Add mapOptionalOnce

README.md

@@ -78,6 +78,18 @@ state().mapOptional { bar }
 ```
 
 
+### Observable.mapOptionalOnce
+Map to one nullable property of the state, wrap in `Optional`, and ensure
+that only first value is observed
+
+```kotlin
+state().mapOptionalOnce { bar }
+  .subscribe { println(it) }
+
+// --> None
+```
+
+
 ### Observable.mapOptionalDistinct
 Map to one nullable property of the state and wrap in `Optional`
 and ensure that subsequently emitted values are distinct
@@ -131,7 +143,7 @@ state().mapSomeOnce { bar }
 ## Binaries
 ```gradle
 dependencies {
-    implementation "cc.femto:rx-mapping-extensions:0.3"
+    implementation "cc.femto:rx-mapping-extensions:0.4"
 }
 ```
 

build.gradle

@@ -12,7 +12,7 @@ plugins {
 }
 
 group 'com.github.hpost'
-version '0.3'
+version '0.4'
 
 repositories {
     mavenCentral()

src/main/kotlin/cc/femto/rx/extensions/Mapping.kt

@@ -44,6 +44,20 @@ inline fun <T, R : Any> Observable<T>.mapOnce(crossinline mapper: T.() -> R): Ob
 inline fun <T, R : Any> Observable<T>.mapOptional(crossinline mapper: T.() -> R?): Observable<Optional<R>> =
     this.map { mapper(it).toOptional() }
 
+/**
+ * Map the stream to the value returned from [mapper], which is wrapped in an [Optional],
+ * and then apply [Observable.take] with value `1` to ensure the stream will
+ * complete after emitting one value
+ *
+ * Usage:
+ * <code>
+ *   stream.mapOptionalOnce { foo }
+ *     .subscribe { /* access at most one value wrapped in Optional */ }
+ * </code>
+ */
+inline fun <T, R : Any> Observable<T>.mapOptionalOnce(crossinline mapper: T.() -> R?): Observable<Optional<R>> =
+        this.mapOptional(mapper).take(1)
+
 /**
  * Applies [mapOptional] and then [Observable.distinctUntilChanged] to ensure
  * the stream won't emit if the value in [mapper] has not changed

src/test/kotlin/cc/femto/rx/extensions/MappingSpec.kt

@@ -77,6 +77,25 @@ class MappingSpec : Spek({
         }
     }
 
+    describe("mapOptionalOnce") {
+        lateinit var observer: TestObserver<Optional<String>>
+
+        beforeEachTest {
+            state = Observable.just(
+                State(bar = "initialized"),
+                State(bar = null),
+                State(bar = "changed")
+            )
+            observer = state.mapOptionalOnce { bar }.test()
+        }
+
+        it("maps to nullable property, wraps in `Optional`, and completes after one emission") {
+            observer.assertValues(
+                Some("initialized")
+            )
+        }
+    }
+
     describe("mapOptionalDistinct") {
         lateinit var observer: TestObserver<Optional<String>>