trailblazer-activity 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b12275a2f1dfc9e9c90d7b3df76d2eab01db0964c453d61a23a307296cda2378
-  data.tar.gz: 93b881493ecec9eb50516cb1185ff1129c6fbc5efe478bc429604adae077c552
+  metadata.gz: dab847dcaff55b44bfa62dad2a7f8e662458bc082e941dccf1e8f189b87eb6fa
+  data.tar.gz: f8c1782081b72b024f5fdc06e49d040825979c3cd825cd2a242270fc100d65c3
 SHA512:
-  metadata.gz: 7245451409ba95340e9a3ef5e9404df93b3e2f7aa9325fe2132bc45f4f7fbcd49370200dfe9532fb5fa8f4307fdd3f4c6eae480920927e232228361712ac8cef
-  data.tar.gz: a127529dea689958ff467558c6a373b37cfe0e2e2475b99b24f854488b672ff012cb8cccdfc3b02339e1b20e62eecbd92e5148fbe7e80ad5da7b8242e7f2c793
+  metadata.gz: acd50922b312667f892d6b73d0c39fdb5cfc136f5421af01fdbb0383e065845e332518b02d068a3279b72cc5cbec1e2f6d22c0a9cbaf77abe25af8669b31a0f9
+  data.tar.gz: e493008be86cff07f981fb6ab6542b14749f17dc91c542bde511f7cfabe14b8b8b0c1eb91dccc6b714a24d66567846b03fe2dbc6898bd598b48b0dd2d16c5192

data/.travis.yml

@@ -5,7 +5,7 @@ rvm:
   - 2.1
   - 2.2
   - 2.3.3
-  - 2.4.1
+  - 2.4.3
   - 2.5.0
 matrix:
   include:

data/CHANGES.md

@@ -1,3 +1,9 @@
+# 0.5.0
+
+* Rename `Nested()` to `Subprocess` and move the original one to the `operation` gem.
+* Add merging: `Activity.merge!` now allows to compose an activity by merging another.
+* Enforce using `Output(..) => Track(:success)` instead of just the track color `:success`. This allow having IDs both symbols and strings.
+
 # 0.4.3
 
 * Make `:outputs` the canonical way to define outputs, and not `:plus_poles`. The latter is computed by the DSL if not passed.

data/NOTES

@@ -1,3 +1,6 @@
+# 2.2
+  * The `Polarizations` classes, e.g. in `FastTrack` could be steps in the normalizer? so we wouldn't need `reverse_merge`.
+
   # NOT lowest level. if you need that, use your own proc.
     # TODO: how do we track what goes into the callable?
     #                 adjust what goes into it (e.g. without direction or with kw args)?

data/lib/trailblazer/activity.rb

@@ -34,6 +34,8 @@ module Trailblazer
       def inspect
         "#<Trailblazer::Activity: {#{name || self[:options][:name]}}>"
       end
+
+      alias_method :to_s, :inspect
     end
 
 
@@ -42,7 +44,7 @@ module Trailblazer
     module DSLHelper
       extend Forwardable
       def_delegators :@builder, :Path
-      def_delegators DSL::Helper, :Output, :End, :Nested
+      def_delegators DSL::Helper, :Output, :End, :Subprocess, :Track
 
       def Path(*args, &block)
         self[:builder].Path(*args, &block)
@@ -69,14 +71,14 @@ module Trailblazer
     require "trailblazer/activity/dsl/add_task"
       include DSL::AddTask
 
-    require "trailblazer/activity/implementation/interface"
+    require "trailblazer/activity/interface"
       include Activity::Interface # DISCUSS
 
       include DSLHelper # DISCUSS
 
       include Activity::Inspect # DISCUSS
 
-    require "trailblazer/activity/magnetic/merge"
+    require "trailblazer/activity/dsl/magnetic/merge"
       include Magnetic::Merge # Activity#merge!
 
       def call(args, argumenter: [], **circuit_options) # DISCUSS: the argumenter logic might be moved out.
@@ -92,12 +94,11 @@ require "trailblazer/circuit"
 require "trailblazer/activity/structures"
 require "trailblazer/activity/config"
 
-require "trailblazer/activity/implementation/build_state"
-require "trailblazer/activity/implementation/interface"
-require "trailblazer/activity/implementation/path"
-require "trailblazer/activity/implementation/plan"
-require "trailblazer/activity/implementation/railway"
-require "trailblazer/activity/implementation/fast_track"
+require "trailblazer/activity/dsl/strategy/build_state"
+require "trailblazer/activity/dsl/strategy/path"
+require "trailblazer/activity/dsl/strategy/plan"
+require "trailblazer/activity/dsl/strategy/railway"
+require "trailblazer/activity/dsl/strategy/fast_track"
 
 require "trailblazer/activity/task_wrap"
 require "trailblazer/activity/task_wrap/call_task"
@@ -110,11 +111,12 @@ require "trailblazer/activity/present"
 
 require "trailblazer/activity/introspect"
 
-# require "trailblazer/activity/heritage"
-require "trailblazer/activity/subprocess"
+require "trailblazer/activity/dsl/magnetic/builder/state"
+require "trailblazer/activity/dsl/magnetic" # the "magnetic" DSL
+
+require "trailblazer/activity/dsl/schema/sequence"
+require "trailblazer/activity/dsl/schema/dependencies"
 
-require "trailblazer/activity/state"
-require "trailblazer/activity/magnetic" # the "magnetic" DSL
-require "trailblazer/activity/schema/sequence"
+require "trailblazer/activity/dsl/magnetic/builder/normalizer" # DISCUSS: name and location are odd. This one uses Activity ;)
 
-require "trailblazer/activity/magnetic/builder/normalizer" # DISCUSS: name and location are odd. This one uses Activity ;)
+require "trailblazer/activity/dsl/record"

data/lib/trailblazer/activity/dsl/add_task.rb

@@ -1,21 +1,21 @@
 class Trailblazer::Activity < Module
   module DSL
     module AddTask
-      def add_task!(name, task, options, &block)
+      def add_task!(strategy, polarizer, name, task, options, &block)
         # The beautiful thing about State.add is it doesn't mutate anything.
         # We're changing state here, on the outside, by overriding the ivars.
         # That in turn means, the only mutated entity is this module.
 
-        _builder, adds, circuit, outputs, options = State.add( self[:builder], self[:adds], name, task, options, &block ) # this could be an extension itself.
+        _builder, adds, circuit, outputs, returned_options = Magnetic::Builder::State.add( self[:builder], self[:adds], strategy, polarizer, task, options, &block ) # this could be an extension itself.
 
         self[:adds]    = adds
         self[:circuit] = circuit
         self[:outputs] = outputs
 
-        task, local_options = options
+        _, local_options = returned_options
 
         # {Extension API} call all extensions.
-        local_options[:extension].collect { |ext| ext.(self, *options) } if local_options[:extension]
+        local_options[:extension].collect { |ext| ext.( self, *returned_options, original_dsl_args: [name, task, options, block] ) } if local_options[:extension]
       end
     end
   end

data/lib/trailblazer/activity/dsl/helper.rb

@@ -4,14 +4,18 @@ module Trailblazer
     # the circuit, etc. Method comes in a module so it can be overridden via modules.
     #
     # This approach assumes you maintain a {#add_task!} method.
-    def self.def_dsl(_name)
+    def self.def_dsl(_name, strategy, polarizer)
       Module.new do
         define_method(_name) do |task, options={}, &block|
-          builder, adds, circuit, outputs, options = add_task!(_name, task, options, &block)  # TODO: similar to Block.
+          builder, adds, circuit, outputs, options = add_task!(strategy, polarizer, _name, task, options, &block)
         end
       end
     end
 
+    # @api private
+    OutputSemantic = Struct.new(:value)
+    Track          = Struct.new(:color)
+
     # Shortcut functions for the DSL. These have no state.
     module Helper
       module_function
@@ -19,7 +23,7 @@ module Trailblazer
       #   Output( Left, :failure )
       #   Output( :failure ) #=> Output::Semantic
       def Output(signal, semantic=nil)
-        return Activity::Magnetic::DSL::Output::Semantic.new(signal) if semantic.nil?
+        return OutputSemantic.new(signal) if semantic.nil?
 
         Activity.Output(signal, semantic)
       end
@@ -28,8 +32,12 @@ module Trailblazer
         Activity.End(semantic)
       end
 
+      def Track(color)
+        Track.new(color).freeze
+      end
+
       def Path(normalizer, track_color: "track_#{rand}", end_semantic: track_color, **options)
-        options    = options.merge(track_color: track_color, end_semantic: end_semantic)
+        options = options.merge(track_color: track_color, end_semantic: end_semantic)
 
         # Build an anonymous class which will be where the block is evaluated in.
         # We use the same normalizer here, so DSL calls in the inner block have the same behavior.
@@ -46,7 +54,7 @@ module Trailblazer
       end
 
       # Computes the :outputs options for {activity}
-      def Nested(activity)
+      def Subprocess(activity)
         {
           task:    activity,
           outputs: activity.outputs

data/lib/trailblazer/activity/dsl/magnetic.rb

@@ -0,0 +1,36 @@
+module Trailblazer
+  class Activity < Module   # all code related to the magnetic building of a circuit hash lives in this namespace.
+    module Magnetic
+      # PlusPole "radiates" a color that MinusPoles are attracted to.
+      #
+      # This datastructure is produced by the DSL and sits in an ADDS.
+      PlusPole = Struct.new(:output, :color) do
+        private :output
+
+        def signal
+          output.signal
+        end
+      end # PlusPole
+    end
+  end
+end
+
+require "trailblazer/activity/dsl/magnetic/process_options"
+require "trailblazer/activity/dsl/magnetic/structure/plus_poles"
+require "trailblazer/activity/dsl/magnetic/structure/polarization"
+require "trailblazer/activity/dsl/magnetic/structure/alterations"
+
+require "trailblazer/activity/dsl/magnetic"
+require "trailblazer/activity/dsl/magnetic/builder"
+# require "trailblazer/activity/dsl/magnetic/builder/dsl_helper"
+# require "trailblazer/activity/dsl/magnetic/dsl_helper"
+
+require "trailblazer/option"
+require "trailblazer/activity/task_builder"
+require "trailblazer/activity/dsl/magnetic/builder/default_normalizer"
+require "trailblazer/activity/dsl/magnetic/builder/path"
+require "trailblazer/activity/dsl/magnetic/builder/railway"
+require "trailblazer/activity/dsl/magnetic/builder/fast_track" # TODO: move to Operation gem.
+
+require "trailblazer/activity/dsl/magnetic/generate"
+require "trailblazer/activity/dsl/magnetic/finalizer"

data/lib/trailblazer/activity/{magnetic → dsl/magnetic}/builder.rb

@@ -1,5 +1,3 @@
-require "trailblazer/activity/magnetic/finalizer"
-
 module Trailblazer
   module Activity::Magnetic
 
@@ -41,21 +39,21 @@ module Trailblazer
       end
 
       # Public top-level entry point.
-      def insert(name, task, options, &block)
+      def insert(strategy, polarizer, task, options, &block)
         normalizer = options[:normalizer] || @normalizer # DISCUSS: do this at a deeper point?
 
         task, local_options, connection_options, sequence_options = normalizer.(task, options)
 
-        implementation, polarizations, task, local_options, block = send(name, task, local_options, &block) # builder.task
+        polarizations = strategy.send(polarizer, @builder_options) # Railway.StepPolarizations( @builder_options )
 
-        insert_element( implementation, polarizations, task, local_options, connection_options, sequence_options, &block )
+        insert_element( polarizations, task, local_options, connection_options, sequence_options, &block )
       end
 
       private
 
       # Internal top-level entry point to add task(s) and connections.
       # High level interface for DSL calls like ::task or ::step.
-      def insert_element(impl, polarizations, task, local_options, connection_options, sequence_options, &block)
+      def insert_element(polarizations, task, local_options, connection_options, sequence_options, &block)
         adds, *returned_options = Builder.adds_for(polarizations, task, local_options, connection_options, sequence_options, &block)
       end
 

data/lib/trailblazer/activity/{magnetic → dsl/magnetic}/builder/fast_track.rb

@@ -88,7 +88,7 @@ module Trailblazer
             adds(
               pass_fast_end,
 
-              Path::TaskPolarizations(builder_options.merge( type: :End )),
+              Path::EndEventPolarizations(builder_options),
 
               {},
               { group: :end },
@@ -100,7 +100,7 @@ module Trailblazer
             adds(
               fail_fast_end,
 
-              Path::TaskPolarizations(builder_options.merge( type: :End )),
+              Path::EndEventPolarizations(builder_options),
 
               {},
               { group: :end },
@@ -116,18 +116,6 @@ module Trailblazer
         # Direction signals.
         FailFast = Class.new(Activity::Signal)
         PassFast = Class.new(Activity::Signal)
-
-        def step(task, options={}, &block)
-          return FastTrack, FastTrack.StepPolarizations(@builder_options), task, options, block
-        end
-
-        def fail(task, options={}, &block)
-          return FastTrack, FastTrack.FailPolarizations(@builder_options), task, options, block
-        end
-
-        def pass(task, options={}, &block)
-          return FastTrack, FastTrack.PassPolarizations(@builder_options), task, options, block
-        end
       end
     end
   end

data/lib/trailblazer/activity/{magnetic → dsl/magnetic}/builder/normalizer.rb

@@ -54,13 +54,13 @@ module Trailblazer
         end
 
         # Filter out connections, e.g. `Output(:fail_fast) => :success` and return only the keywords like `:id` or `:replace`.
-        def self.extract_dsl_keywords(options, connection_classes = [Activity::Output, DSL::Output::Semantic])
+        def self.extract_dsl_keywords(options, connection_classes = [Activity::Output, Activity::DSL::OutputSemantic])
           options.keys - options.keys.find_all { |k| connection_classes.include?( k.class ) }
         end
 
         # FIXME; why don't we use the extensions passed into the initializer?
         def self.normalize_extension_option( ctx, local_options:, ** )
-          local_options[:extension] = (local_options[:extension]||[]) + [ Activity::Introspect.method(:add_introspection) ] # fixme: this sucks
+          local_options[:extension] = (local_options[:extension]||[]) + [ Activity::Introspect.method(:add_introspection), Activity::DSL.method(:record) ] # fixme: this sucks
         end
 
         # Normalizes ctx[:options]

data/lib/trailblazer/activity/{magnetic → dsl/magnetic}/builder/path.rb

@@ -14,17 +14,9 @@ module Trailblazer
           )
         end
 
-        def task(task, options={}, &block)
-          polarizations = Path.TaskPolarizations( @builder_options.merge( type: options[:type] ) ) # DISCUSS: handle :type here? Really?
-
-          return Path, polarizations, task, options, block
-        end
-
-              # @private Might be removed.
         def self.default_outputs
           {
-            success: Activity.Output(Activity::Right, :success),
-            # failure: Activity.Output(Activity::Left,  :failure),
+            success: Activity.Output(Activity::Right, :success)
           }
         end
 
@@ -48,7 +40,7 @@ module Trailblazer
           end_adds = adds(
             track_end,
 
-            TaskPolarizations(builder_options.merge( type: :End )),
+            EndEventPolarizations(builder_options),
 
             {}, { group: :end },
 
@@ -60,12 +52,14 @@ module Trailblazer
           start_adds + end_adds
         end
 
-        def self.TaskPolarizations(track_color:, type: :task, **)
-          return [EndPolarization.new( track_color: track_color )] if type == :End # DISCUSS: should this dispatch be here?
-
+        def self.TaskPolarizations(track_color:, **)
           [TaskPolarization.new( track_color: track_color )]
         end
 
+        def self.EndEventPolarizations(track_color:, **)
+          [EndEventPolarization.new( track_color: track_color )]
+        end
+
         class TaskPolarization
           def initialize(track_color:)
             @track_color = track_color
@@ -79,14 +73,14 @@ module Trailblazer
           end
         end # TaskPolarization
 
-        class EndPolarization < TaskPolarization
+        class EndEventPolarization < TaskPolarization
           def call(magnetic_to, plus_poles, options)
             [
               magnetic_to || [@track_color],
               {}
             ]
           end
-        end # EndPolarization
+        end # EndEventPolarization
       end # Path
     end # Builder
   end

data/lib/trailblazer/activity/{magnetic → dsl/magnetic}/builder/railway.rb

@@ -10,18 +10,6 @@ module Trailblazer
           )
         end
 
-        def step(task, options={}, &block)
-          return Railway, Railway.StepPolarizations(@builder_options), task, options, block
-        end
-
-        def fail(task, options={}, &block)
-          return Railway, Railway.FailPolarizations(@builder_options), task, options, block
-        end
-
-        def pass(task, options={}, &block)
-          return Railway, Railway.PassPolarizations(@builder_options), task, options, block
-        end
-
         def self.default_outputs
           Path.default_outputs.merge(
             :failure => Activity.Output(Activity::Left,  :failure),
@@ -36,7 +24,7 @@ module Trailblazer
           end_adds = adds(
             failure_end,
 
-            Path::TaskPolarizations(builder_options.merge( type: :End )),
+            Path::EndEventPolarizations(builder_options),
 
             {},
             { group: :end },

data/lib/trailblazer/activity/{state.rb → dsl/magnetic/builder/state.rb}

@@ -1,6 +1,6 @@
 module Trailblazer
-  class Activity < Module   # @private
-    # Maintain Builder/Adds/Process/Outputs as immutable objects.
+  class Activity::Magnetic::Builder
+    # Maintain Builder instance plus Adds/Process/Outputs as immutable objects.
     module State
       def self.build(builder_class, normalizer, builder_options)
         builder, adds = builder_class.for(normalizer, builder_options) # e.g. Path.for(...) which creates a Builder::Path instance.
@@ -8,8 +8,8 @@ module Trailblazer
         recompile(builder.freeze, adds.freeze)
       end
 
-      def self.add(builder, adds, name, *args, &block)
-        new_adds, *returned_options = builder.insert(name, *args, &block) # builder.task
+      def self.add(builder, adds, strategy, polarizer, *args, &block)
+        new_adds, *returned_options = builder.insert(strategy, polarizer, *args, &block) # TODO: move that out of here.
 
         adds = adds + new_adds
 
@@ -34,7 +34,7 @@ module Trailblazer
         #
         # @return [Process, Hash] The {Process} instance and its outputs hash.
         def self.call(adds)
-          circuit, end_events = Magnetic::Builder::Finalizer.(adds)
+          circuit, end_events = Finalizer.(adds)
           outputs             = recompile_outputs(end_events)
 
           return circuit, outputs

data/lib/trailblazer/activity/dsl/magnetic/merge.rb

@@ -0,0 +1,16 @@
+class Trailblazer::Activity < Module
+  module Magnetic
+    module Merge
+      def merge!(merged)
+        merged[:record].each do |key, args|
+          dsl_method, *args = args
+
+          return send( dsl_method, args[0], args[1], &args[2] ) if args[2]
+          send( dsl_method, args[0], args[1] )
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/trailblazer/activity/{magnetic/dsl.rb → dsl/magnetic/process_options.rb}

@@ -1,19 +1,6 @@
 module Trailblazer
   module Activity::Magnetic
     module DSL
-      class Polarization
-        def initialize( output:raise, color:raise )
-          @output, @color = output, color
-        end
-
-        def call(magnetic_to, plus_poles, options)
-          [
-            magnetic_to,
-            plus_poles.merge( @output => @color ) # this usually adds a new Output to the task.
-          ]
-        end
-      end # Polarization
-
       # This module only processes additional "wiring" options from the DSL calls
       #   Output(:success) => End("my.new")
       #
@@ -41,22 +28,16 @@ module Trailblazer
         end
 
         def process_tuple(id, output, task, plus_poles, &block)
-          output = output_for(output, plus_poles) if output.kind_of?(DSL::Output::Semantic)
+          output = output_for(output, plus_poles) if output.kind_of?(Activity::DSL::OutputSemantic)
 
           if task.kind_of?(Activity::End)
+            # raise %{An end event with semantic `#{task.to_h[:semantic]}` has already been added. Please use an ID reference: `=> "End.#{task.to_h[:semantic]}"`} if
             new_edge = "#{id}-#{output.signal}"
 
             [
               Polarization.new( output: output, color: new_edge ),
               [ [:add, [task.to_h[:semantic], [ [new_edge], task, [] ], group: :end]] ]
             ]
-          elsif task.is_a?(String) # let's say this means an existing step
-            new_edge = "#{id}-#{output.signal}-#{task}"
-
-            [
-              Polarization.new( output: output, color: new_edge ),
-              [[ :magnetic_to, [ task, [new_edge] ] ]],
-            ]
           # procs come from DSL calls such as `Path() do ... end`.
           elsif task.is_a?(Proc)
             start_color, activity = task.(block)
@@ -69,9 +50,16 @@ module Trailblazer
             # TODO: we also need to merge all the other states such as debug.
               adds[1..-1] # drop start
             ]
-          else # An additional plus polarization. Example: Output => :success
+          elsif task.is_a?(Activity::DSL::Track) # An additional plus polarization. Example: Output => :success
+            [
+              Polarization.new( output: output, color: task.color )
+            ]
+          else  # ID: existing step
+            new_edge = "#{id}-#{output.signal}-#{task}"
+
             [
-              Polarization.new( output: output, color: task )
+              Polarization.new( output: output, color: new_edge ),
+              [[ :magnetic_to, [ task, [new_edge] ] ]],
             ]
           end
         end
@@ -83,11 +71,6 @@ module Trailblazer
           output or raise("Couldn't find existing output for `#{semantic.value.inspect}`.")
         end
       end # OptionsProcessing
-
-      # DSL datastructures
-      module Output
-        Semantic = Struct.new(:value)
-      end
     end # DSL
   end
 end

data/lib/trailblazer/activity/{magnetic → dsl/magnetic}/structure/plus_poles.rb

@@ -73,20 +73,13 @@ module Trailblazer
         @plus_poles.values.collect { |output, color| PlusPole.new(output, color) }
       end
 
-      # Builds PlusPoles from { semantic => Output }, which, surprisingly, is exactly what Activity::outputs looks like.
-      # The plus pole's color is set to the output's semantic.
-      def self.from_outputs(outputs)
-        ary = outputs.collect { |semantic, output| [ output, semantic ] }
-
-        new.merge(::Hash[ary])
-      end
-
       # FIXME: should this be a hash or whatever?
       #
-      # @return Hash All {Output}s mapped to their semantic: `{ Output(Right, :success) => :success }`
+      # @return Hash All {Output}s mapped to their (guessed) semantic: `{ Output(Right, :success) => :success }`
       def self.initial(outputs)
         new.merge(Hash[ outputs.collect { |semantic, output| [output, semantic] } ])
       end
     end
   end
 end
+

data/lib/trailblazer/activity/dsl/magnetic/structure/polarization.rb

@@ -0,0 +1,23 @@
+module Trailblazer
+  module Activity::Magnetic
+    module DSL
+      # Every DSL method creates a set of polarizations that are evaluated and decide about a task's
+      # incoming and outgoing connections.
+      #
+      # @note The API of Polarization might be simplified soon.
+      # @api  private
+      class Polarization
+        def initialize( output:raise, color:raise )
+          @output, @color = output, color
+        end
+
+        def call(magnetic_to, plus_poles, options)
+          [
+            magnetic_to,
+            plus_poles.merge( @output => @color ) # this usually adds a new Output to the task.
+          ]
+        end
+      end # Polarization
+    end
+  end
+end

data/lib/trailblazer/activity/dsl/record.rb

@@ -0,0 +1,11 @@
+module Trailblazer
+  class Activity < Module
+    module DSL
+      # {:extension API}
+      # Record each DSL call (like #step) on the activity.
+      def self.record(activity, *args, original_dsl_args:)
+        activity[:record, original_dsl_args[1]] = original_dsl_args
+      end
+    end
+  end
+end

data/lib/trailblazer/activity/{implementation → dsl/strategy}/build_state.rb

@@ -24,7 +24,7 @@ class Trailblazer::Activity < Module
 
     # @api private
     def self.build_state(normalizer, builder_class:, builder_options: {}, **options)
-      builder, adds, circuit, outputs = State.build(builder_class, normalizer, options.merge(builder_options))
+      builder, adds, circuit, outputs = Magnetic::Builder::State.build(builder_class, normalizer, options.merge(builder_options))
 
       return builder, adds, circuit, outputs, options
     end

data/lib/trailblazer/activity/{implementation → dsl/strategy}/fast_track.rb

@@ -8,6 +8,11 @@ class Trailblazer::Activity < Module
     def self.config
       Railway.config.merge(
         builder_class:  Magnetic::Builder::FastTrack,
+        extend:          [
+          DSL.def_dsl(:step, Magnetic::Builder::FastTrack, :StepPolarizations),
+          DSL.def_dsl(:fail, Magnetic::Builder::FastTrack, :FailPolarizations),
+          DSL.def_dsl(:pass, Magnetic::Builder::FastTrack, :PassPolarizations)
+        ],
       )
     end
   end

data/lib/trailblazer/activity/{implementation → dsl/strategy}/path.rb

@@ -14,7 +14,11 @@ module Trailblazer
           default_outputs:  Magnetic::Builder::Path.default_outputs,
           extension:        [ Introspect.method(:add_introspection) ],
 
-          extend:           [ DSL.def_dsl(:task) ],
+          extend:           [
+            DSL.def_dsl(:task, Magnetic::Builder::Path,    :TaskPolarizations),
+            DSL.def_dsl(:_end, Magnetic::Builder::Path,    :EndEventPolarizations),
+            DSL.def_dsl(:pass, Magnetic::Builder::Railway, :PassPolarizations),
+          ],
         }
       end
     end # Path

data/lib/trailblazer/activity/{implementation → dsl/strategy}/railway.rb

@@ -10,7 +10,11 @@ module Trailblazer
         Path.config.merge(
           builder_class:   Magnetic::Builder::Railway,
           default_outputs: Magnetic::Builder::Railway.default_outputs,
-          extend:          [ DSL.def_dsl(:step), DSL.def_dsl(:fail), DSL.def_dsl(:pass) ],
+          extend:          [
+            DSL.def_dsl(:step, Magnetic::Builder::Railway, :StepPolarizations),
+            DSL.def_dsl(:fail, Magnetic::Builder::Railway, :FailPolarizations),
+            DSL.def_dsl(:pass, Magnetic::Builder::Railway, :PassPolarizations)
+          ],
         )
       end
     end

data/lib/trailblazer/activity/introspect.rb

@@ -37,7 +37,9 @@ module Trailblazer
 
       def self.inspect_task_builder(task)
         proc = task.instance_variable_get(:@user_proc)
-        %{#<TaskBuilder{#{proc}}>}
+        match = proc.inspect.match(/(\w+)>$/)
+
+        %{#<TaskBuilder{.#{match[1]}}>}
       end
 
         # FIXME: clean up that shit below.

data/lib/trailblazer/activity/structures.rb

@@ -1,5 +1,7 @@
   module Trailblazer
-    class Activity < Module     # End event is just another callable task.
+    class Activity < Module
+      # Generic run-time structures that are built via the DSL.
+
       # Builds an {Activity::End} instance.
       def self.End(semantic)
         End.new(semantic: semantic)
@@ -24,12 +26,11 @@
           @options
         end
 
-        def inspect
-          to_s
-        end
         def to_s
           %{#<#{self.class.name} #{@options.collect{ |k,v| "#{k}=#{v.inspect}" }.join(" ")}>}
         end
+
+        alias_method :inspect, :to_s
       end
 
       class Start < End

data/lib/trailblazer/activity/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Activity < Module
-    VERSION = "0.4.3"
+    VERSION = "0.5.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-02 00:00:00.000000000 Z
+date: 2018-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hirb
@@ -109,7 +109,6 @@ files:
 - CHANGES.md
 - Gemfile
 - NOTES
-- NOTES_
 - README.md
 - Rakefile
 - inspeccccccccct.rb
@@ -118,32 +117,33 @@ files:
 - lib/trailblazer/activity/config.rb
 - lib/trailblazer/activity/dsl/add_task.rb
 - lib/trailblazer/activity/dsl/helper.rb
-- lib/trailblazer/activity/implementation/build_state.rb
-- lib/trailblazer/activity/implementation/fast_track.rb
-- lib/trailblazer/activity/implementation/interface.rb
-- lib/trailblazer/activity/implementation/path.rb
-- lib/trailblazer/activity/implementation/plan.rb
-- lib/trailblazer/activity/implementation/railway.rb
+- lib/trailblazer/activity/dsl/magnetic.rb
+- lib/trailblazer/activity/dsl/magnetic/builder.rb
+- lib/trailblazer/activity/dsl/magnetic/builder/default_normalizer.rb
+- lib/trailblazer/activity/dsl/magnetic/builder/fast_track.rb
+- lib/trailblazer/activity/dsl/magnetic/builder/normalizer.rb
+- lib/trailblazer/activity/dsl/magnetic/builder/path.rb
+- lib/trailblazer/activity/dsl/magnetic/builder/railway.rb
+- lib/trailblazer/activity/dsl/magnetic/builder/state.rb
+- lib/trailblazer/activity/dsl/magnetic/finalizer.rb
+- lib/trailblazer/activity/dsl/magnetic/generate.rb
+- lib/trailblazer/activity/dsl/magnetic/merge.rb
+- lib/trailblazer/activity/dsl/magnetic/process_options.rb
+- lib/trailblazer/activity/dsl/magnetic/structure/alterations.rb
+- lib/trailblazer/activity/dsl/magnetic/structure/plus_poles.rb
+- lib/trailblazer/activity/dsl/magnetic/structure/polarization.rb
+- lib/trailblazer/activity/dsl/record.rb
+- lib/trailblazer/activity/dsl/schema/dependencies.rb
+- lib/trailblazer/activity/dsl/schema/sequence.rb
+- lib/trailblazer/activity/dsl/strategy/build_state.rb
+- lib/trailblazer/activity/dsl/strategy/fast_track.rb
+- lib/trailblazer/activity/dsl/strategy/path.rb
+- lib/trailblazer/activity/dsl/strategy/plan.rb
+- lib/trailblazer/activity/dsl/strategy/railway.rb
+- lib/trailblazer/activity/interface.rb
 - lib/trailblazer/activity/introspect.rb
-- lib/trailblazer/activity/magnetic.rb
-- lib/trailblazer/activity/magnetic/builder.rb
-- lib/trailblazer/activity/magnetic/builder/default_normalizer.rb
-- lib/trailblazer/activity/magnetic/builder/fast_track.rb
-- lib/trailblazer/activity/magnetic/builder/normalizer.rb
-- lib/trailblazer/activity/magnetic/builder/path.rb
-- lib/trailblazer/activity/magnetic/builder/railway.rb
-- lib/trailblazer/activity/magnetic/dsl.rb
-- lib/trailblazer/activity/magnetic/finalizer.rb
-- lib/trailblazer/activity/magnetic/generate.rb
-- lib/trailblazer/activity/magnetic/merge.rb
-- lib/trailblazer/activity/magnetic/structure/alterations.rb
-- lib/trailblazer/activity/magnetic/structure/plus_poles.rb
 - lib/trailblazer/activity/present.rb
-- lib/trailblazer/activity/schema/dependencies.rb
-- lib/trailblazer/activity/schema/sequence.rb
-- lib/trailblazer/activity/state.rb
 - lib/trailblazer/activity/structures.rb
-- lib/trailblazer/activity/subprocess.rb
 - lib/trailblazer/activity/task_builder.rb
 - lib/trailblazer/activity/task_wrap.rb
 - lib/trailblazer/activity/task_wrap/call_task.rb

data/NOTES_

@@ -1,36 +0,0 @@
-  # NOT lowest level. if you need that, use your own proc.
-    # TODO: how do we track what goes into the callable?
-    #                 adjust what goes into it (e.g. without direction or with kw args)?
-    #                 pre contract -> step -> post contract (are these all just steps, in "mini nested pipe"?)
-    #
-    #
-    # aka "Atom".
-    def self.Task(instance: :context, method: :call, id:nil)
-
-
-      # * ingoing contract (could be implemented as a nested pipe with 3 steps. that would allow us
-      #   to compile it to native ruby method calls later)
-      ->(direction, options, **flow_options) {
-        instance = flow_options[:context] if instance==:context # TODO; implement different :context (e.g. :my_context).
-
-
-
-      # * incoming args
-        # step_args = [args] # TODO: overridable.
-        step_args = [ options, **options ]
-
-      # ** call the actual thing
-        res = instance.send(method, *step_args) # what goes in? kws?
-
-      # * interpret result (e.g. true=>Right) (should we keep doing that in the tie? so the op has it easier with success, etc?)
-      # * outgoing contract
-      # * outgoing args
-
-        [ *res, flow_options ]
-
-
-      # * tracing: incoming, outgoing, direction, etc. - do we want that in tasks, too?
-
-
-      }
-    end

data/lib/trailblazer/activity/magnetic.rb

@@ -1,36 +0,0 @@
-module Trailblazer
-  class Activity < Module   # all code related to the magnetic building of a circuit hash lives in this namespace.
-    module Magnetic
-      # PlusPole "radiates" a color that MinusPoles are attracted to.
-      #
-      # This datastructure is produced by the DSL and sits in an ADDS.
-      PlusPole = Struct.new(:output, :color) do
-        private :output
-
-        def signal
-          output.signal
-        end
-      end # PlusPole
-    end
-  end
-end
-
-require "trailblazer/activity/magnetic/dsl"
-require "trailblazer/activity/magnetic/structure/plus_poles"
-require "trailblazer/activity/magnetic/structure/alterations"
-
-require "trailblazer/activity/schema/dependencies"
-
-require "trailblazer/activity/magnetic"
-require "trailblazer/activity/magnetic/builder"
-# require "trailblazer/activity/magnetic/builder/dsl_helper"
-# require "trailblazer/activity/magnetic/dsl_helper"
-
-require "trailblazer/option"
-require "trailblazer/activity/task_builder"
-require "trailblazer/activity/magnetic/builder/default_normalizer"
-require "trailblazer/activity/magnetic/builder/path"
-require "trailblazer/activity/magnetic/builder/railway"
-require "trailblazer/activity/magnetic/builder/fast_track" # TODO: move to Operation gem.
-
-require "trailblazer/activity/magnetic/generate"

data/lib/trailblazer/activity/magnetic/merge.rb

@@ -1,18 +0,0 @@
-class Trailblazer::Activity < Module
-  module Magnetic
-    module Merge
-      # THIS IS HIGHLY EXPERIMENTAL AS WE'RE NOT MERGING taskWrap etc.
-      def merge!(merged)
-        merged_adds = Builder.merge(self[:adds], merged[:adds])
-        # TODO: MERGE DEBUG, TASK_WRAP
-        builder, adds, circuit, outputs, = State.recompile(self[:builder], merged_adds)
-
-        self[:adds] = adds
-        self[:circuit] = circuit
-        self[:outputs] = outputs
-
-        self
-      end
-    end
-  end
-end

data/lib/trailblazer/activity/subprocess.rb

@@ -1,41 +0,0 @@
-module Trailblazer
-  class Activity < Module    # A {Subprocess} is an instance of an abstract {Activity} that can be `call`ed.
-     # It is the runtime instance that runs from a specific start event.
-    def self.Subprocess(*args)
-      Subprocess.new(*args)
-    end
-
-    # Subprocess allows to have tasks with a different call interface and start event.
-    # @param activity any object with an {Activity interface}
-    class Subprocess
-      include Interface
-
-      def initialize(activity, call: :call, **options)
-        @activity = activity
-        @options  = options
-        @call     = call
-      end
-
-      def call(args, **circuit_options)
-        @activity.public_send(@call, args, circuit_options.merge(@options))
-      end
-
-      # @private
-      def to_h
-        @activity.to_h # TODO: test explicitly
-      end
-
-      def debug
-        @activity.debug
-      end
-
-      def to_s
-        %{#<Trailblazer::Activity::Subprocess activity=#{@activity}>}
-      end
-    end
-  end
-end
-
-# circuit.( args, runner: Runner, start_at: raise, **circuit_flow_options )
-
-# subprocess.( options, flow_options, *args, start_event:<Event>, last_signal: signal )