Yigit/move fetcher factories to fetcher

README.md

@@ -56,9 +56,9 @@ Let's start by looking at what a fully configured Store looks like. We will then
 ```kotlin
 StoreBuilder
     .from(
-        fetcher = nonFlowValueFetcher { api.fetchSubreddit(it, "10").data.children.map(::toPosts) },
+        fetcher = Fetcher.from { api.fetchSubreddit(it, "10").data.children.map(::toPosts) },
         sourceOfTruth = SourceOfTrue.from(
-            reader = db.postDao()::loadPosts,
+            flowReader = db.postDao()::loadPosts,
             writer = db.postDao()::insertPosts,
             delete = db.postDao()::clearFeed,
             deleteAll = db.postDao()::clearAllFeeds
@@ -81,7 +81,7 @@ You create a Store using a builder. The only requirement is to include a `Fetche
 
 ```kotlin
 val store = StoreBuilder
-        .from(valueFetcher { articleId -> api.getArticle(articleId) }) // api returns Flow<Article>
+        .from(Fetcher.fromFlow { articleId -> api.getArticle(articleId) }) // api returns Flow<Article>
         .build()
 ```
 
@@ -186,9 +186,9 @@ allows you to create offline first applications that can be used without an acti
 ```kotlin
 StoreBuilder
     .from(
-        fetcher = nonFlowValueFetcher { api.fetchSubreddit(it, "10").data.children.map(::toPosts) },
+        fetcher = Fetcher.from { api.fetchSubreddit(it, "10").data.children.map(::toPosts) },
         sourceOfTruth = SourceOfTrue.from(
-            reader = db.postDao()::loadPosts,
+            flowReader = db.postDao()::loadPosts,
             writer = db.postDao()::insertPosts,
             delete = db.postDao()::clearFeed,
             deleteAll = db.postDao()::clearAllFeeds
@@ -215,9 +215,9 @@ You can configure in-memory cache with the `MemoryPolicy`:
 ```kotlin
 StoreBuilder
     .from(
-        fetcher = nonFlowValueFetcher { api.fetchSubreddit(it, "10").data.children.map(::toPosts) },
+        fetcher = Fetcher.from { api.fetchSubreddit(it, "10").data.children.map(::toPosts) },
         sourceOfTruth = SourceOfTrue.from(
-            reader = db.postDao()::loadPosts,
+            flowReader = db.postDao()::loadPosts,
             writer = db.postDao()::insertPosts,
             delete = db.postDao()::clearFeed,
             deleteAll = db.postDao()::clearAllFeeds
@@ -244,8 +244,9 @@ You can delete a specific entry by key from a store, or clear all entries in a s
 
 ```kotlin
 val store = StoreBuilder
-    .from(nonFlowValueFetcher { api.fetchData(key) })
-    .build()
+  .from(Fetcher.from { key: String ->
+      api.fetchData(key)
+  }).build()
 ```
 
 The following will clear the entry associated with the key from the in-memory cache:
@@ -267,9 +268,9 @@ When store has a sourceOfTruth, you'll need to provide the `delete` and `deleteA
 ```kotlin
 StoreBuilder
     .from(
-        fetcher = nonFlowValueFetcher { api.fetchData(key) },
+        fetcher = Fetcher.from { api.fetchData(key) },
         sourceOfTruth = SourceOfTrue.from(
-            reader = dao::loadData,
+            flowReader = dao::loadData,
             writer = dao::writeData,
             delete = dao::clearDataByKey,
             deleteAll = dao::clearAllData

app/src/main/java/com/dropbox/android/sample/Graph.kt

@@ -11,13 +11,13 @@ import com.dropbox.android.external.fs3.FileSystemPersister
 import com.dropbox.android.external.fs3.PathResolver
 import com.dropbox.android.external.fs3.SourcePersisterFactory
 import com.dropbox.android.external.fs3.filesystem.FileSystemFactory
+import com.dropbox.android.external.store4.Fetcher
 import com.dropbox.android.external.store4.StoreBuilder
 import com.dropbox.android.external.store4.MemoryPolicy
 import com.dropbox.android.external.store4.Persister
 import com.dropbox.android.external.store4.Store
 import com.dropbox.android.external.store4.SourceOfTruth
 import com.dropbox.android.external.store4.legacy.BarCode
-import com.dropbox.android.external.store4.nonFlowValueFetcher
 import com.squareup.moshi.Moshi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -46,11 +46,11 @@ object Graph {
         val db = provideRoom(context)
         return StoreBuilder
             .from(
-                nonFlowValueFetcher { key: String ->
+                Fetcher.from { key: String ->
                     provideRetrofit().fetchSubreddit(key, 10).data.children.map(::toPosts)
                 },
                 sourceOfTruth = SourceOfTruth.from(
-                    reader = db.postDao()::loadPosts,
+                    flowReader = db.postDao()::loadPosts,
                     writer = db.postDao()::insertPosts,
                     delete = db.postDao()::clearFeedBySubredditName,
                     deleteAll = db.postDao()::clearAllFeeds
@@ -63,12 +63,12 @@ object Graph {
         val db = provideRoom(context)
         return StoreBuilder
             .from<Pair<String, RedditConfig>, List<Post>, List<Post>>(
-                nonFlowValueFetcher { (query, config) ->
+                Fetcher.from { (query, config) ->
                     provideRetrofit().fetchSubreddit(query, config.limit)
                         .data.children.map(::toPosts)
                 },
                 sourceOfTruth = SourceOfTruth.from(
-                    reader = { (query, _) -> db.postDao().loadPosts(query) },
+                    flowReader = { (query, _) -> db.postDao().loadPosts(query) },
                     writer = { (query, _), posts -> db.postDao().insertPosts(query, posts) },
                     delete = { (query, _) -> db.postDao().clearFeedBySubredditName(query) },
                     deleteAll = db.postDao()::clearAllFeeds
@@ -99,11 +99,11 @@ object Graph {
         val adapter = moshi.adapter<RedditConfig>(RedditConfig::class.java)
         return StoreBuilder
             .from<Unit, RedditConfig, RedditConfig>(
-                nonFlowValueFetcher {
+                Fetcher.from {
                     delay(500)
                     RedditConfig(10)
                 },
-                sourceOfTruth = SourceOfTruth.fromNonFlow(
+                sourceOfTruth = SourceOfTruth.from(
                     reader = {
                         runCatching {
                             val source = fileSystemPersister.read(Unit)

app/src/main/java/com/dropbox/android/sample/ui/stream/StreamFragment.kt

@@ -5,12 +5,12 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.fragment.app.Fragment
+import com.dropbox.android.external.store4.Fetcher
 import com.dropbox.android.external.store4.MemoryPolicy
 import com.dropbox.android.external.store4.StoreBuilder
 import com.dropbox.android.external.store4.StoreRequest
 import com.dropbox.android.external.store4.fresh
 import com.dropbox.android.external.store4.get
-import com.dropbox.android.external.store4.nonFlowValueFetcher
 import com.dropbox.android.sample.R
 import kotlinx.android.synthetic.main.fragment_stream.*
 import kotlinx.coroutines.CoroutineScope
@@ -51,7 +51,7 @@ class StreamFragment : Fragment(), CoroutineScope {
         var counter = 0
 
         val store = StoreBuilder
-            .from(nonFlowValueFetcher { key: Int ->
+            .from(Fetcher.from { key: Int ->
                 (key * 1000 + counter++).also { delay(1_000) }
             })
             .cachePolicy(

store-rx2/api/store-rx2.api

@@ -1,8 +1,8 @@
 public final class com/dropbox/store/rx2/RxFetcherKt {
-	public static final fun flowableFetcher (Lkotlin/jvm/functions/Function1;)Lkotlin/jvm/functions/Function1;
-	public static final fun flowableValueFetcher (Lkotlin/jvm/functions/Function1;)Lkotlin/jvm/functions/Function1;
-	public static final fun singleFetcher (Lkotlin/jvm/functions/Function1;)Lkotlin/jvm/functions/Function1;
-	public static final fun singleValueFetcher (Lkotlin/jvm/functions/Function1;)Lkotlin/jvm/functions/Function1;
+	public static final fun from (Lcom/dropbox/android/external/store4/Fetcher$Companion;Lkotlin/jvm/functions/Function1;)Lcom/dropbox/android/external/store4/Fetcher;
+	public static final fun fromFetcherResultFlowable (Lcom/dropbox/android/external/store4/Fetcher$Companion;Lkotlin/jvm/functions/Function1;)Lcom/dropbox/android/external/store4/Fetcher;
+	public static final fun fromFlowable (Lcom/dropbox/android/external/store4/Fetcher$Companion;Lkotlin/jvm/functions/Function1;)Lcom/dropbox/android/external/store4/Fetcher;
+	public static final fun fromSingleFetcherResult (Lcom/dropbox/android/external/store4/Fetcher$Companion;Lkotlin/jvm/functions/Function1;)Lcom/dropbox/android/external/store4/Fetcher;
 }
 
 public final class com/dropbox/store/rx2/RxSourceOfTruthKt {

store-rx2/src/main/kotlin/com/dropbox/store/rx2/RxFetcher.kt

@@ -3,7 +3,6 @@ package com.dropbox.store.rx2
 import com.dropbox.android.external.store4.Fetcher
 import com.dropbox.android.external.store4.FetcherResult
 import com.dropbox.android.external.store4.Store
-import com.dropbox.android.external.store4.valueFetcher
 import io.reactivex.Flowable
 import io.reactivex.Single
 import kotlinx.coroutines.reactive.asFlow
@@ -19,9 +18,9 @@ import kotlinx.coroutines.reactive.asFlow
  *
  * @param flowableFactory a factory for a [Flowable] source of network records.
  */
-fun <Key : Any, Output : Any> flowableFetcher(
+fun <Key : Any, Output : Any> Fetcher.Companion.fromFetcherResultFlowable(
     flowableFactory: (key: Key) -> Flowable<FetcherResult<Output>>
-): Fetcher<Key, Output> = { key: Key -> flowableFactory(key).asFlow() }
+): Fetcher<Key, Output> = Fetcher.fromFetcherResultFlow { key: Key -> flowableFactory(key).asFlow() }
 
 /**
  * "Creates" a [Fetcher] from a [singleFactory].
@@ -34,9 +33,9 @@ fun <Key : Any, Output : Any> flowableFetcher(
  *
  * @param singleFactory a factory for a [Single] source of network records.
  */
-fun <Key : Any, Output : Any> singleFetcher(
+fun <Key : Any, Output : Any> Fetcher.Companion.fromSingleFetcherResult(
     singleFactory: (key: Key) -> Single<FetcherResult<Output>>
-): Fetcher<Key, Output> = { key: Key -> singleFactory(key).toFlowable().asFlow() }
+): Fetcher<Key, Output> = Fetcher.fromFetcherResultFlow { key: Key -> singleFactory(key).toFlowable().asFlow() }
 
 /**
  * "Creates" a [Fetcher] from a [flowableFactory] and translate the results to a [FetcherResult].
@@ -50,9 +49,9 @@ fun <Key : Any, Output : Any> singleFetcher(
  *
  * @param flowFactory a factory for a [Flowable] source of network records.
  */
-fun <Key : Any, Output : Any> flowableValueFetcher(
+fun <Key : Any, Output : Any> Fetcher.Companion.fromFlowable(
     flowableFactory: (key: Key) -> Flowable<Output>
-): Fetcher<Key, Output> = valueFetcher { key: Key -> flowableFactory(key).asFlow() }
+): Fetcher<Key, Output> = Fetcher.fromFlow { key: Key -> flowableFactory(key).asFlow() }
 
 /**
  * Creates a new [Fetcher] from a [singleFactory] and translate the results to a [FetcherResult].
@@ -66,6 +65,6 @@ fun <Key : Any, Output : Any> flowableValueFetcher(
  *
  * @param singleFactory a factory for a [Single] source of network records.
  */
-fun <Key : Any, Output : Any> singleValueFetcher(
+fun <Key : Any, Output : Any> Fetcher.Companion.from(
     singleFactory: (key: Key) -> Single<Output>
-): Fetcher<Key, Output> = flowableValueFetcher { key: Key -> singleFactory(key).toFlowable() }
+): Fetcher<Key, Output> = fromFlowable { key: Key -> singleFactory(key).toFlowable() }

store-rx2/src/main/kotlin/com/dropbox/store/rx2/RxSourceOfTruth.kt

@@ -26,7 +26,7 @@ fun <Key : Any, Input : Any, Output : Any> SourceOfTruth.Companion.fromMaybe(
     val deleteFun: (suspend (Key) -> Unit)? =
         if (delete != null) { key -> delete(key).await() } else null
     val deleteAllFun: (suspend () -> Unit)? = deleteAll?.let { { deleteAll().await() } }
-    return fromNonFlow(
+    return from(
         reader = { key -> reader.invoke(key).await() },
         writer = { key, output -> writer.invoke(key, output).await() },
         delete = deleteFun,
@@ -54,7 +54,7 @@ fun <Key : Any, Input : Any, Output : Any> SourceOfTruth.Companion.fromFlowable(
         if (delete != null) { key -> delete(key).await() } else null
     val deleteAllFun: (suspend () -> Unit)? = deleteAll?.let { { deleteAll().await() } }
     return from(
-        reader = { key -> reader.invoke(key).asFlow() },
+        flowReader = { key -> reader.invoke(key).asFlow() },
         writer = { key, output -> writer.invoke(key, output).await() },
         delete = deleteFun,
         deleteAll = deleteAllFun

store-rx2/src/test/kotlin/com/dropbox/store/rx2/test/HotRxSingleStoreTest.kt

@@ -6,7 +6,7 @@ import com.dropbox.android.external.store4.ResponseOrigin
 import com.dropbox.android.external.store4.StoreBuilder
 import com.dropbox.android.external.store4.StoreRequest
 import com.dropbox.android.external.store4.StoreResponse
-import com.dropbox.store.rx2.singleFetcher
+import com.dropbox.store.rx2.fromSingleFetcherResult
 import com.google.common.truth.Truth.assertThat
 import io.reactivex.Single
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -30,7 +30,7 @@ class HotRxSingleStoreTest {
                 3 to FetcherResult.Data("three-1"),
                 3 to FetcherResult.Data("three-2")
             )
-            val pipeline = StoreBuilder.from(singleFetcher<Int, String> { fetcher.fetch(it) })
+            val pipeline = StoreBuilder.from(Fetcher.fromSingleFetcherResult<Int, String> { fetcher.fetch(it) })
                 .scope(testScope)
                 .build()
 

store-rx2/src/test/kotlin/com/dropbox/store/rx2/test/RxFlowableStoreTest.kt

@@ -1,12 +1,13 @@
 package com.dropbox.store.rx2.test
 
+import com.dropbox.android.external.store4.Fetcher
 import com.dropbox.android.external.store4.FetcherResult
 import com.dropbox.android.external.store4.ResponseOrigin
 import com.dropbox.android.external.store4.SourceOfTruth
 import com.dropbox.android.external.store4.StoreBuilder
 import com.dropbox.android.external.store4.StoreRequest
 import com.dropbox.android.external.store4.StoreResponse
-import com.dropbox.store.rx2.flowableFetcher
+import com.dropbox.store.rx2.fromFetcherResultFlowable
 import com.dropbox.store.rx2.fromFlowable
 import com.dropbox.store.rx2.observe
 import io.reactivex.BackpressureStrategy
@@ -30,7 +31,7 @@ class RxFlowableStoreTest {
     private val fakeDisk = mutableMapOf<Int, String>()
     private val store =
         StoreBuilder.from<Int, String, String>(
-            flowableFetcher {
+            Fetcher.fromFetcherResultFlowable {
                 Flowable.create({ emitter ->
                     emitter.onNext(
                         FetcherResult.Data("$it ${atomicInteger.incrementAndGet()} occurrence")
@@ -64,12 +65,12 @@ class RxFlowableStoreTest {
         testSubscriber
             .awaitCount(3)
             .assertValues(
-                StoreResponse.Loading<String>(ResponseOrigin.Fetcher),
+                StoreResponse.Loading(ResponseOrigin.Fetcher),
                 StoreResponse.Data("3 1 occurrence", ResponseOrigin.Fetcher),
                 StoreResponse.Data("3 2 occurrence", ResponseOrigin.Fetcher)
             )
 
-        testSubscriber = TestSubscriber<StoreResponse<String>>()
+        testSubscriber = TestSubscriber()
         store.observe(StoreRequest.cached(3, false))
             .subscribeOn(testScheduler)
             .subscribe(testSubscriber)
@@ -81,20 +82,20 @@ class RxFlowableStoreTest {
                 StoreResponse.Data("3 2 occurrence", ResponseOrigin.SourceOfTruth)
             )
 
-        testSubscriber = TestSubscriber<StoreResponse<String>>()
+        testSubscriber = TestSubscriber()
         store.observe(StoreRequest.fresh(3))
             .subscribeOn(testScheduler)
             .subscribe(testSubscriber)
         testScheduler.triggerActions()
         testSubscriber
             .awaitCount(3)
             .assertValues(
-                StoreResponse.Loading<String>(ResponseOrigin.Fetcher),
+                StoreResponse.Loading(ResponseOrigin.Fetcher),
                 StoreResponse.Data("3 3 occurrence", ResponseOrigin.Fetcher),
                 StoreResponse.Data("3 4 occurrence", ResponseOrigin.Fetcher)
             )
 
-        testSubscriber = TestSubscriber<StoreResponse<String>>()
+        testSubscriber = TestSubscriber()
         store.observe(StoreRequest.cached(3, false))
             .subscribeOn(testScheduler)
             .subscribe(testSubscriber)

store-rx2/src/test/kotlin/com/dropbox/store/rx2/test/RxSingleStoreExtensionsTest.kt

@@ -1,13 +1,14 @@
 package com.dropbox.store.rx2.test
 
 import com.dropbox.android.external.store4.ExperimentalStoreApi
+import com.dropbox.android.external.store4.Fetcher
 import com.dropbox.android.external.store4.FetcherResult
 import com.dropbox.android.external.store4.SourceOfTruth
 import com.dropbox.android.external.store4.StoreBuilder
 import com.dropbox.store.rx2.freshSingle
 import com.dropbox.store.rx2.fromMaybe
 import com.dropbox.store.rx2.getSingle
-import com.dropbox.store.rx2.singleFetcher
+import com.dropbox.store.rx2.fromSingleFetcherResult
 import com.dropbox.store.rx2.withScheduler
 import io.reactivex.Completable
 import io.reactivex.Maybe
@@ -29,7 +30,7 @@ class RxSingleStoreExtensionsTest {
     private var fakeDisk = mutableMapOf<Int, String>()
     private val store =
         StoreBuilder.from<Int, String, String>(
-            fetcher = singleFetcher {
+            fetcher = Fetcher.fromSingleFetcherResult {
                 Single.fromCallable { FetcherResult.Data("$it ${atomicInteger.incrementAndGet()}") }
             },
             sourceOfTruth = SourceOfTruth.fromMaybe(