trailblazer-activity 0.15.1 → 0.16.0

data/lib/trailblazer/activity/schema/compiler.rb

@@ -0,0 +1,106 @@
+module Trailblazer
+  class Activity
+    class Schema
+      class Intermediate
+        # @private This class might get removed in 0.17.0.
+        module Compiler
+          module_function
+
+          DEFAULT_CONFIG = {wrap_static: Hash.new(Activity::TaskWrap.initial_wrap_static.freeze)} # DISCUSS: this really doesn't have to be here, but works for now and we want it in 99%.
+
+          # Compiles a {Schema} instance from an {intermediate} structure and
+          # the {implementation} object references.
+          #
+          # Intermediate structure, Implementation, calls extensions, passes {config} # TODO
+          def call(intermediate, implementation, config_merge: {})
+            config = DEFAULT_CONFIG
+              .merge(config_merge)
+              .freeze
+
+            circuit, outputs, nodes, config = schema_components(intermediate, implementation, config)
+
+            Schema.new(circuit, outputs, nodes, config)
+          end
+
+          # From the intermediate "template" and the actual implementation, compile a {Circuit} instance.
+          def schema_components(intermediate, implementation, config)
+            wiring = {}
+            nodes_attributes  = []
+
+            intermediate.wiring.each do |task_ref, outs|
+              id        = task_ref.id
+              impl_task = implementation.fetch(id)
+              task      = impl_task.circuit_task
+              outputs   = impl_task.outputs
+
+              wiring[task] = connections_for(outs, outputs, implementation)
+
+              nodes_attributes << [
+                id,               # id
+                task,             # task
+                task_ref[:data],  # TODO: allow adding data from implementation.
+                outputs           # {Activity::Output}s
+              ]
+
+              # Invoke each task's extensions (usually coming from the DSL user or some macro).
+              # We're expecting each {ext} to be a {TaskWrap::Extension::WrapStatic} instance.
+              config = invoke_extensions_for(config, impl_task, id)
+            end
+
+            start_id = intermediate.start_task_id
+
+            terminus_to_output  = terminus_to_output(intermediate, implementation)
+            activity_outputs    = terminus_to_output.values
+
+            circuit = Circuit.new(
+              wiring,
+              terminus_to_output.keys, # termini
+              start_task: implementation.fetch(start_id).circuit_task
+            )
+
+            return circuit,
+              activity_outputs,
+              Schema::Nodes(nodes_attributes),
+              config
+          end
+
+          # Compute the connections for {circuit_task}.
+          # For a terminus, this produces an empty hash.
+          def connections_for(intermediate_outs, task_outputs, implementation)
+            intermediate_outs.collect { |intermediate_out| # Intermediate::Out, it's abstract.
+              [
+                output_for_semantic(task_outputs, intermediate_out.semantic).signal,
+                implementation.fetch(intermediate_out.target).circuit_task    # Find the implementation task, the Ruby code component for runtime.
+              ]
+            }.to_h
+          end
+
+          def terminus_to_output(intermediate, implementation)
+            terminus_to_semantic = intermediate.stop_task_ids
+
+            terminus_to_semantic.collect do |id, semantic|
+              terminus_task = implementation.fetch(id).circuit_task
+
+              [
+                terminus_task,
+                Activity::Output(terminus_task, semantic) # The End instance is the signal.
+              ]
+            end.to_h
+          end
+
+          # Run all Implementation::Task.extensions and return new {config}
+          def invoke_extensions_for(config, impl_task, id)
+            impl_task
+              .extensions
+              .inject(config) { |cfg, ext| ext.(config: cfg, id: id, task: impl_task) } # {ext} must return new config hash.
+          end
+
+          # In an array of {Activity::Output}, find the output matching {semantic}.
+          def output_for_semantic(outputs, semantic)
+            outputs.find { |out| out.semantic == semantic } or raise "`#{semantic}` not found in implementation"
+          end
+        end # Intermediate
+      end
+    end
+  end
+end

data/lib/trailblazer/activity/schema/implementation.rb

@@ -1,10 +1,11 @@
 class Trailblazer::Activity
   class Schema
+    # @private This class might get removed in 0.17.0.
     module Implementation
       # Implementation structures
       Task = Struct.new(:circuit_task, :outputs, :extensions)
 
-      def self.Task(task, outputs, extensions=[])
+      def self.Task(task, outputs, extensions = [])
         Task.new(task, outputs, extensions)
       end
     end

data/lib/trailblazer/activity/schema/intermediate.rb

@@ -2,97 +2,17 @@ class Trailblazer::Activity
   class Schema
     # An {Intermediate} structure defines the *structure* of the circuit. It usually
     # comes from a DSL or a visual editor.
-    class Intermediate < Struct.new(:wiring, :stop_task_ids, :start_task_ids)
+    # @private This class might get removed in 0.17.0.
+    class Intermediate < Struct.new(:wiring, :stop_task_ids, :start_task_id)
       TaskRef = Struct.new(:id, :data) # TODO: rename to NodeRef
       Out     = Struct.new(:semantic, :target)
 
-      def self.TaskRef(id, data={}); TaskRef.new(id, data) end
-      def self.Out(*args);           Out.new(*args)        end
-
-      # Compiles a {Schema} instance from an {intermediate} structure and
-      # the {implementation} object references.
-      #
-      # Intermediate structure, Implementation, calls extensions, passes {config} # TODO
-      def self.call(intermediate, implementation, config_merge: {})
-        config_default = {wrap_static: Hash.new(TaskWrap.initial_wrap_static)} # DISCUSS: this really doesn't have to be here, but works for now and we want it in 99%.
-        config         = config_default.merge(config_merge)
-        config.freeze
-
-        circuit = circuit(intermediate, implementation)
-        nodes   = node_attributes(intermediate, implementation)
-        outputs = outputs(intermediate.stop_task_ids, nodes)
-        config  = config(implementation, config: config)
-
-        Schema.new(circuit, outputs, nodes, config)
-      end
-
-      # From the intermediate "template" and the actual implementation, compile a {Circuit} instance.
-      def self.circuit(intermediate, implementation)
-        end_events = intermediate.stop_task_ids
-
-        wiring = Hash[
-          intermediate.wiring.collect do |task_ref, outs|
-            task = implementation.fetch(task_ref.id)
-
-            [
-              task.circuit_task,
-              end_events.include?(task_ref.id) ? {} : connections_for(outs, task.outputs, implementation)
-            ]
-          end
-        ]
-
-        Circuit.new(
-          wiring,
-          intermediate.stop_task_ids.collect { |id| implementation.fetch(id).circuit_task },
-          start_task: intermediate.start_task_ids.collect { |id| implementation.fetch(id).circuit_task }[0]
-        )
-      end
-
-      # Compute the connections for {circuit_task}.
-      def self.connections_for(outs, task_outputs, implementation)
-        Hash[
-          outs.collect { |required_out| # Intermediate::Out, it's abstract.
-            [
-              for_semantic(task_outputs, required_out.semantic).signal,
-              implementation.fetch(required_out.target).circuit_task
-            ]
-          }.compact
-        ]
+      def self.TaskRef(id, data = {})
+        TaskRef.new(id, data)
       end
 
-      def self.node_attributes(intermediate, implementation)
-        intermediate.wiring.collect do |task_ref, outputs|
-          id                  = task_ref.id
-          implementation_task = implementation.fetch(id)
-          data                = task_ref[:data] # TODO: allow adding data from implementation.
-
-          NodeAttributes.new(id, implementation_task.outputs, implementation_task.circuit_task, data)
-        end
-      end
-
-      # intermediate/implementation independent.
-      def self.outputs(stop_task_ids, nodes_attributes)
-        stop_task_ids.collect do |id|
-          # Grab the {outputs} of the stop nodes.
-          nodes_attributes.find { |node_attrs| id == node_attrs.id }.outputs
-        end.flatten(1)
-      end
-
-      # Invoke each task's extensions (usually coming from the DSL user or some macro).
-      # We're expecting each {ext} to be a {TaskWrap::Extension::WrapStatic} instance.
-      def self.config(implementation, config:)
-        implementation.each do |id, task|
-          task.extensions.each { |ext| config = ext.(config: config, id: id, task: task) } # DISCUSS: ext must return new {Config}.
-        end
-
-        config
-      end
-
-
-
-      # Apply to any array.
-      private_class_method def self.for_semantic(outputs, semantic)
-        outputs.find { |out| out.semantic == semantic } or raise "`#{semantic}` not found"
+      def self.Out(*args)
+        Out.new(*args)
       end
     end # Intermediate
   end

data/lib/trailblazer/activity/schema.rb

@@ -1,15 +1,38 @@
 module Trailblazer
   class Activity
-    # In NodeAttributes we store data from Intermediate and Implementing compile-time.
-    # This would be lost otherwise.
-    NodeAttributes = Struct.new(:id, :outputs, :task, :data) # TODO: rename to Schema::Task::Attributes.
-
+    # The idea with {:config} is to have a generic runtime store for feature fields
+    # like {:wrap_static} but also for flags, e.g. `each: true` from the Each() macro.
     class Schema < Struct.new(:circuit, :outputs, :nodes, :config)
       # {:nodes} is passed directly from {compile_activity}. We need to store this data here.
 
       # @!method to_h()
       #   Returns a hash containing the schema's components.
 
+      class Nodes < Hash
+        # In Attributes we store data from Intermediate and Implementing compile-time.
+        # This would be lost otherwise.
+        Attributes = Struct.new(:id, :task, :data, :outputs)
+      end
+
+      # Builder for {Schema::Nodes} datastructure.
+      #
+      # A {Nodes} instance is a hash of Attributes, keyed by task. It turned out that
+      # 90% of introspect lookups, we search for attributes for a particular *task*, not ID.
+      # That's why in 0.16.0 we changed this structure.5
+      #
+      # Nodes{#<task> => #<Nodes::Attributes id= task= data= outputs=>}
+      #
+      # @private Please use {Introspect.Nodes} for querying nodes.
+      def self.Nodes(nodes)
+        Nodes[
+          nodes.collect do |attrs|
+            [
+              attrs[1], # task
+              Nodes::Attributes.new(*attrs).freeze
+            ]
+          end
+        ].freeze
+      end
     end # Schema
   end
 end

data/lib/trailblazer/activity/structures.rb

@@ -12,8 +12,8 @@ module Trailblazer
         @options = options.merge(semantic: semantic)
       end
 
-      def call(args, **circuit_options)
-        return self, args, **circuit_options
+      def call(args, **)
+        return self, args
       end
 
       def to_h
@@ -21,21 +21,23 @@ module Trailblazer
       end
 
       def to_s
-        %{#<#{self.class.name} #{@options.collect { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>}
+        %(#<#{self.class.name} #{@options.collect { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>)
       end
 
       alias inspect to_s
     end
 
     class Start < End
-      def call(args, **circuit_options)
-        return Activity::Right, args, **circuit_options
+      def call(args, **)
+        return Activity::Right, args
       end
     end
 
-    class Signal;         end
+    class Signal; end
+
     class Right < Signal; end
-    class Left  < Signal; end
+
+    class Left < Signal; end
 
     # signal:   actual signal emitted by the task
     # color:    the mapping, where this signal will travel to. This can be e.g. Left=>:success. The polarization when building the graph.

data/lib/trailblazer/activity/task_wrap/call_task.rb

@@ -13,7 +13,10 @@ class Trailblazer::Activity
       return_signal, return_args = task.(original_arguments, **original_circuit_options)
 
       # DISCUSS: do we want original_args here to be passed on, or the "effective" return_args which are different to original_args now?
-      wrap_ctx = wrap_ctx.merge( return_signal: return_signal, return_args: return_args )
+      wrap_ctx = wrap_ctx.merge(
+        return_signal: return_signal,
+        return_args:   return_args
+      )
 
       return wrap_ctx, original_args
     end

data/lib/trailblazer/activity/task_wrap/extension.rb

@@ -9,7 +9,7 @@ module Trailblazer
     #   |-- Call (call actual task) id: "task_wrap.call_task"
     #   |-- Trace.capture_return [optional]
     #   |-- Wrap::End
-    module TaskWrap      
+    module TaskWrap
       # inserts must be
       # An {Extension} can be used for {:wrap_runtime}. It expects a collection of
       # "friendly interface" arrays.
@@ -86,14 +86,20 @@ Please update to the new TaskWrap.Extension() API."
           end
 
           def call(config:, task:, **)
-            # Add the extension's task(s) to the activity's {wrap_static} taskWrap
-            # by using the immutable {Config} interface.
-            before_pipe = Config.get(config, :wrap_static, task.circuit_task)
+            # DISCUSS: does it make sense to test the immutable behavior here? What would be the worst outcome?
+            task = task.circuit_task # Receives {Schema::Implementation::Task}. DISCUSS: why?
 
-            Config.set(config, :wrap_static, task.circuit_task, @extension.(before_pipe))
+            # Add the extension's task(s) to the activity's {:wrap_static} taskWrap
+            # which is stored in the {:config} field.
+            wrap_static = config[:wrap_static]                 # the activity's {wrap_static}.
+            task_wrap   = wrap_static[task] # the "original" taskWrap for {task}.
+
+            # Overwrite the original task_wrap:
+            wrap_static = wrap_static.merge(task => @extension.(task_wrap))
+
+            config.merge(wrap_static: wrap_static) # Return new config hash. This needs to be immutable code!
           end
         end # WrapStatic
-
       end # Extension
     end # TaskWrap
   end

data/lib/trailblazer/activity/task_wrap/pipeline.rb

@@ -29,7 +29,7 @@ class Trailblazer::Activity
           insert_before: :Prepend,
           insert_after: :Append,
           append: :Append,
-          prepend: :Prepend,
+          prepend: :Prepend
         }.fetch(name)
 
         warn "[Trailblazer] Using `Trailblazer::Activity::TaskWrap::Pipeline.method(:#{name})` is deprecated.

data/lib/trailblazer/activity/task_wrap/runner.rb

@@ -10,7 +10,7 @@ class Trailblazer::Activity
       # @api private
       # @interface Runner
       def self.call(task, args, **circuit_options)
-        wrap_ctx = { task: task }
+        wrap_ctx = {task: task}
 
         # this pipeline is "wrapped around" the actual `task`.
         task_wrap_pipeline = merge_static_with_runtime(task, **circuit_options) || raise
@@ -28,14 +28,13 @@ class Trailblazer::Activity
         return wrap_ctx[:return_signal], wrap_ctx[:return_args]
       end
 
-
       # Compute the task's wrap by applying alterations both static and from runtime.
       #
       # NOTE: this is for performance reasons: we could have only one hash containing everything but that'd mean
       # unnecessary computations at `call`-time since steps might not even be executed.
       # TODO: make this faster.
-      private_class_method def self.merge_static_with_runtime(task, wrap_runtime:, **circuit_options)
-        static_wrap = TaskWrap.wrap_static_for(task, **circuit_options) # find static wrap for this specific task [, or default wrap activity].
+      private_class_method def self.merge_static_with_runtime(task, wrap_runtime:, activity:, **circuit_options)
+        static_wrap = TaskWrap.wrap_static_for(task, activity) # find static wrap for this specific task [, or default wrap activity].
 
         # Apply runtime alterations.
         # Grab the additional wirings for the particular `task` from `wrap_runtime`.
@@ -44,9 +43,11 @@ class Trailblazer::Activity
     end # Runner
 
     # Retrieve the static wrap config from {activity}.
-    def self.wrap_static_for(task, activity:, **)
-      wrap_static = activity[:wrap_static]
-      wrap_static[task] or raise "#{task}"
+    # @private
+    def self.wrap_static_for(task, activity)
+      activity.to_h
+        .fetch(:config)
+        .fetch(:wrap_static)[task] # the {wrap_static} for {task}.
     end
   end
 end

data/lib/trailblazer/activity/task_wrap.rb

@@ -21,7 +21,7 @@ module Trailblazer
         circuit_options = circuit_options.merge(
           runner:       TaskWrap::Runner,
           wrap_runtime: wrap_runtime,
-          activity:     container_activity, # for Runner. Ideally we'd have a list of all static_wraps here (even nested).
+          activity:     container_activity # for Runner. Ideally we'd have a list of all static_wraps here (even nested).
         )
 
         # signal, (ctx, flow), circuit_options =
@@ -43,10 +43,13 @@ module Trailblazer
       #
       # DISCUSS: we could cache that on Strategy/Operation level.
       #          merging the **config hash is 1/4 slower than before.
-      def container_activity_for(activity, wrap_static: initial_wrap_static, **config)
+      def container_activity_for(activity, wrap_static: initial_wrap_static, id: nil, **config)
         {
-          wrap_static:  {activity => wrap_static},
-          **config
+          config: {
+            wrap_static: {activity => wrap_static},
+            **config
+          },
+          nodes:  Schema.Nodes([[id, activity]])
         }
       end
 
@@ -54,4 +57,3 @@ module Trailblazer
     end # TaskWrap
   end
 end
-

data/lib/trailblazer/activity/testing.rb

@@ -10,8 +10,9 @@ module Trailblazer
     def self.def_steps(*names)
       Module.new do
         module_function
+
         names.each do |name|
-          define_method(name) do | ctx, ** |
+          define_method(name) do |ctx, **|
             ctx[:seq] << name
             ctx.key?(name) ? ctx[name] : true
           end
@@ -24,21 +25,15 @@ module Trailblazer
     # @example
     #   task task: T.def_task(:create)
     def self.def_task(name)
-      Module.new do
-        define_singleton_method(name) do | (ctx, flow_options), ** |
-          ctx[:seq] << name
-          signal = ctx.key?(name) ? ctx[name] : Activity::Right
-
-          return signal, [ctx, flow_options]
-        end
-      end.method(name)
+      def_tasks(name).method(name)
     end
 
     def self.def_tasks(*names)
       Module.new do
         module_function
+
         names.each do |name|
-          define_method(name) do | (ctx, flow_options), ** |
+          define_method(name) do |(ctx, flow_options), **|
             ctx[:seq] << name
             signal = ctx.key?(name) ? ctx[name] : Activity::Right
 
@@ -49,136 +44,62 @@ module Trailblazer
     end
 
     module Assertions
-        Activity  = Trailblazer::Activity
-        Inter     = Trailblazer::Activity::Schema::Intermediate
-        Schema    = Trailblazer::Activity::Schema
-        TaskWrap  = Trailblazer::Activity::TaskWrap
-
-        # `:seq` is always passed into ctx.
-        # @param :seq String What the {:seq} variable in the result ctx looks like. (expected seq)
-        # @param :expected_ctx_variables Variables that are added during the call by the asserted activity.
-        def assert_call(activity, terminus: :success, seq: "[]", expected_ctx_variables: {}, **ctx_variables)
-          # Call without taskWrap!
-          signal, (ctx, _) = activity.([{seq: [], **ctx_variables}, _flow_options = {}]) # simply call the activity with the input you want to assert.
-
-          assert_call_for(signal, ctx, terminus: terminus, seq: seq, **expected_ctx_variables, **ctx_variables)
-        end
-
-        # Use {TaskWrap.invoke} to call the activity.
-        def assert_invoke(activity, terminus: :success, seq: "[]", circuit_options: {}, expected_ctx_variables: {}, **ctx_variables)
-          signal, (ctx, _flow_options) = TaskWrap.invoke(
-            activity,
-            [
-              {seq: [], **ctx_variables},
-              {}                          # flow_options
-            ],
-            **circuit_options
-          )
-
-          assert_call_for(signal, ctx, terminus: terminus, seq: seq, **ctx_variables, **expected_ctx_variables) # DISCUSS: ordering of variables?
-        end
-
-        def assert_call_for(signal, ctx, terminus: :success, seq: "[]", **ctx_variables)
-          assert_equal signal.to_h[:semantic], terminus, "assert_call expected #{terminus} terminus, not #{signal}. Use assert_call(activity, terminus: #{signal.to_h[:semantic].inspect})"
-
-          assert_equal ctx.inspect, {seq: "%%%"}.merge(ctx_variables).inspect.sub('"%%%"', seq)
-
-          return ctx
-        end
-
-        module Implementing
-          extend Activity::Testing.def_tasks(:a, :b, :c, :d, :f, :g)
+      # `:seq` is always passed into ctx.
+      # @param :seq String What the {:seq} variable in the result ctx looks like. (expected seq)
+      # @param :expected_ctx_variables Variables that are added during the call by the asserted activity.
+      def assert_call(activity, terminus: :success, seq: "[]", expected_ctx_variables: {}, **ctx_variables)
+        # Call without taskWrap!
+        signal, (ctx, _) = activity.([{seq: [], **ctx_variables}, _flow_options = {}]) # simply call the activity with the input you want to assert.
+
+        assert_call_for(signal, ctx, terminus: terminus, seq: seq, **expected_ctx_variables, **ctx_variables)
+      end
 
-          Start = Activity::Start.new(semantic: :default)
-          Failure = Activity::End(:failure)
-          Success = Activity::End(:success)
-        end
+      # Use {TaskWrap.invoke} to call the activity.
+      def assert_invoke(activity, terminus: :success, seq: "[]", circuit_options: {}, expected_ctx_variables: {}, **ctx_variables)
+        signal, (ctx, _flow_options) = Activity::TaskWrap.invoke(
+          activity,
+          [
+            {seq: [], **ctx_variables},
+            {}                          # flow_options
+          ],
+          **circuit_options
+        )
+
+        assert_call_for(signal, ctx, terminus: terminus, seq: seq, **ctx_variables, **expected_ctx_variables) # DISCUSS: ordering of variables?
+      end
 
-        # TODO: Remove this once all its references are removed
-        def implementing
-          Implementing
-        end
+      def assert_call_for(signal, ctx, terminus: :success, seq: "[]", **ctx_variables)
+        assert_equal signal.to_h[:semantic], terminus, "assert_call expected #{terminus} terminus, not #{signal}. Use assert_call(activity, terminus: #{signal.to_h[:semantic].inspect})"
 
-        def flat_activity(implementing: Implementing)
-          return @_flat_activity if defined?(@_flat_activity)
-
-          intermediate = Inter.new(
-            {
-              Inter::TaskRef("Start.default")      => [Inter::Out(:success, :B)],
-              Inter::TaskRef(:B, additional: true) => [Inter::Out(:success, :C), Inter::Out(:failure, "End.failure")],
-              Inter::TaskRef(:C)                   => [Inter::Out(:success, "End.success")],
-              Inter::TaskRef("End.success", stop_event: true) => [Inter::Out(:success, nil)],
-              Inter::TaskRef("End.failure", stop_event: true) => [Inter::Out(:failure, nil)],
-            },
-            ["End.success", "End.failure"],
-            ["Start.default"], # start
-          )
-
-          implementation = {
-            "Start.default" => Schema::Implementation::Task(st = Implementing::Start, [Activity::Output(Activity::Right, :success)],        []),
-            :B => Schema::Implementation::Task(b = implementing.method(:b), [Activity::Output(Activity::Right, :success), Activity::Output(Activity::Left, :failure)],                  []),
-            :C => Schema::Implementation::Task(c = implementing.method(:c), [Activity::Output(Activity::Right, :success)],                  []),
-            "End.success" => Schema::Implementation::Task(_es = Implementing::Success, [Activity::Output(Implementing::Success, :success)], []), # DISCUSS: End has one Output, signal is itself?
-            "End.failure" => Schema::Implementation::Task(Implementing::Failure, [Activity::Output(Implementing::Failure, :failure)], []), # DISCUSS: End has one Output, signal is itself?
-          }
-
-          schema = Inter.(intermediate, implementation)
-
-          @_flat_activity = Activity.new(schema)
-        end
+        assert_equal ctx.inspect, {seq: "%%%"}.merge(ctx_variables).inspect.sub('"%%%"', seq)
 
-# FIXME: why is this in Testing? We don't need this anywhere but in this gem.
-        def nested_activity(flat_activity: bc, d_id: :D)
-          intermediate = Inter.new(
-            {
-              Inter::TaskRef("Start.default") => [Inter::Out(:success, :B)],
-              Inter::TaskRef(:B, more: true)  => [Inter::Out(:success, d_id)],
-              Inter::TaskRef(d_id) => [Inter::Out(:success, :E)],
-              Inter::TaskRef(:E) => [Inter::Out(:success, "End.success")],
-              Inter::TaskRef("End.success", stop_event: true) => [Inter::Out(:success, nil)]
-            },
-            ["End.success"],
-            ["Start.default"] # start
-          )
-
-          implementation = {
-            "Start.default" => Schema::Implementation::Task(st = Implementing::Start, [Activity::Output(Activity::Right, :success)],        []),
-            :B => Schema::Implementation::Task(b = Implementing.method(:b), [Activity::Output(Activity::Right, :success)],                  []),
-            d_id => Schema::Implementation::Task(flat_activity, [Activity::Output(Implementing::Success, :success)],                  []),
-            :E => Schema::Implementation::Task(e = Implementing.method(:f), [Activity::Output(Activity::Right, :success)],                  []),
-            "End.success" => Schema::Implementation::Task(_es = Implementing::Success, [Activity::Output(Implementing::Success, :success)], []), # DISCUSS: End has one Output, signal is itself?
-          }
-
-          schema = Inter.(intermediate, implementation)
-
-          Activity.new(schema)
-        end
+        return ctx
+      end
 
-        alias_method :bc, :flat_activity
-        alias_method :bde, :nested_activity
+      # Tests {:circuit} and {:outputs} fields so far.
+      def assert_process_for(process, *args)
+        semantics, circuit = args[0..-2], args[-1]
 
-        # Tests {:circuit} and {:outputs} fields so far.
-        def assert_process_for(process, *args)
-          semantics, circuit = args[0..-2], args[-1]
+        inspects = semantics.collect { |semantic| %(#<struct Trailblazer::Activity::Output signal=#<Trailblazer::Activity::End semantic=#{semantic.inspect}>, semantic=#{semantic.inspect}>) }
 
-          inspects = semantics.collect { |semantic| %{#<struct Trailblazer::Activity::Output signal=#<Trailblazer::Activity::End semantic=#{semantic.inspect}>, semantic=#{semantic.inspect}>} }
+        assert_equal %([#{inspects.join(", ")}]), process.to_h[:outputs].inspect
 
-          assert_equal %{[#{inspects.join(", ")}]}, process.to_h[:outputs].inspect
+        assert_circuit(process, circuit)
 
-          assert_circuit(process, circuit)
+        process
+      end
 
-          process
-        end
+      alias_method :assert_process, :assert_process_for
 
-        def assert_circuit(schema, circuit)
-          cct = Cct(schema)
+      def assert_circuit(schema, circuit)
+        cct = Cct(schema)
 
-          cct = cct.gsub("#<Trailblazer::Activity::TaskBuilder::Task user_proc=", "<*")
-          assert_equal %{#{circuit}}, cct
-        end
+        cct = cct.gsub("#<Trailblazer::Activity::TaskBuilder::Task user_proc=", "<*")
+        assert_equal circuit.to_s, cct
+      end
 
       def Cct(activity)
-        Trailblazer::Developer::Render::Circuit.(activity, inspect_task: Trailblazer::Activity::Testing.method(:render_task))
+        Activity::Introspect::Render.(activity, inspect_task: Trailblazer::Activity::Testing.method(:render_task))
       end
     end
 

data/lib/trailblazer/activity/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Activity
-      VERSION = '0.15.1'
+      VERSION = "0.16.0"
     end
   end
 end