Make scopes off of Chain

Signed-off-by: Michael X. Grey <grey@openrobotics.org>

Author: mxgrey

src/builder.rs

@@ -123,37 +123,7 @@ impl<'w, 's, 'a> Builder<'w, 's, 'a> {
         Streams: StreamPack,
     {
         let scope_id = self.commands.spawn(()).id();
-        let exit_scope = self.commands.spawn(UnusedTarget).id();
-        let operation = OperateScope::<Request, Response, Streams>::new(
-            scope_id, Some(exit_scope), settings, self.commands,
-        );
-        self.commands.add(AddOperation::new(scope_id, operation));
-
-        let (stream_in, stream_out) = Streams::spawn_scope_streams(
-            scope_id,
-            self.scope,
-            self.commands,
-        );
-
-        let mut builder = Builder {
-            scope: scope_id,
-            finish_scope_cancel: operation.finish_cancel(),
-            commands: self.commands,
-        };
-
-        let scope = Scope {
-            input: Output::new(scope_id, operation.enter_scope()),
-            terminate: InputSlot::new(scope_id, operation.terminal()),
-            streams: stream_in,
-        };
-
-        build(scope, &mut builder);
-
-        Node {
-            input: InputSlot::new(self.scope, scope_id),
-            output: Output::new(self.scope, exit_scope),
-            streams: stream_out,
-        }
+        self.create_scope_impl(scope_id, settings, build)
     }
 
     /// It is possible for a scope to be cancelled before it terminates. Even a
@@ -216,4 +186,49 @@ impl<'w, 's, 'a> Builder<'w, 's, 'a> {
     pub fn commands(&'a mut self) -> &'a mut Commands<'w, 's> {
         &mut self.commands
     }
+
+    /// Used internally to create scopes in different ways.
+    pub(crate) fn create_scope_impl<Request, Response, Streams>(
+        &mut self,
+        scope_id: Entity,
+        settings: ScopeSettings,
+        build: impl FnOnce(Scope<Request, Response, Streams>, &mut Builder),
+    ) -> Node<Request, Response, Streams>
+    where
+        Request: 'static + Send + Sync,
+        Response: 'static + Send + Sync,
+        Streams: StreamPack,
+    {
+        let exit_scope = self.commands.spawn(UnusedTarget).id();
+        let operation = OperateScope::<Request, Response, Streams>::new(
+            scope_id, Some(exit_scope), settings, self.commands,
+        );
+        self.commands.add(AddOperation::new(scope_id, operation));
+
+        let (stream_in, stream_out) = Streams::spawn_scope_streams(
+            scope_id,
+            self.scope,
+            self.commands,
+        );
+
+        let mut builder = Builder {
+            scope: scope_id,
+            finish_scope_cancel: operation.finish_cancel(),
+            commands: self.commands,
+        };
+
+        let scope = Scope {
+            input: Output::new(scope_id, operation.enter_scope()),
+            terminate: InputSlot::new(scope_id, operation.terminal()),
+            streams: stream_in,
+        };
+
+        build(scope, &mut builder);
+
+        Node {
+            input: InputSlot::new(self.scope, scope_id),
+            output: Output::new(self.scope, exit_scope),
+            streams: stream_out,
+        }
+    }
 }

src/chain.rs

@@ -21,9 +21,9 @@ use bevy::prelude::Entity;
 
 use crate::{
     UnusedTarget, AddOperation, Node, InputSlot, Builder,
-    ForkClone, StreamPack, Provider, ProvideOnce,
+    ForkClone, StreamPack, Provider, ProvideOnce, Scope,
     AsMap, IntoBlockingMap, IntoAsyncMap, Output, Noop,
-    ForkTargetStorage, StreamTargetMap,
+    ForkTargetStorage, StreamTargetMap, ScopeSettings,
     make_result_branching, make_cancel_filter_on_err,
     make_option_branching, make_cancel_filter_on_none,
 };
@@ -215,6 +215,42 @@ impl<'w, 's, 'a, 'b, T: 'static + Send + Sync> Chain<'w, 's, 'a, 'b, T> {
         self.then_node(f.into_async_map())
     }
 
+    /// Build a workflow scope to be used as an element in this chain.
+    ///
+    /// If you want to connect to the stream outputs, use
+    /// [`Self::then_scope_node`] instead.
+    #[must_use]
+    pub fn then_scope<Response, Streams>(
+        self,
+        settings: ScopeSettings,
+        build: impl FnOnce(Scope<T, Response, Streams>, &mut Builder),
+    ) -> Chain<'w, 's, 'a, 'b, Response>
+    where
+        Response: 'static + Send + Sync,
+        Streams: StreamPack,
+    {
+        self.builder.create_scope_impl::<T, Response, Streams>(
+            self.target, settings, build,
+        ).output.chain(self.builder)
+    }
+
+    /// From the current target in the chain, build a [scoped](Scope) workflow
+    /// and then get back a node that represents that scoped workflow.
+    #[must_use]
+    pub fn then_scope_node<Response, Streams>(
+        self,
+        settings: ScopeSettings,
+        build: impl FnOnce(Scope<T, Response, Streams>, &mut Builder),
+    ) -> Node<T, Response, Streams>
+    where
+        Response: 'static + Send + Sync,
+        Streams: StreamPack,
+    {
+        self.builder.create_scope_impl::<T, Response, Streams>(
+            self.target, settings, build,
+        )
+    }
+
     /// Apply a [`Provider`] that filters the response by returning an [`Option`].
     /// If the filter returns [`None`] then a cancellation is triggered.
     /// Otherwise the chain continues with the value given inside [`Some`].