Renames ComposeViewFactoryRoot to CompositionRoot and decouples the implementation.

The root is now applied via a `ViewRegistry` wrapper that wraps individual factories
to apply the root, instead of having this logic hard-coded inside `ComposeViewFactory`.

This approach is more flexible in general (could be used to do other tricks), and decouples
the rooting feature from the rest of the code.

Author: zach-klippenstein

core-compose/src/androidTest/java/com/squareup/workflow/ui/compose/ComposeViewFactoryTest.kt

@@ -40,7 +40,7 @@ class ComposeViewFactoryTest {
   @Test fun wrapsFactoryWithRoot() {
     val wrapperText = mutableStateOf("one")
     val viewEnvironment = ViewEnvironment(ViewRegistry(TestFactory))
-        .withComposeViewFactoryRoot { content ->
+        .withCompositionRoot { content ->
           Column {
             Text(wrapperText.value)
             content()

core-compose/src/androidTest/java/com/squareup/workflow/ui/compose/internal/SafeComposeViewFactoryRootTest.kt renamed to core-compose/src/androidTest/java/com/squareup/workflow/ui/compose/CompositionRootTest.kt

@@ -13,8 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.squareup.workflow.ui.compose.internal
+package com.squareup.workflow.ui.compose
 
+import androidx.compose.FrameManager
+import androidx.compose.mutableStateOf
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.ui.foundation.Text
 import androidx.ui.layout.Column
@@ -23,28 +25,114 @@ import androidx.ui.test.assertIsDisplayed
 import androidx.ui.test.createComposeRule
 import androidx.ui.test.findByText
 import com.google.common.truth.Truth.assertThat
-import com.squareup.workflow.ui.compose.ComposeViewFactoryRoot
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import kotlin.test.assertFailsWith
 
 @RunWith(AndroidJUnit4::class)
-class SafeComposeViewFactoryRootTest {
+class CompositionRootTest {
 
   @Rule @JvmField val composeRule = createComposeRule()
 
+  @Test fun wrapWithRootIfNecessary_wrapsWhenNecessary() {
+    val root: CompositionRoot = { content ->
+      Column {
+        Text("one")
+        content()
+      }
+    }
+
+    composeRule.setContent {
+      wrapWithRootIfNecessary(root) {
+        Text("two")
+      }
+    }
+
+    findByText("one\ntwo").assertIsDisplayed()
+  }
+
+  @Test fun wrapWithRootIfNecessary_onlyWrapsOnce() {
+    val root: CompositionRoot = { content ->
+      Column {
+        Text("one")
+        content()
+      }
+    }
+
+    composeRule.setContent {
+      wrapWithRootIfNecessary(root) {
+        Text("two")
+        wrapWithRootIfNecessary(root) {
+          Text("three")
+        }
+      }
+    }
+
+    findByText("one\ntwo\nthree").assertIsDisplayed()
+  }
+
+  @Test fun wrapWithRootIfNecessary_seesUpdatesFromRootWrapper() {
+    val wrapperText = mutableStateOf("one")
+    val root: CompositionRoot = { content ->
+      Column {
+        Text(wrapperText.value)
+        content()
+      }
+    }
+
+    composeRule.setContent {
+      wrapWithRootIfNecessary(root) {
+        Text("two")
+      }
+    }
+
+    findByText("one\ntwo").assertIsDisplayed()
+    FrameManager.framed {
+      wrapperText.value = "ENO"
+    }
+    findByText("ENO\ntwo").assertIsDisplayed()
+  }
+
+  @Test fun wrapWithRootIfNecessary_rewrapsWhenDifferentRoot() {
+    val root1: CompositionRoot = { content ->
+      Column {
+        Text("one")
+        content()
+      }
+    }
+    val root2: CompositionRoot = { content ->
+      Column {
+        Text("ENO")
+        content()
+      }
+    }
+    val viewEnvironment = mutableStateOf(root1)
+
+    composeRule.setContent {
+      wrapWithRootIfNecessary(viewEnvironment.value) {
+        Text("two")
+      }
+    }
+
+    findByText("one\ntwo").assertIsDisplayed()
+    FrameManager.framed {
+      viewEnvironment.value = root2
+    }
+    findByText("ENO\ntwo").assertIsDisplayed()
+  }
+
   @Test fun safeComposeViewFactoryRoot_wraps_content() {
-    val wrapped = ComposeViewFactoryRoot { content ->
+    val wrapped: CompositionRoot = { content ->
       Column {
         Text("Parent")
         content()
       }
     }
-    val safeRoot = SafeComposeViewFactoryRoot(wrapped)
+    val safeRoot = safeCompositionRoot(wrapped)
 
     composeRule.setContent {
-      safeRoot.wrap {
+      safeRoot {
         // Need an explicit semantics container, otherwise both Texts will be merged into a single
         // Semantics object with the text "Parent\nChild".
         Semantics(container = true) {
@@ -58,12 +146,12 @@ class SafeComposeViewFactoryRootTest {
   }
 
   @Test fun safeComposeViewFactoryRoot_throws_whenChildrenNotInvoked() {
-    val wrapped = ComposeViewFactoryRoot { }
-    val safeRoot = SafeComposeViewFactoryRoot(wrapped)
+    val wrapped: CompositionRoot = { }
+    val safeRoot = safeCompositionRoot(wrapped)
 
     val error = assertFailsWith<IllegalStateException> {
       composeRule.setContent {
-        safeRoot.wrap {}
+        safeRoot {}
       }
     }
 
@@ -74,15 +162,15 @@ class SafeComposeViewFactoryRootTest {
   }
 
   @Test fun safeComposeViewFactoryRoot_throws_whenChildrenInvokedMultipleTimes() {
-    val wrapped = ComposeViewFactoryRoot { children ->
+    val wrapped: CompositionRoot = { children ->
       children()
       children()
     }
-    val safeRoot = SafeComposeViewFactoryRoot(wrapped)
+    val safeRoot = safeCompositionRoot(wrapped)
 
     val error = assertFailsWith<IllegalStateException> {
       composeRule.setContent {
-        safeRoot.wrap {
+        safeRoot {
           Text("Hello")
         }
       }

core-compose/src/androidTest/java/com/squareup/workflow/ui/compose/internal/ComposeViewFactoryRootTest.kt

@@ -25,7 +25,7 @@ import com.squareup.workflow.ui.ViewEnvironment
 import com.squareup.workflow.ui.ViewRegistry
 import com.squareup.workflow.ui.compose.bindCompose
 import com.squareup.workflow.ui.compose.showRendering
-import com.squareup.workflow.ui.compose.withComposeViewFactoryRoot
+import com.squareup.workflow.ui.compose.withCompositionRoot
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -37,7 +37,7 @@ class ViewFactoriesTest {
 
   @Test fun showRendering_wrapsFactoryWithRoot_whenAlreadyInComposition() {
     val viewEnvironment = ViewEnvironment(ViewRegistry(TestFactory))
-        .withComposeViewFactoryRoot { content ->
+        .withCompositionRoot { content ->
           Column {
             Text("one")
             content()

core-compose/src/androidTest/java/com/squareup/workflow/ui/compose/internal/ViewFactoriesTest.kt

@@ -73,11 +73,10 @@ import kotlin.reflect.KClass
  * ## Initializing Compose context
  *
  * Often all the [bindCompose] factories in an app need to share some context – for example, certain
- * ambients need to be provided, such as `MaterialTheme`. To configure this shared context, include
- * a [ComposeViewFactoryRoot] in your top-level [ViewEnvironment] (e.g. by using
- * [withComposeViewFactoryRoot]). The first time a [bindCompose] is used to show a rendering, its
- * [showRendering] function will be wrapped with the [ComposeViewFactoryRoot]. See the documentation
- * on [ComposeViewFactoryRoot] for more information.
+ * ambients need to be provided, such as `MaterialTheme`. To configure this shared context, call
+ * [withCompositionRoot] on your top-level [ViewEnvironment]. The first time a [bindCompose] is used
+ * to show a rendering, its [showRendering] function will be wrapped with the [CompositionRoot].
+ * See the documentation on [CompositionRoot] for more information.
  */
 inline fun <reified RenderingT : Any> bindCompose(
   noinline showRendering: @Composable() (
@@ -89,7 +88,7 @@ inline fun <reified RenderingT : Any> bindCompose(
 @PublishedApi
 internal class ComposeViewFactory<RenderingT : Any>(
   override val type: KClass<RenderingT>,
-  private val content: @Composable() (RenderingT, ViewEnvironment) -> Unit
+  val content: @Composable() (RenderingT, ViewEnvironment) -> Unit
 ) : ViewFactory<RenderingT> {
 
   override fun buildView(
@@ -129,22 +128,9 @@ internal class ComposeViewFactory<RenderingT : Any>(
     // Entry point to the world of Compose.
     composeContainer.setOrContinueContent(initialViewEnvironment) {
       val (rendering, environment) = renderState.value!!
-      showRenderingWrappedWithRoot(rendering, environment)
+      content(rendering, environment)
     }
 
     return composeContainer
   }
-
-  /**
-   * Invokes [content]. If this is the highest [ComposeViewFactory] in the tree, wraps with
-   * the [ComposeViewFactoryRoot] if present in the [ViewEnvironment].
-   */
-  @Composable internal fun showRenderingWrappedWithRoot(
-    rendering: RenderingT,
-    viewEnvironment: ViewEnvironment
-  ) {
-    wrapWithRootIfNecessary(viewEnvironment) {
-      content(rendering, viewEnvironment)
-    }
-  }
 }