GithubApi work.

kobalt/src/Build.kt

@@ -74,6 +74,9 @@ val kobalt = kotlinProject(wrapper) {
                 "com.github.spullara.mustache.java:compiler:0.9.1",
                 "io.reactivex:rxjava:1.0.14",
                 "com.google.code.gson:gson:2.4",
+                "com.squareup.retrofit:retrofit:1.9.0",
+//                "com.squareup.retrofit:retrofit:2.0.0-beta2",
+//                "com.squareup.retrofit:converter-gson:2.0.0-beta2",
                 file("modules/wrapper/kobaltBuild/libs/kobalt-wrapper.jar")
               )
     }

src/main/kotlin/com/beust/kobalt/misc/GithubApi.kt

@@ -3,29 +3,164 @@ package com.beust.kobalt.misc
 import com.google.gson.JsonArray
 import com.google.gson.JsonObject
 import com.google.gson.JsonParser
-import javax.inject.Inject
+import com.google.gson.annotations.SerializedName
+import com.squareup.okhttp.OkHttpClient
+import retrofit.RestAdapter
+import retrofit.client.OkClient
+import retrofit.http.*
+import rx.Observable
+import rx.Observer
 import java.io.BufferedReader
+import java.io.File
 import java.io.IOException
 import java.io.InputStreamReader
 import java.net.URL
 import java.util.concurrent.Callable
 import java.util.concurrent.Future
+import javax.inject.Inject
 
 /**
  * Retrieve Kobalt's latest release version from github.
  */
 public class GithubApi @Inject constructor(val executors: KobaltExecutors) {
     companion object {
-        const val HOST = "https://api.github.com/"
+        const val HOST =
+                "https://api.github.com"
+//                "https://developer.github.com/v3/"
+        const val RELEASES_URL = "$HOST/repos/cbeust/kobalt/releases"
     }
 
+    public class ServiceGenerator {
+        companion object {
+            val API_BASE_URL = HOST
+
+            val httpClient = OkHttpClient()
+            val builder = RestAdapter.Builder()
+                    .setEndpoint(API_BASE_URL)
+//                    .baseUrl(API_BASE_URL)
+//                    .addConverterFactory(GsonConverterFactory.create())
+
+            class Contributor {
+                var login: String? = null
+                var contributions: Int? = null
+            }
+
+            class Release {
+                var name: String? = null
+                var prerelease: Boolean? = null
+            }
+
+            val ACCESS_TOKEN = "5368d5cc49727a3b3e5ea8b320be0149aab5283d"
+
+            class UploadReleaseResponse(var id: String? = null)
+
+            class CreateRelease(@SerializedName("tag_name") var tag_name: String? = null)
+//            class CreateRelease(
+//                    @Query("tag_name") tag_name: String,
+//                    @Query("target_commitish") target: String,
+//                    @Query("name") name: String,
+//                    @Query("body") body: String,
+//                    @Query("draft") draft : Boolean,
+//                    @Query("prerelease") prerelease: Boolean
+//            )
+            class CreateReleaseResponse(var id: String? = null)
+
+            interface Api {
+                @GET("/repos/{owner}/{repo}/contributors")
+                fun contributors(@Path("owner") owner: String, @Path("repo") repo: String): List<Contributor>
+
+                @GET("/repos/{owner}/{repo}/releases")
+                fun releases(@Path("owner") owner: String, @Path("repo") repo: String): List<Release>
+
+                @POST("/repos/{owner}/{repo}/releases")
+                fun createRelease(@Path("owner") owner: String, @Path("repo") repo: String,
+                        @Query("access_token") accessToken: String,
+                        @Body createRelease: CreateRelease
+                ) : Observable<CreateReleaseResponse>
+
+                @POST("/repos/{owner}/{repo}/releases/{id}/assets")
+                fun uploadRelease(@Path("owner") owner: String, @Path("repo") repo: String,
+                        @Path("id") id: String,
+                        @Query("name") name: String,
+                        @Query("label") label: String,
+                        @Body file: File,
+                        @Query("Content-Type") contentType: String = "application/zip")
+                    : Observable<UploadReleaseResponse>
+
+            }
+
+            val service : Api by lazy { ServiceGenerator.createService(Api::class.java) }
+
+            fun <S> createService(serviceClass: Class<S>): S {
+                val retrofit = builder
+                        .setEndpoint(HOST)
+                        .setLogLevel(RestAdapter.LogLevel.FULL)
+                        .setClient(OkClient(OkHttpClient()))
+
+                //                        .setClient(httpClient)
+                        .build()
+                return retrofit.create(serviceClass)
+            }
+
+            fun uploadRelease() {
+                val id = createRelease()
+
+//                val typedFile = File("c:\\users\\cbeust\\t\\a.zip")
+//                s.uploadRelease("cbeust", "kobalt", "42", "kobalt-0.500", "0.500", typedFile)
+//                        .subscribe(object: Observer<UploadReleaseResponse> {
+//                            override fun onCompleted() {
+//                                println("Call completed")
+//                            }
+//
+//                            override fun onNext(response: UploadReleaseResponse?) {
+//                                println("Received response: $response")
+//                            }
+//
+//                            override fun onError(e: Throwable) {
+//                                println("Error: $e")
+//                            }
+//
+//                        })
+            }
+            fun createRelease() : Int {
+                println("createRelease()")
+                service.createRelease("cbeust", "kobalt", ACCESS_TOKEN,
+//                        hashMapOf("tag_name" to "0.502tagName")
+                        CreateRelease("0.503tagName")
+//                        CreateRelease().apply { tag_name = "0.500tagName"}
+//                        CreateRelease("0.500tagName",
+//                        "master", "0.500name",
+//                        "A test release",
+//                        draft = false, prerelease = true)
+                )
+                    .subscribe(object: Observer<CreateReleaseResponse> {
+                        override fun onCompleted() {
+                            println("Call completed")
+                        }
+
+                        override fun onNext(response: CreateReleaseResponse?) {
+                            println("Received response: $response")
+                        }
+
+                        override fun onError(e: Throwable) {
+                            println("Error: $e")
+                        }
+
+                    })
+                Thread.sleep(10000)
+                return 0
+            }
+
+        }
+    }
+
+
     val latestKobaltVersion: Future<String>
         get() {
             val callable = Callable<String> {
                 var result = "0"
-                val url = HOST + "repos/cbeust/kobalt/releases"
                 try {
-                    val ins = URL(url).openConnection().inputStream
+                    val ins = URL(RELEASES_URL).openConnection().inputStream
                     @Suppress("UNCHECKED_CAST")
                     val reader = BufferedReader(InputStreamReader(ins))
                     val jo = JsonParser().parse(reader) as JsonArray
@@ -40,7 +175,7 @@ public class GithubApi @Inject constructor(val executors: KobaltExecutors) {
                         }
                     }
                 } catch(ex: IOException) {
-                    warn("Couldn't load the release URL: $url")
+                    warn("Couldn't load the release URL: $RELEASES_URL")
                 }
                 result
             }