GH-8 More docs and rename (#8)

* Add more docs

* Update HttpClient.java

Author: vLuckyyy

README.md

@@ -1,11 +1,79 @@
-# EternalUpdater
-✔ Updater for EternalCode plugins
+# Updater 
 
+#### Updater is a library for checking for updates for your plugin on GitHub. It uses the GitHub API to get information about the latest release of your plugin and compare it to the current version of your plugin.
+
+### Usage
+First, you need to create an instance of the `Updater` class by passing the plugin name, current version, and Github repository name as arguments. Then, you can call the `checkUpdates()` method to check for updates and get the `RemoteInformation` object.
+
+The `RemoteInformation` object contains information about the update, such as the availability of a new version, the current version, and the download URI.
+
+```java
+if (remoteInformation.isAvailableNewVersion()) {
+    System.out.println("A new version is available: " + remoteInformation.getCurrentVersion());
+    System.out.println("Download URI: " + remoteInformation.getDownloadUri());
+} else {
+    System.out.println("You are already running the latest version.");
+}
+```
+
+### Example
+Here's an example of how to can use the Updater in `Spigot` plugin
 
-# Example usage
 ```java
-import com.eternalcode.eternalupdater.EternalUpdater;
 
-EternalUpdater eternalUpdater = new EternalUpdater("name", "currentPluginVer", "githubrepo");
-RemoteInformation pluginUpdate = eternalUpdater.checkUpdates();
-```
+import com.eternalcode.updater.Updater;
+import com.eternalcode.updater.http.RemoteInformation;
+
+public class MyPlugin {
+
+    private Updater updater;
+
+    public void onEnable() {
+        updater = new Updater("MyPlugin", "1.0", "MyGithubUsername/MyPlugin");
+        checkForUpdates();
+    }
+
+    private void checkForUpdates() {
+        RemoteInformation remoteInformation = updater.checkUpdates();
+        if (remoteInformation.isAvailableNewVersion()) {
+            System.out.println("A new version is available: " + remoteInformation.getCurrentVersion());
+            System.out.println("Download URI: " + remoteInformation.getDownloadUri());
+        } else {
+            System.out.println("You are already running the latest version.");
+        }
+    }
+}
+```
+
+### Maven/Gradle
+Get the latest version from [EternalCode Repository](https://repo.eternalcode.pl/#/releases/com/eternalcode/eternalupdater)
+
+#### gradle groovy
+```groovy
+maven { url "https://repo.eternalcode.pl/releases" }
+
+implementation "com.eternalcode:updater:{VERSION}"
+```
+
+```kotlin
+maven { url = uri("https://repo.eternalcode.pl/releases") }
+
+implementation("com.eternalcode:updater:{VERSION}")
+```
+
+```xml
+<repository>
+  <id>eternalcode-reposilite-releases</id>
+  <name>EternalCode Repository</name>
+  <url>https://repo.eternalcode.pl/releases</url>
+</repository>
+
+<dependency>
+<groupId>com.eternalcode</groupId>
+<artifactId>updater</artifactId>
+<version>{VERSION}</version>
+</dependency>
+```
+
+
+

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/com/eternalcode/eternalupdater/EternalUpdater.java

@@ -0,0 +1,56 @@
+package com.eternalcode.updater;
+
+import org.jetbrains.annotations.Contract;
+
+/**
+ * The PluginData class is used to store information about a plugin.
+ */
+public class PluginData {
+
+    private final String githubRepository;
+    private final String pluginVersion;
+    private final String pluginName;
+
+    /**
+     * Creates a new instance of PluginData with the GitHub repository name, plugin version, and plugin name.
+     *
+     * @param githubRepository The GitHub repository name
+     * @param pluginVersion The version of the plugin
+     * @param pluginName The name of the plugin
+     */
+    public PluginData(String githubRepository, String pluginVersion, String pluginName) {
+        this.githubRepository = githubRepository;
+        this.pluginVersion = pluginVersion;
+        this.pluginName = pluginName;
+    }
+
+    /**
+     * Returns the GitHub repository name
+     *
+     * @return The GitHub repository name
+     */
+    @Contract(pure = true)
+    public String getGithubRepository() {
+        return this.githubRepository;
+    }
+
+    /**
+     * Returns the version of the plugin
+     *
+     * @return The version of the plugin
+     */
+    @Contract(pure = true)
+    public String getPluginVersion() {
+        return this.pluginVersion;
+    }
+
+    /**
+     * Returns the name of the plugin
+     *
+     * @return The name of the plugin
+     */
+    @Contract(pure = true)
+    public String getPluginName() {
+        return this.pluginName;
+    }
+}

src/main/java/com/eternalcode/eternalupdater/data/PluginData.java

@@ -0,0 +1,47 @@
+package com.eternalcode.updater;
+
+import com.eternalcode.updater.http.RemoteInformation;
+import com.eternalcode.updater.http.HttpClient;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.json.simple.JSONObject;
+
+/**
+ * The Updater class is used to check for updates for a plugin.
+ */
+public class Updater {
+
+    private final PluginData pluginData;
+
+    /**
+     * Creates a new instance of Updater with the plugin name, plugin version, and GitHub remote repository name.
+     *
+     * @param pluginName The name of the plugin
+     * @param pluginVersion The current version of the plugin
+     * @param githubRepository The name of the GitHub remote repository (e.g. eternalcodeteam/eternalcore)
+     */
+    public Updater(@NotNull String pluginName, @NotNull String pluginVersion, @NotNull String githubRepository) {
+        this.pluginData = new PluginData(githubRepository, pluginVersion, pluginName);
+    }
+
+    /**
+     * Checks for updates for the plugin.
+     *
+     * @return Remote plugin information
+     * @throws RuntimeException If there is a connection problem or the remote repository is not found
+     */
+    @Contract(pure = true)
+    public RemoteInformation checkUpdates() {
+        JSONObject response = HttpClient.doRequest("repos/" + this.pluginData.getGithubRepository() + "/releases/latest");
+        boolean newVersionAvailable = !this.pluginData.getPluginVersion().equals(response.get("tag_name"));
+        String latestTag = (String) response.get("tag_name");
+        String newDownloadUri = (String) response.get("zipball_url");
+
+        return new RemoteInformation(
+                newVersionAvailable,
+                latestTag,
+                newDownloadUri
+        );
+    }
+
+}

src/main/java/com/eternalcode/eternalupdater/data/RemoteInformation.java

@@ -1,16 +1,28 @@
-package com.eternalcode.eternalupdater.util;
+package com.eternalcode.updater.http;
 
 import okhttp3.OkHttpClient;
 import okhttp3.Request;
 import okhttp3.Response;
+import org.jetbrains.annotations.Contract;
 import org.json.simple.JSONObject;
 import org.json.simple.parser.JSONParser;
 
+/**
+ * The HttpClient class is used to send HTTP requests to the GitHub server.
+ */
 public class HttpClient {
 
     private final static String baseUri = "https://api.github.com/";
     private final static OkHttpClient client = new OkHttpClient();
 
+    /**
+     * Sends an HTTP request to the GitHub server and returns the response as a JSON object.
+     *
+     * @param url The URL of the request
+     * @return The server's response in JSON format
+     * @throws RuntimeException If there is a connection problem or the provided repository is not found
+     */
+    @Contract(pure = true)
     public static JSONObject doRequest(String url) {
         Request request = new Request
                 .Builder()
@@ -26,9 +38,9 @@ public static JSONObject doRequest(String url) {
             else {
                 return jsonResponse;
             }
-        } catch (Exception e) {
-            throw new RuntimeException(e);
+        }
+        catch (Exception exception) {
+            throw new RuntimeException(exception);
         }
     }
-
 }

src/main/java/com/eternalcode/updater/PluginData.java

@@ -0,0 +1,55 @@
+package com.eternalcode.updater.http;
+
+import org.jetbrains.annotations.Contract;
+
+/**
+ * The RemoteInformation class is used to store information about a plugin update.
+ */
+public class RemoteInformation {
+    private final boolean isAvailableNewVersion;
+    private final String currentVersion;
+    private final String downloadUri;
+
+    /**
+     * Creates a new instance of RemoteInformation with the update availability, current version, and download URI.
+     *
+     * @param isAvailableNewVersion True if a new version is available, false otherwise
+     * @param currentVersion The current version of the plugin
+     * @param downloadUri The URI to download the update
+     */
+    public RemoteInformation(boolean isAvailableNewVersion, String currentVersion, String downloadUri) {
+        this.isAvailableNewVersion = isAvailableNewVersion;
+        this.currentVersion = currentVersion;
+        this.downloadUri = downloadUri;
+    }
+
+    /**
+     * Returns the URI to download the update
+     *
+     * @return The URI to download the update
+     */
+    @Contract(pure = true)
+    public String getDownloadUri() {
+        return this.downloadUri;
+    }
+
+    /**
+     * Indicates if a new version is available
+     *
+     * @return True if a new version is available, false otherwise
+     */
+    @Contract(pure = true)
+    public boolean isAvailableNewVersion() {
+        return this.isAvailableNewVersion;
+    }
+
+    /**
+     * Returns the current version of the plugin
+     *
+     * @return The current version of the plugin
+     */
+    @Contract(pure = true)
+    public String getCurrentVersion() {
+        return this.currentVersion;
+    }
+}