Merge pull request #29 from MarioAriasC/master

1.0.0-beta

Author: MarioAriasC

build.gradle

@@ -1,5 +1,5 @@
 buildscript {
-  ext.kotlin_version = '0.14.449'
+  ext.kotlin_version = '1.0.0-beta-1038'
   repositories { jcenter() }
   dependencies { classpath 'com.netflix.nebula:gradle-rxjava-project-plugin:2.+',
                            "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" }
@@ -11,7 +11,7 @@ apply plugin: 'kotlin'
 dependencies {
     compile 'io.reactivex:rxjava:1.0.+'
     compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-    testCompile 'org.funktionale:funktionale:0.6_M14'
+    testCompile 'org.funktionale:funktionale:0.6_1.0.0-beta'
     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

@@ -1,12 +1,12 @@
 package rx.lang.kotlin.examples
 
 import rx.Observable
-import kotlin.concurrent.thread
-import java.util.Scanner
-import java.net.URL
 import rx.lang.kotlin.observable
-import rx.lang.kotlin.toObservable
 import rx.lang.kotlin.onError
+import rx.lang.kotlin.toObservable
+import java.net.URL
+import java.util.*
+import kotlin.concurrent.thread
 
 fun main(args: Array<String>) {
 
@@ -25,7 +25,7 @@ fun main(args: Array<String>) {
     asyncWiki("Tiger", "Elephant").subscribe(printArticle)
 
     asyncWikiWithErrorHandling("Tiger", "Elephant").subscribe(printArticle) { e ->
-        println("--- Error ---\n${e.getMessage()}")
+        println("--- Error ---\n${e.message}")
     }
 
 }

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

@@ -16,16 +16,15 @@
 
 package rx.lang.kotlin
 
-import rx.Observable
+import org.junit.Assert.assertEquals
+import org.junit.Assert.fail
 import org.junit.Test
 import org.mockito.Mockito.*
-import org.mockito.Matchers.*
-import org.junit.Assert.*
 import rx.Notification
-import kotlin.concurrent.thread
-import rx.lang.kotlin.BasicKotlinTests.AsyncObservable
+import rx.Observable
 import rx.Observable.OnSubscribe
 import rx.Subscriber
+import kotlin.concurrent.thread
 
 /**
  * This class use plain Kotlin without extensions from the language adaptor
@@ -50,7 +49,7 @@ public class BasicKotlinTests : KotlinTests() {
 
     @Test
     public fun testFilter() {
-        Observable.from(listOf(1, 2, 3)).filter { it >= 2 }.subscribe(received)
+        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);
@@ -63,26 +62,26 @@ public class BasicKotlinTests : KotlinTests() {
 
     @Test
     public fun testLastWithPredicate() {
-        assertEquals("two", Observable.from(listOf("one", "two", "three")).toBlocking().last { x -> x.length() == 3 })
+        assertEquals("two", Observable.from(listOf("one", "two", "three")).toBlocking().last { x -> x.length == 3 })
     }
 
     @Test
     public fun testMap1() {
-        Observable.just(1).map { v -> "hello_$v" }.subscribe(received)
+        Observable.just(1).map { v -> "hello_$v" }.subscribe(received())
         verify(a, times(1)).received("hello_1")
     }
 
     @Test
     public fun testMap2() {
-        Observable.from(listOf(1, 2, 3)).map { v -> "hello_$v" }.subscribe(received)
+        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
     public fun testMaterialize() {
-        Observable.from(listOf(1, 2, 3)).materialize().subscribe(received)
+        Observable.from(listOf(1, 2, 3)).materialize().subscribe(received())
         verify(a, times(4)).received(any(Notification::class.java))
         verify(a, times(0)).error(any(Exception::class.java))
     }
@@ -97,7 +96,7 @@ public class BasicKotlinTests : KotlinTests() {
                         Observable.just(7)
                 ),
                 Observable.from(listOf(4, 5))
-        ).subscribe(received) { e -> a.error(e) }
+        ).subscribe(received()) { e -> a.error(e) }
         verify(a, times(1)).received(1)
         verify(a, times(1)).received(2)
         verify(a, times(1)).received(3)
@@ -110,14 +109,14 @@ public class BasicKotlinTests : KotlinTests() {
 
     @Test
     public fun testScriptWithMaterialize() {
-        TestFactory().observable.materialize().subscribe(received)
+        TestFactory().observable.materialize().subscribe(received())
         verify(a, times(2)).received(any(Notification::class.java))
     }
 
     @Test
     public fun testScriptWithMerge() {
         val factory = TestFactory()
-        Observable.merge(factory.observable, factory.observable).subscribe(received)
+        Observable.merge(factory.observable, factory.observable).subscribe(received())
         verify(a, times(1)).received("hello_1")
         verify(a, times(1)).received("hello_2")
     }
@@ -144,65 +143,65 @@ public class BasicKotlinTests : KotlinTests() {
 
     @Test
     public fun testScriptWithOnNext() {
-        TestFactory().observable.subscribe(received)
+        TestFactory().observable.subscribe(received())
         verify(a, times(1)).received("hello_1")
     }
 
     @Test
     public fun testSkipTake() {
-        Observable.from(listOf(1, 2, 3)).skip(1).take(1).subscribe(received)
+        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
     public fun testSkip() {
-        Observable.from(listOf(1, 2, 3)).skip(2).subscribe(received)
+        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
     public fun testTake() {
-        Observable.from(listOf(1, 2, 3)).take(2).subscribe(received)
+        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
     public fun testTakeLast() {
-        TestFactory().observable.takeLast(1).subscribe(received)
+        TestFactory().observable.takeLast(1).subscribe(received())
         verify(a, times(1)).received("hello_1")
     }
 
     @Test
     public fun testTakeWhile() {
-        Observable.from(listOf(1, 2, 3)).takeWhile { x -> x < 3 }.subscribe(received)
+        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
     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)
+        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
     public fun testToSortedList() {
-        TestFactory().numbers.toSortedList().subscribe(received)
+        TestFactory().numbers.toSortedList().subscribe(received())
         verify(a, times(1)).received(listOf(1, 2, 3, 4, 5))
     }
 
     @Test
     public fun testForEach() {
-        Observable.create(AsyncObservable()).toBlocking().forEach(received)
+        Observable.create(AsyncObservable()).toBlocking().forEach(received())
         verify(a, times(1)).received(1)
         verify(a, times(1)).received(2)
         verify(a, times(1)).received(3)
@@ -216,27 +215,27 @@ public class BasicKotlinTests : KotlinTests() {
 
     @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 })
+        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 = 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 }
+        assertEquals("one", Observable.just("one").toBlocking().single { x -> x.length == 3 })
+        Observable.from(listOf("one", "two")).toBlocking().single { x -> x.length == 3 }
         fail()
     }
 
     @Test
     public fun testDefer() {
-        Observable.defer { Observable.from(listOf(1, 2)) }.subscribe(received)
+        Observable.defer { Observable.from(listOf(1, 2)) }.subscribe(received())
         verify(a, times(1)).received(1)
         verify(a, times(1)).received(2)
     }
 
     @Test
     public fun testAll() {
-        Observable.from(listOf(1, 2, 3)).all { x -> x > 0 }.subscribe(received)
+        Observable.from(listOf(1, 2, 3)).all { x -> x > 0 }.subscribe(received())
         verify(a, times(1)).received(true)
     }
 
@@ -269,7 +268,7 @@ public class BasicKotlinTests : KotlinTests() {
         var count = 0
 
         Observable.from(listOf("one", "two", "three", "four", "five", "six"))
-                .groupBy { s -> s.length() }
+                .groupBy { s -> s.length }
                 .flatMap { groupObervable ->
                     groupObervable.map { s ->
                         "Value: $s Group ${groupObervable.key}"