Merge pull request #23 from cbruegg/0.x

Migrate to Kotlin M13

Author: MarioAriasC

build.gradle

@@ -1,16 +1,17 @@
 buildscript {
+  ext.kotlin_version = '0.13.1513'
   repositories { jcenter() }
   dependencies { classpath 'com.netflix.nebula:gradle-rxjava-project-plugin:2.+',
-                           'org.jetbrains.kotlin:kotlin-gradle-plugin:0.12.+' }
+                           "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" }
 }
 
 apply plugin: 'rxjava-project'
 apply plugin: 'kotlin'
 
 dependencies {
     compile 'io.reactivex:rxjava:1.0.+'
-    compile 'org.jetbrains.kotlin:kotlin-stdlib:0.12.+'
-    compile 'org.funktionale:funktionale:0.5.1_M12'
+    compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    compile 'org.funktionale:funktionale:0.6_M13'
     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/retrofit.kt

@@ -11,15 +11,15 @@ data class SearchResults(val docs : List<SearchResultEntry>)
 data class MavenSearchResponse(val response : SearchResults)
 
 interface MavenSearchService {
-    GET("/solrsearch/select?wt=json")
-    fun search(Query("q") s : String, Query("rows") rows : Int = 20) : Observable<MavenSearchResponse>
+    @GET("/solrsearch/select?wt=json")
+    fun search(@Query("q") s : String, @Query("rows") rows : Int = 20) : Observable<MavenSearchResponse>
 }
 
 fun main(args: Array<String>) {
     val service = RestAdapter.Builder().
             setEndpoint("http://search.maven.org").
             build().
-            create(javaClass<MavenSearchService>())
+            create(MavenSearchService::class.java)
 
     service.search("rxkotlin").
             flatMapIterable { it.response.docs }.

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

@@ -19,62 +19,62 @@ package rx.lang.kotlin
 import rx.Observable
 import rx.Subscriber
 
-deprecated("use observable {} instead")
+@Deprecated("use observable {} instead")
 public fun<T> Function1<Subscriber<in T>, Unit>.asObservable(): Observable<T> {
     return Observable.create(this)
 }
 
-deprecated("use deferredObservable {} instead")
+@Deprecated("use deferredObservable {} instead")
 public fun<T> Function0<Observable<T>>.defer(): Observable<T> {
     return Observable.defer(this)
 }
 
-deprecated("use toObservable() instead")
+@Deprecated("use toObservable() instead")
 fun IntRange.asObservable(): Observable<Int> {
     return Observable.range(start, end)
 }
 
-deprecated("use toObservable() instead")
+@Deprecated("use toObservable() instead")
 public fun<T> Iterable<T>.asObservable(): Observable<T> {
     return Observable.from(this)
 }
 
-deprecated("use toSingletonObservable() instead")
+@Deprecated("use toSingletonObservable() instead")
 public fun<T> T.asObservable(): Observable<T> {
     return Observable.just(this)
 }
 
-deprecated("use toObservable() instead")
+@Deprecated("use toObservable() instead")
 public fun<T> Throwable.asObservable(): Observable<T> {
     return Observable.error(this)
 }
 
-deprecated("use listOf().toObservable() instead")
+@Deprecated("use listOf().toObservable() instead")
 public fun<T> Pair<T, T>.asObservable(): Observable<T> {
     return Observable.from(listOf(first, second))
 }
 
-deprecated("use listOf().toObservable() instead")
+@Deprecated("use listOf().toObservable() instead")
 public fun<T> Triple<T, T, T>.asObservable(): Observable<T> {
     return Observable.from(listOf(first, second, third))
 }
 
-deprecated("use first.mergeWith(second) or listOf(first, second).merge() instead")
+@Deprecated("use first.mergeWith(second) or listOf(first, second).merge() instead")
 public fun<T> Pair<Observable<T>, Observable<T>>.merge(): Observable<T> {
     return Observable.merge(first, second)
 }
 
-deprecated("use listOf(first, second, third).merge() instead")
+@Deprecated("use listOf(first, second, third).merge() instead")
 public fun<T> Triple<Observable<T>, Observable<T>, Observable<T>>.merge(): Observable<T> {
     return Observable.merge(first, second, third)
 }
 
-deprecated("use listOf(first, second).mergeDelayError() instead")
+@Deprecated("use listOf(first, second).mergeDelayError() instead")
 public fun<T> Pair<Observable<T>, Observable<T>>.mergeDelayError(): Observable<T> {
     return Observable.mergeDelayError(first, second)
 }
 
-deprecated("use listOf(first, second, third).mergeDelayError() instead")
+@Deprecated("use listOf(first, second, third).mergeDelayError() instead")
 public fun<T> Triple<Observable<T>, Observable<T>, Observable<T>>.mergeDelayError(): Observable<T> {
     return Observable.mergeDelayError(first, second, third)
 }

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

@@ -44,12 +44,12 @@ 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")
-public fun <T> Observable<T>.onErrorReturnNull() : Observable<T?> = onErrorReturn {null}
+@Suppress("BASE_WITH_NULLABLE_UPPER_BOUND")
+public fun <T> Observable<T>.onErrorReturnNull() : Observable<T?> = onErrorReturn<T> {null}
 
 public fun <T, R> Observable<T>.lift(operator : (Subscriber<in R>) -> Subscriber<T>) : Observable<R> = lift(object : Observable.Operator<R, T> {
     override fun call(t1: Subscriber<in R>?): Subscriber<in T> = operator(t1!!)

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

@@ -83,8 +83,8 @@ public class BasicKotlinTests : KotlinTests() {
     @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>()))
+        verify(a, times(4)).received(any(Notification::class.java))
+        verify(a, times(0)).error(any(Exception::class.java))
     }
 
     @Test
@@ -105,13 +105,13 @@ public class BasicKotlinTests : KotlinTests() {
         verify(a, times(0)).received(5)
         verify(a, times(1)).received(6)
         verify(a, times(0)).received(7)
-        verify(a, times(1)).error(any(javaClass<NullPointerException>()))
+        verify(a, times(1)).error(any(NullPointerException::class.java))
     }
 
     @Test
     public fun testScriptWithMaterialize() {
         TestFactory().observable.materialize().subscribe(received)
-        verify(a, times(2)).received(any(javaClass<Notification<Int>>()))
+        verify(a, times(2)).received(any(Notification::class.java))
     }
 
     @Test
@@ -272,7 +272,7 @@ public class BasicKotlinTests : KotlinTests() {
                 .groupBy { s -> s.length() }
                 .flatMap { groupObervable ->
                     groupObervable.map { s ->
-                        "Value: $s Group ${groupObervable.getKey()}"
+                        "Value: $s Group ${groupObervable.key}"
                     }
                 }.toBlocking().forEach { s ->
             println(s)

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

@@ -81,8 +81,8 @@ public class ExtensionTests : KotlinTests() {
     @Test
     public fun testMaterialize() {
         listOf(1, 2, 3).toObservable().materialize().subscribe((received))
-        verify(a, times(4)).received(any(javaClass<Notification<Int>>()))
-        verify(a, times(0)).error(any(javaClass<Exception>()))
+        verify(a, times(4)).received(any(Notification::class.java))
+        verify(a, times(0)).error(any(Exception::class.java))
     }
 
 
@@ -102,13 +102,13 @@ public class ExtensionTests : KotlinTests() {
         verify(a, times(0)).received(5)
         verify(a, times(1)).received(6)
         verify(a, times(0)).received(7)
-        verify(a, times(1)).error(any(javaClass<NullPointerException>()))
+        verify(a, times(1)).error(any(NullPointerException::class.java))
     }
 
     @Test
     public fun testScriptWithMaterialize() {
         TestFactory().observable.materialize().subscribe((received))
-        verify(a, times(2)).received(any(javaClass<Notification<Int>>()))
+        verify(a, times(2)).received(any(Notification::class.java))
     }
 
     @Test

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

@@ -30,7 +30,7 @@ public abstract class KotlinTests {
         MockitoAnnotations.initMocks(this)
     }
 
-    suppress("BASE_WITH_NULLABLE_UPPER_BOUND")
+    @Suppress("BASE_WITH_NULLABLE_UPPER_BOUND")
     val <T> received = {result: T? -> a.received(result) }
 
     public interface ScriptAssertion {

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

@@ -10,7 +10,7 @@ import org.junit.Ignore
 
 
 public class ObservablesTest {
-    test fun testCreation() {
+    @test fun testCreation() {
         val o0 : Observable<Int> = emptyObservable()
         observable<Int> { s -> s.onNext(1); s.onNext(777); s.onCompleted() }.toList().forEach {
             assertEquals(listOf(1, 777), it)
@@ -30,7 +30,7 @@ public class ObservablesTest {
         assertNotNull(o5)
     }
 
-    test fun testExampleFromReadme() {
+    @test fun testExampleFromReadme() {
         val result = observable<String> { subscriber ->
             subscriber.onNext("H")
             subscriber.onNext("e")
@@ -47,39 +47,39 @@ public class ObservablesTest {
         assertEquals("Hello", result)
     }
 
-    test fun iteratorObservable() {
+    @test fun iteratorObservable() {
         assertEquals(listOf(1,2,3), listOf(1,2,3).iterator().toObservable().toList().toBlocking().single())
     }
 
-    test fun intProgressionStep1Empty() {
+    @test fun intProgressionStep1Empty() {
         assertEquals(listOf(1), (1..1).toObservable().toList().toBlocking().first())
     }
-    test fun intProgressionStep1() {
+    @test fun intProgressionStep1() {
         assertEquals((1..10).toList(), (1..10).toObservable().toList().toBlocking().first())
     }
 
-    test fun intProgressionDownto() {
+    @test fun intProgressionDownto() {
         assertEquals((1 downTo 10).toList(), (1 downTo 10).toObservable().toList().toBlocking().first())
     }
 
-    Ignore
-    test fun intProgressionOverflow() {
+    @Ignore
+    @test fun intProgressionOverflow() {
         // too slow
-        assertEquals((0..10).toList().reverse(), (-10 .. Integer.MAX_VALUE).toObservable().skip(Integer.MAX_VALUE).map{Integer.MAX_VALUE - it}.toList().toBlocking().first())
+        assertEquals((0..10).toList().reversed(), (-10 .. Integer.MAX_VALUE).toObservable().skip(Integer.MAX_VALUE).map{Integer.MAX_VALUE - it}.toList().toBlocking().first())
     }
 
-    test fun filterNotNull() {
+    @test fun filterNotNull() {
         val o : Observable<Int> = listOf(1, null).toObservable().filterNotNull()
         o.toList().forEach {
             assertEquals(listOf(1), it)
         }
     }
 
-    test fun requireNoNullsWithoutNulls() {
+    @test fun requireNoNullsWithoutNulls() {
         (listOf(1,2) as List<Int?>).toObservable().requireNoNulls().subscribe()
     }
 
-    test fun requireNoNulls() {
+    @test fun requireNoNulls() {
         try {
             val o : Observable<Int> = listOf(1, null).toObservable().requireNoNulls()
 
@@ -89,7 +89,7 @@ public class ObservablesTest {
         }
     }
 
-    test fun testWithIndex() {
+    @test fun testWithIndex() {
         listOf("a", "b", "c").toObservable().
                 withIndex().
                 toList().
@@ -98,29 +98,29 @@ public class ObservablesTest {
                 }
     }
 
-    test fun testFold() {
+    @test fun testFold() {
         listOf(1, 2, 3).toObservable().fold(0) {acc, e -> acc + e}.single().forEach {
             assertEquals(6, it)
         }
     }
 
-    test fun `kotlin sequence should produce expected items and observable be able to handle em`() {
+    @test fun `kotlin sequence should produce expected items and observable be able to handle em`() {
         kotlin.sequence(0) {it + 1}.toObservable().take(3).toList().forEach {
             assertEquals(listOf(0, 1, 2), it)
         }
     }
 
-    test fun `infinite iterable should not hang or produce too many elements`() {
+    @test fun `infinite iterable should not hang or produce too many elements`() {
         val generated = AtomicInteger()
         kotlin.sequence { generated.incrementAndGet() }.toObservable().
                 take(100).
                 toList().
                 subscribe()
 
-        assertEquals(101, generated.get())
+        assertEquals(100, generated.get())
     }
 
-    test fun testFlatMapSequence() {
+    @test fun testFlatMapSequence() {
         assertEquals(
                 listOf(1, 2, 3, 2, 3, 4, 3, 4, 5),
             listOf(1,2,3).toObservable().flatMapSequence { listOf(it, it + 1, it + 2).asSequence() }.toList().toBlocking().single()