Move to gitlab

Author: Setako

.gitignore

@@ -0,0 +1,24 @@
+### MacOS
+.DS_Store/
+
+### Intellij
+.idea/
+*.iml
+*.iws
+
+### Eclipse
+.classpath
+.project
+.settings/
+
+### VSCode
+.vscode/
+
+### Gradle
+.gradle/
+build/
+
+### Java
+*.class
+*.log
+hs_err_pid*

.gitlab-ci.yml

@@ -0,0 +1,29 @@
+image: java:8-jdk
+
+stages:
+  - build
+  - deploy
+
+before_script:
+  - export GRADLE_USER_HOME=`pwd`/.gradle
+
+cache:
+  paths:
+    - .gradle/wrapper
+    - .gradle/caches
+
+build:
+  stage: build
+  script:
+    - ./gradlew build
+  artifacts:
+    paths:
+      - build/libs/*.jar
+    expire_in: 1 week
+  only:
+    - master
+
+deploy:
+  stage: deploy
+  script:
+    - ./gradlew bintrayUpload

LICENSE

@@ -0,0 +1,131 @@
+# Swampium
+
+Swampium core is a spigot plugin framework which provide a better way for developing spigot plugins.
+
+Including:
+ - Dependency injection
+ - Service instance managing
+ - Initialize order resolving
+ - Defined common service interface (for example: economy, faction and configs)
+ - and the utils that you need.
+
+## Build
+If you would like to compile it yourself, clone the project and ensure you have JDK 8.
+
+After that, use `./gradlew build` (`gradlew build` for windows) to start your build.
+
+You can find the compiled jars in `./build/libs`. 
+Use `swampium-*-all.jar` which including the dependencies if you would like to load as spigot plugin.
+
+## Quick start
+### Add as dependency
+For gradle:
+```groovy
+repositories {
+    maven {
+        url https://dl.bintray.com/setako/swamphut
+    }
+}
+
+dependencies {
+    compileOnly "net.swamphut:swampium:0.0.2-rc"
+}
+```
+### Modify your plugin class
+Firstly, create your plugin just like a normal spigot plugin, and add Swampium as depend in your `plugin.yml`.
+```yaml
+depend:
+  - Swampium
+```
+
+Add a annotation `@SwampiumPlugin` on your plugin class, and tell swampium where to find your services.
+The following config will match `net.swamphut.demo.*`.
+```java
+@SwampiumPlugin(servicePackages = "net.swamphut.demo")
+public class DemoPlugin extends JavaPlugin {
+    
+}
+```
+If your services are in multiple packages:
+```java
+@SwampiumPlugin(servicePackages = {"com.otherpackage.test.demo", "net.swamphut.demo"})
+```
+
+### Your first service
+We have defined a testing service interface called `HelloService`,
+let's use it to say hello when our service start.
+ 
+
+```java
+@SwObject
+@ServiceProvider
+public class DemoHelloService implements LifeCycleHook {
+
+    @Inject
+    private HelloService helloService;
+
+    @Override
+    public void init() {
+        helloService.sayHello("demo");
+    }
+}
+```
+
+### Define a service interface
+Although swampium have define the most common features service interfaces, 
+but you can define a new service interface as you wish.
+Don't forgot to create an issues if you found that we are missing an important interface.
+
+Now we are going to define a simple messaging interface.
+Before we start working on it, we have to clearly understand what function should a messaging service have.
+As an example, we will just include some of them:
+ - sendMessage(Player sender, Player receiver, String message)
+ - getMessageSentHistory(Player sender);
+
+Then, we have to analyze should it be an async method, if it should, 
+then let's define its return type as `Observable`/`Single`/`Completable`
+
+```java
+public interface ChattingService{
+    Completable sendMessage(Player sender, Player receiver, String message);
+    Single<List<String>> getMessageSentHistory(Player sender);
+    //more definition...
+}
+```
+
+After we defined the `ChattingService` interface,
+all service which have implements and providing it will be consider as an available `ChattingService`.
+
+### Implement an service provider
+To implement an service interface, we have to use annotation `@ServiceProvider`, 
+and declare which classes you are providing.
+
+Assume that you have completed the above task, and defined a `ChattingService` interface, 
+the tutorial is not going to show how to save the data, so we will not save the message here.
+```java
+@SwObject
+@ServiceProvider(provide = ChattingService.class)
+public class SimpleChattingService implements ChattingService{
+    
+    //Since we are not going to introduce data saving here
+    private Map<Player, List<String>> sentHistories = new HashMap<>();
+    
+    @Override
+    public Completable sendMessage(Player sender, Player receiver, String message){
+        return Completable.fromAction(() -> {
+            receiver.sendMessage("[" + sender + "]" + message);
+            if (!sentHistories.containsKey(sender)){
+                sentHistories.put(sender,new ArrayList<>());
+            }
+            sentHistories.get(sender).add(message);
+        });
+    }
+    
+    @Override
+    public Single<List<String>> getMessageSentHistory(Player sender){
+        return Single.fromCallable(() -> sentHistories.getOrDefault(sender, new ArrayList<>()));
+    }
+}
+```
+
+Now `SimpleChattingService` can be inject as an `ChattingService`

README.md

@@ -0,0 +1,124 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import java.net.URI
+
+group = "net.swamphut"
+version = "0.0.2-snapshot"
+
+val kotlinVersion = "1.3.31"
+
+
+buildscript {
+    repositories {
+        jcenter()
+        mavenCentral()
+    }
+    dependencies {
+        classpath("com.github.jengelman.gradle.plugins:shadow:4.0.3")
+    }
+}
+
+plugins {
+    java
+    maven
+    `maven-publish`
+    kotlin("jvm") version "1.3.31"
+    id("com.jfrog.bintray") version "1.8.4"
+}
+
+apply(plugin = "maven-publish")
+apply(plugin = "com.github.johnrengelman.shadow")
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+val compileKotlin by tasks.getting(KotlinCompile::class) {
+    kotlinOptions.jvmTarget = "1.8"
+    kotlinOptions.freeCompilerArgs = listOf("-Xjvm-default=compatibility")
+}
+
+repositories {
+    mavenCentral()
+    maven { url = URI.create("https://hub.spigotmc.org/nexus/content/repositories/snapshots") }
+    maven { url = URI.create("https://oss.sonatype.org/content/repositories/snapshots/") }
+    maven { url = URI.create("https://dl.bintray.com/setako/swamphut") }
+    maven { url = URI.create("https://repo.codemc.org/repository/maven-public") }
+}
+
+dependencies {
+    listOf(
+            "stdlib-jdk8",
+            "reflect"
+//            "script-util",
+//            "script-runtime",
+//            "compiler-embeddable",
+//            "scripting-compiler"
+    ).forEach { compile(kotlin(it, kotlinVersion)) }
+
+    implementation("org.bstats:bstats-bukkit:1.4")
+
+    compile("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.2.1")
+    compile("io.reactivex.rxjava2:rxjava:2.2.0")
+    compile("org.reflections:reflections:0.9.11")
+
+    compile("com.google.code.gson:gson:2.8.5")
+    compile("org.yaml:snakeyaml:1.24")
+
+    compileOnly("org.spigotmc:spigot-api:1.13.2-R0.1-SNAPSHOT")
+}
+
+val sourcesJar by tasks.registering(Jar::class) {
+    classifier = "sources"
+    from(sourceSets.main.get().allSource)
+}
+
+val shadowJar: ShadowJar by tasks
+shadowJar.apply {
+    baseName = project.name
+    relocate("org.bstats", "net.swamphut.swampium.core")
+}
+
+tasks.getByName("build").dependsOn(shadowJar)
+
+
+tasks.register<Copy>("deployPlugin") {
+    dependsOn(shadowJar)
+    val pluginDeployPath = System.getenv("PLUGIN_DEPLOY_PATH")
+
+    if (pluginDeployPath != null) {
+        from(shadowJar)
+        into(pluginDeployPath)
+    }
+}
+val deployPlugin = tasks.getByName("deployPlugin")
+tasks.getByName("build").dependsOn(deployPlugin)
+
+publishing {
+    publications {
+        create<MavenPublication>("maven") {
+            from(components["java"])
+            artifact(sourcesJar.get())
+            artifact(shadowJar)
+
+            groupId = group.toString()
+            artifactId = project.name
+            version = version
+        }
+    }
+}
+
+bintray {
+    user = System.getenv("BINTRAY_USER")
+    key = System.getenv("BINTRAY_KEY")
+    setPublications("maven")
+    publish = true
+    override = true
+    pkg.apply {
+        repo = "swamphut"
+        name = project.name
+        setLicenses("GPL-3.0")
+        vcsUrl = "https://github.com/SwampHut/Swampium.git"
+    }
+}

build.gradle.kts

@@ -0,0 +1,6 @@
+#Sun Dec 30 15:34:57 HKT 2018
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.0-all.zip