Merge pull request #20 from EddieRingle/kotlin-m12

Update to Kotlin M12

Author: MarioAriasC

build.gradle

@@ -1,16 +1,16 @@
 buildscript {
   repositories { jcenter() }
   dependencies { classpath 'com.netflix.nebula:gradle-rxjava-project-plugin:2.+',
-                           'org.jetbrains.kotlin:kotlin-gradle-plugin:0.11.+' }
+                           'org.jetbrains.kotlin:kotlin-gradle-plugin:0.12.+' }
 }
 
 apply plugin: 'rxjava-project'
 apply plugin: 'kotlin'
 
 dependencies {
     compile 'io.reactivex:rxjava:1.0.+'
-    compile 'org.jetbrains.kotlin:kotlin-stdlib:0.11.+'
-    compile 'org.funktionale:funktionale:0.4.2_M11'
+    compile 'org.jetbrains.kotlin:kotlin-stdlib:0.12.+'
+    compile 'org.funktionale:funktionale:0.5.1_M12'
     testCompile 'junit:junit:4.12'
     testCompile 'org.mockito:mockito-core:1.8.5'
     examplesCompile 'com.squareup.retrofit:retrofit:1.9.+'

src/examples/kotlin/rx/lang/kotlin/examples/examples.kt

@@ -10,11 +10,11 @@ import rx.lang.kotlin.onError
 
 fun main(args: Array<String>) {
 
-    val printArticle = {(art: String) ->
+    val printArticle = { art: String ->
         println("--- Article ---\n${art.substring(0, 125)}")
     }
 
-    val printIt = {(it: String) -> println(it) }
+    val printIt = { it: String -> println(it) }
 
     asyncObservable().subscribe(printIt)
 

src/examples/kotlin/rx/lang/kotlin/examples/retrofit.kt

@@ -10,7 +10,7 @@ data class SearchResultEntry(val id : String, val latestVersion : String)
 data class SearchResults(val docs : List<SearchResultEntry>)
 data class MavenSearchResponse(val response : SearchResults)
 
-trait MavenSearchService {
+interface MavenSearchService {
     GET("/solrsearch/select?wt=json")
     fun search(Query("q") s : String, Query("rows") rows : Int = 20) : Observable<MavenSearchResponse>
 }

src/main/kotlin/rx/lang/kotlin/observables.kt

@@ -27,13 +27,13 @@ public fun <T> Array<out T>.toObservable() : Observable<T> = Observable.from(thi
 
 public fun Progression<Int>.toObservable() : Observable<Int> =
         if (increment == 1 && end.toLong() - start < Integer.MAX_VALUE) Observable.range(start, Math.max(0, end - start + 1))
-        else (this : Iterable<Int>).toObservable()
+        else Observable.from(this)
 
 public fun <T> Iterator<T>.toObservable() : Observable<T> = toIterable().toObservable()
 public fun <T> Iterable<T>.toObservable() : Observable<T> = Observable.from(this)
 public fun <T> Sequence<T>.toObservable() : Observable<T> = Observable.from(object : Iterable<T> {
     override fun iterator(): Iterator<T> = this@toObservable.iterator()
-}) : Observable<T>
+})
 
 public fun <T> T.toSingletonObservable() : Observable<T> = Observable.just(this)
 public fun <T> Throwable.toObservable() : Observable<T> = Observable.error(this)
@@ -44,11 +44,11 @@ public fun <T> Iterable<Observable<out T>>.mergeDelayError() : Observable<T> = O
 
 public fun <T, R> Observable<T>.fold(initial : R, body : (R, T) -> R) : Observable<R> = reduce(initial, {a, e -> body(a, e)})
 public fun <T> Observable<T>.onError(block : (Throwable) -> Unit) : Observable<T> = doOnError(block)
-[suppress("BASE_WITH_NULLABLE_UPPER_BOUND")]
+@suppress("BASE_WITH_NULLABLE_UPPER_BOUND")
 public fun <T> Observable<T>.firstOrNull() : Observable<T?> = firstOrDefault(null)
 public fun <T> BlockingObservable<T>.firstOrNull() : T = firstOrDefault(null)
 
-[suppress("BASE_WITH_NULLABLE_UPPER_BOUND")]
+@suppress("BASE_WITH_NULLABLE_UPPER_BOUND")
 public fun <T> Observable<T>.onErrorReturnNull() : Observable<T?> = onErrorReturn {null}
 
 public fun <T, R> Observable<T>.lift(operator : (Subscriber<in R>) -> Subscriber<T>) : Observable<R> = lift(object : Observable.Operator<R, T> {

src/test/kotlin/rx/lang/kotlin/BasicKotlinTests.kt

@@ -33,7 +33,7 @@ import rx.Subscriber
 public class BasicKotlinTests : KotlinTests() {
 
 
-    [Test]
+    @Test
     public fun testCreate() {
 
         Observable.create(object:OnSubscribe<String> {
@@ -48,46 +48,46 @@ public class BasicKotlinTests : KotlinTests() {
         verify(a, times(1)).received("Hello")
     }
 
-    [Test]
+    @Test
     public fun testFilter() {
         Observable.from(listOf(1, 2, 3)).filter { it >= 2 }.subscribe(received)
         verify(a, times(0)).received(1);
         verify(a, times(1)).received(2);
         verify(a, times(1)).received(3);
     }
 
-    [Test]
+    @Test
     public fun testLast() {
         assertEquals("three", Observable.from(listOf("one", "two", "three")).toBlocking().last())
     }
 
-    [Test]
+    @Test
     public fun testLastWithPredicate() {
         assertEquals("two", Observable.from(listOf("one", "two", "three")).toBlocking().last { x -> x.length() == 3 })
     }
 
-    [Test]
+    @Test
     public fun testMap1() {
         Observable.just(1).map { v -> "hello_$v" }.subscribe(received)
         verify(a, times(1)).received("hello_1")
     }
 
-    [Test]
+    @Test
     public fun testMap2() {
         Observable.from(listOf(1, 2, 3)).map { v -> "hello_$v" }.subscribe(received)
         verify(a, times(1)).received("hello_1")
         verify(a, times(1)).received("hello_2")
         verify(a, times(1)).received("hello_3")
     }
 
-    [Test]
+    @Test
     public fun testMaterialize() {
         Observable.from(listOf(1, 2, 3)).materialize().subscribe(received)
         verify(a, times(4)).received(any(javaClass<Notification<Int>>()))
         verify(a, times(0)).error(any(javaClass<Exception>()))
     }
 
-    [Test]
+    @Test
     public fun testMerge() {
         Observable.merge(
                 Observable.from(listOf(1, 2, 3)),
@@ -108,139 +108,139 @@ public class BasicKotlinTests : KotlinTests() {
         verify(a, times(1)).error(any(javaClass<NullPointerException>()))
     }
 
-    [Test]
+    @Test
     public fun testScriptWithMaterialize() {
         TestFactory().observable.materialize().subscribe(received)
         verify(a, times(2)).received(any(javaClass<Notification<Int>>()))
     }
 
-    [Test]
+    @Test
     public fun testScriptWithMerge() {
         val factory = TestFactory()
         Observable.merge(factory.observable, factory.observable).subscribe(received)
         verify(a, times(1)).received("hello_1")
         verify(a, times(1)).received("hello_2")
     }
 
-    [Test]
+    @Test
     public fun testFromWithIterable() {
         val list = listOf(1, 2, 3, 4, 5)
         assertEquals(5, Observable.from(list).count().toBlocking().single())
     }
 
-    [Test]
+    @Test
     public fun testFromWithObjects() {
         val list = listOf(1, 2, 3, 4, 5)
         assertEquals(2, Observable.from(listOf(list, 6)).count().toBlocking().single())
     }
 
-    [Test]
+    @Test
     public fun testStartWith() {
         val list = listOf(10, 11, 12, 13, 14)
         val startList = listOf(1, 2, 3, 4, 5)
         assertEquals(6, Observable.from(list).startWith(0).count().toBlocking().single())
         assertEquals(10, Observable.from(list).startWith(startList).count().toBlocking().single())
     }
 
-    [Test]
+    @Test
     public fun testScriptWithOnNext() {
         TestFactory().observable.subscribe(received)
         verify(a, times(1)).received("hello_1")
     }
 
-    [Test]
+    @Test
     public fun testSkipTake() {
         Observable.from(listOf(1, 2, 3)).skip(1).take(1).subscribe(received)
         verify(a, times(0)).received(1)
         verify(a, times(1)).received(2)
         verify(a, times(0)).received(3)
     }
 
-    [Test]
+    @Test
     public fun testSkip() {
         Observable.from(listOf(1, 2, 3)).skip(2).subscribe(received)
         verify(a, times(0)).received(1)
         verify(a, times(0)).received(2)
         verify(a, times(1)).received(3)
     }
 
-    [Test]
+    @Test
     public fun testTake() {
         Observable.from(listOf(1, 2, 3)).take(2).subscribe(received)
         verify(a, times(1)).received(1)
         verify(a, times(1)).received(2)
         verify(a, times(0)).received(3)
     }
 
-    [Test]
+    @Test
     public fun testTakeLast() {
         TestFactory().observable.takeLast(1).subscribe(received)
         verify(a, times(1)).received("hello_1")
     }
 
-    [Test]
+    @Test
     public fun testTakeWhile() {
         Observable.from(listOf(1, 2, 3)).takeWhile { x -> x < 3 }.subscribe(received)
         verify(a, times(1)).received(1)
         verify(a, times(1)).received(2)
         verify(a, times(0)).received(3)
     }
 
-    [Test]
+    @Test
     public fun testTakeWhileWithIndex() {
         Observable.from(listOf(1, 2, 3)).takeWhile { x -> x < 3 }.zipWith(Observable.range(0,Integer.MAX_VALUE)){ x, i -> x }.subscribe(received)
         verify(a, times(1)).received(1)
         verify(a, times(1)).received(2)
         verify(a, times(0)).received(3)
     }
 
-    [Test]
+    @Test
     public fun testToSortedList() {
         TestFactory().numbers.toSortedList().subscribe(received)
         verify(a, times(1)).received(listOf(1, 2, 3, 4, 5))
     }
 
-    [Test]
+    @Test
     public fun testForEach() {
         Observable.create(AsyncObservable()).toBlocking().forEach(received)
         verify(a, times(1)).received(1)
         verify(a, times(1)).received(2)
         verify(a, times(1)).received(3)
     }
 
-    [Test(expected = javaClass<RuntimeException>())]
+    @Test(expected = RuntimeException::class)
     public fun testForEachWithError() {
         Observable.create(AsyncObservable()).toBlocking().forEach { throw RuntimeException("err") }
         fail("we expect an exception to be thrown")
     }
 
-    [Test]
+    @Test
     public fun testLastOrDefault() {
         assertEquals("two", Observable.from(listOf("one", "two")).toBlocking().lastOrDefault("default") { x -> x.length() == 3 })
         assertEquals("default", Observable.from(listOf("one", "two")).toBlocking().lastOrDefault("default") { x -> x.length() > 3 })
     }
 
-    [Test(expected = javaClass<IllegalArgumentException>())]
+    @Test(expected = IllegalArgumentException::class)
     public fun testSingle() {
         assertEquals("one", Observable.just("one").toBlocking().single { x -> x.length() == 3 })
         Observable.from(listOf("one", "two")).toBlocking().single { x -> x.length() == 3 }
         fail()
     }
 
-    [Test]
+    @Test
     public fun testDefer() {
         Observable.defer { Observable.from(listOf(1, 2)) }.subscribe(received)
         verify(a, times(1)).received(1)
         verify(a, times(1)).received(2)
     }
 
-    [Test]
+    @Test
     public fun testAll() {
         Observable.from(listOf(1, 2, 3)).all { x -> x > 0 }.subscribe(received)
         verify(a, times(1)).received(true)
     }
 
-    [Test]
+    @Test
     public fun testZip() {
         val o1 = Observable.from(listOf(1, 2, 3))
         val o2 = Observable.from(listOf(4, 5, 6))
@@ -252,7 +252,7 @@ public class BasicKotlinTests : KotlinTests() {
         assertEquals(listOf(3, 6, 9), values[2])
     }
 
-    [Test]
+    @Test
     public fun testZipWithIterable() {
         val o1 = Observable.from(listOf(1, 2, 3))
         val o2 = Observable.from(listOf(4, 5, 6))
@@ -264,7 +264,7 @@ public class BasicKotlinTests : KotlinTests() {
         assertEquals(listOf(3, 6, 9), values[2])
     }
 
-    [Test]
+    @Test
     public fun testGroupBy() {
         var count = 0