Merge pull request #1586 from jbripley/rxscala-just

RxScala: Observable.items(T*) -> Observable.just(T*)

Author: benjchristensen

language-adaptors/rxjava-scala/README.md

@@ -5,14 +5,14 @@ This adaptor allows to use RxJava in Scala with anonymous functions, e.g.
 ```scala
 val o = Observable.interval(200 millis).take(5)
 o.subscribe(n => println("n = " + n))
-Observable.items(1, 2, 3, 4).reduce(_ + _)
+Observable.just(1, 2, 3, 4).reduce(_ + _)
 ```
 
 For-comprehensions are also supported:
 
 ```scala
-val first = Observable.items(10, 11, 12)
-val second = Observable.items(10, 11, 12)
+val first = Observable.just(10, 11, 12)
+val second = Observable.just(10, 11, 12)
 val booleans = for ((n1, n2) <- (first zip second)) yield (n1 == n2)
 ```
 

language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/Olympics.scala

@@ -22,9 +22,9 @@ import scala.language.postfixOps
 object Olympics {
   case class Medal(val year: Int, val games: String, val discipline: String, val medal: String, val athlete: String, val country: String)
 
-  def mountainBikeMedals: Observable[Medal] = Observable.items(
+  def mountainBikeMedals: Observable[Medal] = Observable.just(
     duration(100 millis), // a short delay because medals are only awarded some time after the Games began
-    Observable.items(
+    Observable.just(
       Medal(1996, "Atlanta 1996", "cross-country men", "Gold", "Bart BRENTJENS", "Netherlands"),
       Medal(1996, "Atlanta 1996", "cross-country women", "Gold", "Paola PEZZO", "Italy"),
       Medal(1996, "Atlanta 1996", "cross-country men", "Silver", "Thomas FRISCHKNECHT", "Switzerland"),
@@ -33,7 +33,7 @@ object Olympics {
       Medal(1996, "Atlanta 1996", "cross-country women", "Bronze", "Susan DEMATTEI", "United States of America")
     ),
     fourYearsEmpty,
-    Observable.items(
+    Observable.just(
       Medal(2000, "Sydney 2000", "cross-country women", "Gold", "Paola PEZZO", "Italy"),
       Medal(2000, "Sydney 2000", "cross-country women", "Silver", "Barbara BLATTER", "Switzerland"),
       Medal(2000, "Sydney 2000", "cross-country women", "Bronze", "Marga FULLANA", "Spain"),
@@ -42,7 +42,7 @@ object Olympics {
       Medal(2000, "Sydney 2000", "cross-country men", "Bronze", "Christoph SAUSER", "Switzerland")
     ),
     fourYearsEmpty,
-    Observable.items(
+    Observable.just(
       Medal(2004, "Athens 2004", "cross-country men", "Gold", "Julien ABSALON", "France"),
       Medal(2004, "Athens 2004", "cross-country men", "Silver", "Jose Antonio HERMIDA RAMOS", "Spain"),
       Medal(2004, "Athens 2004", "cross-country men", "Bronze", "Bart BRENTJENS", "Netherlands"),
@@ -51,7 +51,7 @@ object Olympics {
       Medal(2004, "Athens 2004", "cross-country women", "Bronze", "Sabine SPITZ", "Germany")
     ),
     fourYearsEmpty,
-    Observable.items(
+    Observable.just(
       Medal(2008, "Beijing 2008", "cross-country women", "Gold", "Sabine SPITZ", "Germany"),
       Medal(2008, "Beijing 2008", "cross-country women", "Silver", "Maja WLOSZCZOWSKA", "Poland"),
       Medal(2008, "Beijing 2008", "cross-country women", "Bronze", "Irina KALENTYEVA", "Russian Federation"),
@@ -60,7 +60,7 @@ object Olympics {
       Medal(2008, "Beijing 2008", "cross-country men", "Bronze", "Nino SCHURTER", "Switzerland")
     ),
     fourYearsEmpty,
-    Observable.items(
+    Observable.just(
       Medal(2012, "London 2012", "cross-country men", "Gold", "Jaroslav KULHAVY", "Czech Republic"),
       Medal(2012, "London 2012", "cross-country men", "Silver", "Nino SCHURTER", "Switzerland"),
       Medal(2012, "London 2012", "cross-country men", "Bronze", "Marco Aurelio FONTANA", "Italy"),
@@ -87,7 +87,7 @@ object Olympics {
   def fourYearsEmpty: Observable[Medal] = duration(4*oneYear)
 
   def yearTicks: Observable[Int] = 
-    (Observable.from(1996 to 2014) zip (Observable.items(-1) ++ Observable.interval(oneYear))).map(_._1)
+    (Observable.from(1996 to 2014) zip (Observable.just(-1) ++ Observable.interval(oneYear))).map(_._1)
 
   /*
   def fourYearsEmptyOld: Observable[Medal] = {

language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala

@@ -50,7 +50,7 @@ import rx.lang.scala.schedulers._
 class RxScalaDemo extends JUnitSuite {
 
   @Test def subscribeExample() {
-    val o = Observable.items(1, 2, 3)
+    val o = Observable.just(1, 2, 3)
 
     // Generally, we have two methods, `subscribe` and `foreach`, to listen to the messages from an Observable.
     // `foreach` is just an alias to `subscribe`.
@@ -609,8 +609,8 @@ class RxScalaDemo extends JUnitSuite {
   }
 
   @Test def zipWithExample() {
-    val xs = Observable.items(1, 3, 5, 7)
-    val ys = Observable.items(2, 4, 6, 8)
+    val xs = Observable.just(1, 3, 5, 7)
+    val ys = Observable.just(2, 4, 6, 8)
     xs.zipWith(ys)(_ * _).subscribe(println(_))
   }
 
@@ -912,15 +912,15 @@ class RxScalaDemo extends JUnitSuite {
 
   @Test def delayExample3(): Unit = {
     val o = List(100, 500, 200).toObservable.delay(
-      (i: Int) => Observable.items(i).delay(i millis)
+      (i: Int) => Observable.just(i).delay(i millis)
     )
     o.toBlocking.foreach(println(_))
   }
 
   @Test def delayExample4(): Unit = {
     val o = List(100, 500, 200).toObservable.delay(
       () => Observable.interval(500 millis).take(1),
-      (i: Int) => Observable.items(i).delay(i millis)
+      (i: Int) => Observable.just(i).delay(i millis)
     )
     o.toBlocking.foreach(println(_))
   }
@@ -1332,14 +1332,14 @@ class RxScalaDemo extends JUnitSuite {
   }
 
   @Test def flatMapExample() {
-    val o = Observable.items(10, 100)
+    val o = Observable.just(10, 100)
     o.flatMap(n => Observable.interval(200 millis).map(_ * n))
       .take(20)
       .toBlocking.foreach(println)
   }
 
   @Test def flatMapExample2() {
-    val o = Observable.items(10, 100)
+    val o = Observable.just(10, 100)
     val o1 = for (n <- o;
                   i <- Observable.interval(200 millis)) yield i * n
     o1.take(20).toBlocking.foreach(println)
@@ -1361,7 +1361,7 @@ class RxScalaDemo extends JUnitSuite {
   }
 
   @Test def flatMapExample4() {
-    val o = Observable.items(10, 100)
+    val o = Observable.just(10, 100)
     o.flatMap(
       (n: Int) => Observable.interval(200 millis).map(_ * n),
       e => Observable.interval(200 millis).map(_ * -1),
@@ -1371,23 +1371,23 @@ class RxScalaDemo extends JUnitSuite {
   }
 
   @Test def flatMapExample5() {
-    val o = Observable.items(1, 10, 100, 1000)
+    val o = Observable.just(1, 10, 100, 1000)
     o.flatMapWith(_ => Observable.interval(200 millis).take(5))(_ * _).toBlocking.foreach(println)
   }
 
   @Test def flatMapIterableExample() {
-    val o = Observable.items(10, 100)
+    val o = Observable.just(10, 100)
     o.flatMapIterable(n => (1 to 20).map(_ * n))
       .toBlocking.foreach(println)
   }
 
   @Test def flatMapIterableExample2() {
-    val o = Observable.items(1, 10, 100, 1000)
+    val o = Observable.just(1, 10, 100, 1000)
     o.flatMapIterableWith(_=> (1 to 5))(_ * _).toBlocking.foreach(println)
   }
 
   @Test def concatMapExample() {
-    val o = Observable.items(10, 100)
+    val o = Observable.just(10, 100)
     o.concatMap(n => Observable.interval(200 millis).map(_ * n).take(10))
       .take(20)
       .toBlocking.foreach(println)
@@ -1402,7 +1402,7 @@ class RxScalaDemo extends JUnitSuite {
         subscriber.onNext(3)
         subscriber.onNext(4)
     }
-    o.onErrorResumeNext(_ => Observable.items(10, 11, 12)).subscribe(println(_))
+    o.onErrorResumeNext(_ => Observable.just(10, 11, 12)).subscribe(println(_))
   }
 
   @Test def onErrorFlatMapExample() {
@@ -1414,13 +1414,13 @@ class RxScalaDemo extends JUnitSuite {
         subscriber.onNext(3)
         subscriber.onNext(4)
     }
-    o.onErrorFlatMap((_, _) => Observable.items(10, 11, 12)).subscribe(println(_))
+    o.onErrorFlatMap((_, _) => Observable.just(10, 11, 12)).subscribe(println(_))
   }
 
   @Test def onErrorFlatMapExample2() {
-    val o = Observable.items(4, 2, 0).map(16 / _).onErrorFlatMap {
+    val o = Observable.just(4, 2, 0).map(16 / _).onErrorFlatMap {
       (e, op) => op match {
-        case Some(v) if v == 0 => Observable.items(Int.MinValue)
+        case Some(v) if v == 0 => Observable.just(Int.MinValue)
         case _ => Observable.empty
       }
     }

language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala

@@ -254,7 +254,7 @@ trait Observable[+T]
    * @return  an Observable that first emits the items emitted by `this`, and then `elem`.
    */
   def :+[U >: T](elem: U): Observable[U] = {
-    this ++ Observable.items(elem)
+    this ++ Observable.just(elem)
   }
 
   /**
@@ -4432,10 +4432,31 @@ object Observable {
    *            resulting Observable
    * @return an Observable that emits each item in the source Array
    */
+  @deprecated("Use `just` instead", "0.20")
   def items[T](items: T*): Observable[T] = {
     toScalaObservable[T](rx.Observable.from(items.toIterable.asJava))
   }
 
+  /**
+   * Converts a sequence of values into an Observable.
+   *
+   * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/from.png">
+   *
+   * Implementation note: the entire array will be immediately emitted each time an [[rx.lang.scala.Observer]] subscribes.
+   * Since this occurs before the [[rx.lang.scala.Subscription]] is returned,
+   * it in not possible to unsubscribe from the sequence before it completes.
+   *
+   * @param items
+   *            the source Array
+   * @tparam T
+   *            the type of items in the Array, and the type of items to be emitted by the
+   *            resulting Observable
+   * @return an Observable that emits each item in the source Array
+   */
+  def just[T](items: T*): Observable[T] = {
+    toScalaObservable[T](rx.Observable.from(items.toIterable.asJava))
+  }
+
  /** Returns an Observable emitting the value produced by the Future as its single item.
    * If the future fails, the Observable will fail as well.
    *

language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala

@@ -156,7 +156,7 @@ class CompletenessTest extends JUnitSuite {
       "skipWhileWithIndex(Func2[_ >: T, Integer, Boolean])" -> unnecessary,
       "skipUntil(Observable[U])" -> "dropUntil(Observable[Any])",
       "startWith(T)" -> "[use `item +: o`]",
-      "startWith(Array[T], Scheduler)" -> "[use `Observable.items(items).subscribeOn(scheduler) ++ o`]",
+      "startWith(Array[T], Scheduler)" -> "[use `Observable.just(items).subscribeOn(scheduler) ++ o`]",
       "startWith(Iterable[T])" -> "[use `Observable.from(iterable) ++ o`]",
       "startWith(Iterable[T], Scheduler)" -> "[use `Observable.from(iterable).subscribeOn(scheduler) ++ o`]",
       "startWith(Observable[T])" -> "[use `++`]",
@@ -242,7 +242,7 @@ class CompletenessTest extends JUnitSuite {
       "zip(Iterable[_ <: T2], Func2[_ >: T, _ >: T2, _ <: R])" -> "zipWith(Iterable[U])((T, U) => R)"
   ) ++ List.iterate("T, T", 8)(s => s + ", T").map(
       // all 9 overloads of startWith:
-      "startWith(" + _ + ")" -> "[use `Observable.items(...) ++ o`]"
+      "startWith(" + _ + ")" -> "[use `Observable.just(...) ++ o`]"
   ).toMap ++ List.iterate("Observable[_ <: T]", 9)(s => s + ", Observable[_ <: T]").map(
       // concat 2-9
       "concat(" + _ + ")" -> "[unnecessary because we can use `++` instead or `Observable(o1, o2, ...).concat`]"

language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ConstructorTest.scala

@@ -28,7 +28,7 @@ class ConstructorTest extends JUnitSuite {
     val ys = Observable.from(List(1,2,3)).toBlocking.toList
     assertEquals(List(1,2,3), xs)
 
-    val zs = Observable.items(1,2,3).toBlocking.toList
+    val zs = Observable.just(1,2,3).toBlocking.toList
     assertEquals(List(1,2,3), xs)
 
   }