trailblazer-activity 0.3.2 → 0.4.o

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

@@ -0,0 +1,16 @@
+class Trailblazer::Activity < Module
+  module Interface
+    # @return [Process, Hash, Adds] Adds is private and should not be used in your application as it might get removed.
+    def decompose # TODO: test me
+      @state.to_h
+    end
+
+    def debug # TODO: TEST ME
+      decompose[:debug]
+    end
+
+    def outputs
+      decompose[:outputs]
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Trailblazer
+  class Activity < Module
+    def self.Path(options={})
+      Activity::Path.new(Path, options)
+    end
+
+    # Implementation module that can be passed to `Activity[]`.
+    class Path < Activity
+      # Default variables, called in {Activity::initialize}.
+      def self.config
+        {
+          builder_class:    Magnetic::Builder::Path, # we use the Activity-based Normalizer
+          normalizer_class: Magnetic::Normalizer,
+          plus_poles:       Magnetic::Builder::Path.default_plus_poles,
+          extension:        [ Introspect.method(:add_introspection) ],
+
+          extend:           [ DSL.def_dsl(:task) ],
+        }
+      end
+
+      def self.Plan()
+        Plan
+      end
+
+      module Plan
+        def self.extended(extended)
+          extended.singleton_class.send :attr_accessor, :record
+          extended.record = []
+          extended.extend(Methods)
+        end
+
+        module Methods
+          def task(*args, &block)
+            record << [:task, args, block]
+          end
+        end
+
+        def self.merge!(activity, plan)
+          plan.record.each { |(dsl_method, args, block)| activity.send(dsl_method, *args, &block)  }
+          activity
+        end
+
+        # Creates a copy of the {activity} module and merges the {Plan} into it.
+        #
+        # @params activity [Activity] The activity to extend
+        # @params plan [Plan] The plan providing additional steps
+        # @return [Activity] A new, merged activity
+        def self.merge(activity, plan)
+          merge!(activity.clone, plan)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,18 @@
+module Trailblazer
+  # Implementation module that can be passed to `Activity[]`.
+  class Activity < Module
+    def self.Railway(options={})
+      Railway.new(Railway, options)
+    end
+
+    class Railway < Activity
+      def self.config
+        Path.config.merge(
+          builder_class:  Magnetic::Builder::Railway,
+          plus_poles:     Magnetic::Builder::Railway.default_plus_poles,
+          extend:         [ DSL.def_dsl(:step), DSL.def_dsl(:fail), DSL.def_dsl(:pass) ],
+        )
+      end
+    end
+  end
+end

data/lib/trailblazer/activity/{introspection.rb → introspect.rb}

@@ -1,10 +1,30 @@
 module Trailblazer
-  class Activity
-    # Introspection is not used at run-time except for rendering diagrams, tracing, and the like.
+  class Activity < Module   # Introspection is not used at run-time except for rendering diagrams, tracing, and the like.
     module Introspect
+      # {:argumenter} API
+      def self.arguments_for_call(activity, (options, flow_options), **circuit_options)
+        circuit_options = circuit_options.merge( introspect: activity.debug )
+
+        return activity, [ options, flow_options ], circuit_options
+      end
+
+      # {Extension} API
+      def self.add_introspection(activity, task, local_options, *returned_options)
+        activity[:debug, task] = { id: local_options[:id] || task }
+      end
+
+
+      # @api private
+      def self.find(activity, &block)
+        circuit = activity.decompose[:circuit]
+
+        circuit.instance_variable_get(:@map).find(&block)
+      end
+
 
       def self.collect(activity, options={}, &block)
-        circuit_hash, _ = activity.decompose
+        circuit         = activity.decompose[:circuit]
+        circuit_hash, _ = circuit.decompose
 
         locals = circuit_hash.collect do |task, connections|
           [
@@ -15,9 +35,11 @@ module Trailblazer
       end
 
 
+        # FIXME: clean up that shit below.
+
 # render
-      def self.Cct(process, **options)
-        circuit_hash( process.instance_variable_get(:@circuit).to_fields[0], **options )
+      def self.Cct(circuit, **options)
+        circuit_hash( circuit.decompose[0], **options )
       end
 
       def self.circuit_hash(circuit_hash, show_ids:false)
@@ -33,11 +55,11 @@ module Trailblazer
           content = content.join("\n")
 
           return "\n#{content}" if show_ids
-          return "\n#{content}".gsub(/\d\d+/, "")
+          return "\n#{content}".gsub(/0x\w+/, "0x").gsub(/0.\d+/, "0.")
       end
 
-      def self.Ends(process)
-        end_events = process.instance_variable_get(:@circuit).to_fields[1]
+      def self.Ends(activity)
+        end_events = activity.decompose[1]
         ends = end_events.collect { |evt| Task(evt) }.join(",")
         "[#{ends}]".gsub(/\d\d+/, "")
       end
@@ -74,9 +96,9 @@ module Trailblazer
 
       def self.cct(builder)
         adds = builder.instance_variable_get(:@adds)
-        process, _ = Builder::Finalizer.(adds)
+        circuit, _ = Builder::Finalizer.(adds)
 
-        Cct(process)
+        Cct(circuit)
       end
 
       private
@@ -90,7 +112,7 @@ module Trailblazer
 #{pluses.empty? ? " []" : pluses.join("\n")}}
           end.join("\n")
 
-    "\n#{content}\n".gsub(/\d\d+/, "")
+    "\n#{content}\n".gsub(/\d\d+/, "").gsub(/0x\w+/, "0x")
       end
 
       def self.PlusPole(plus_pole)

data/lib/trailblazer/activity/magnetic.rb

@@ -1,6 +1,5 @@
 module Trailblazer
-  class Activity
-    # all code related to the magnetic building of a circuit hash lives in this namespace.
+  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.
       #
@@ -13,21 +12,6 @@ module Trailblazer
         end
       end # PlusPole
     end
-
-    class Process
-      def self.plan(options={}, &block)
-        Magnetic::Builder::Path.plan(options, &block)
-      end
-
-      def self.build(options={}, &block)
-        Magnetic::Builder::Path.build(options, &block)
-      end
-
-      def self.draft(options={}, &block) # TODO: remove me!
-        Magnetic::Builder::Path.draft(options, &block)
-      end
-    end
-
   end
 end
 
@@ -39,7 +23,12 @@ require "trailblazer/activity/schema/dependencies"
 
 require "trailblazer/activity/magnetic"
 require "trailblazer/activity/magnetic/builder"
-require "trailblazer/activity/magnetic/builder/block"
+# 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.

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

@@ -2,6 +2,19 @@ require "trailblazer/activity/magnetic/finalizer"
 
 module Trailblazer
   module Activity::Magnetic
+
+    # TODO: move?
+    module Options
+      # Produce two hashes, one "local" options with DSL-specific options such as `:fast_track`,
+      # one with generic DSL options, for example tuples like `Right=>Output(:failure)`.
+      def self.normalize(options, local_keys)
+        local, foreign = {}, {}
+        options.each { |k,v| local_keys.include?(k) ? local[k] = v : foreign[k] = v }
+
+        return foreign, local
+      end
+    end
+
     def self.Builder(implementation, normalizer, builder_options={})
       builder = implementation.new(normalizer, builder_options.freeze).freeze # e.g. Path.new(...)
 
@@ -9,115 +22,63 @@ module Trailblazer
     end
 
     class Builder
-
-      def self.plan_for(builder, adds, &block)
-        adds += Block.new(builder).(&block) # returns ADDS
-      end
-
-      def self.build(options={}, &block)
-        adds = plan( options, &block )
-
-        Finalizer.(adds)
-      end
-
       def initialize(normalizer, builder_options)
         @normalizer, @builder_options = normalizer, builder_options
       end
 
-      def self.merge(activity, merged)
-        merged = merged[2..-1] || []
+      def self.merge(activity_adds, merged_adds)
+        merged_adds = merged_adds[2..-1] || []
 
-        activity + merged
+        activity_adds + merged_adds
       end
 
-      module DSLMethods
-        #   Output( Left, :failure )
-        #   Output( :failure ) #=> Output::Semantic
-        def Output(signal, semantic=nil)
-          return DSL::Output::Semantic.new(signal) if semantic.nil?
+      # Stateful helper.
+      def Path(*args)
+        Activity::DSL::Helper.Path(@normalizer, *args)
+      end
 
-          Activity.Output(signal, semantic)
-        end
+      def insert(name, task, options, &block)
+        normalizer = options[:normalizer] || @normalizer # DISCUSS: do this at a deeper point?
 
-        def End(name, semantic)
-          Activity.End(name, semantic)
-        end
+        task, local_options, connection_options, sequence_options = normalizer.(task, options)
 
-        def Path(track_color: "track_#{rand}", end_semantic: :success, **options)
-          options = options.merge(track_color: track_color, end_semantic: end_semantic)
+        implementation, polarizations, task, local_options, block = send(name, task, local_options, &block) # builder.task
 
-          # this block is called in DSL::ProcessTuples.
-          ->(block) { [ track_color, Builder::Path.plan( options, @normalizer, &block ) ] }
-        end
+        insert_element( implementation, polarizations, task, local_options, connection_options, sequence_options, &block )
       end
 
-      include DSLMethods
-
       private
 
       # Internal top-level entry point to add task(s) and connections.
-      def insert_element(impl, polarizations, task, options, &block)
-        normalizer = options[:normalizer] || @normalizer # DISCUSS: do this at a deeper point?
-
-        adds, *returned_options = Builder.adds_for(polarizations, normalizer, task, options, &block)
-      end
-
-      def self.sequence_keywords
-        [ :group, :before, :after, :replace, :delete ] # hard-wires Builder to Sequence/Alterations.
-      end
-
-      # Produce two hashes, one "local" options with DSL-specific options such as `:fast_track`,
-      # one with generic DSL options, for example tuples like `Right=>Output(:failure)`.
-      def self.normalize(options, local_keys)
-        local, foreign = {}, {}
-        options.each { |k,v| local_keys.include?(k) ? local[k] = v : foreign[k] = v }
-
-        return foreign, local
+      def insert_element(impl, 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
 
       # @return Adds
       # High level interface for DSL calls like ::task or ::step.
       # TODO: RETURN ALL OPTIONS
-      def self.adds_for(polarizations, normalizer, task, options, &block)
-        task, local_options, options, sequence_options = normalize_options(normalizer, task, options)
-
-        initial_plus_poles = local_options[:plus_poles]
-        magnetic_to        = local_options[:magnetic_to]
-        adds               = local_options[:adds] || []
-
+      def self.adds_for(polarizations, task, local_options, connection_options, sequence_options, &block)
         # go through all wiring options such as Output()=>:color.
-        polarizations_from_user_options, additional_adds = DSL::ProcessOptions.(local_options[:id], options, initial_plus_poles, &block)
+        polarizations_from_user_options, additional_adds = process_dsl_options(connection_options, local_options, &block)
 
-        result = adds(local_options[:id], task, initial_plus_poles, polarizations, polarizations_from_user_options, local_options, sequence_options, magnetic_to)
+        polarizations = polarizations + polarizations_from_user_options
 
-        return result + adds + additional_adds, task, local_options, options, sequence_options
-      end
+        result = adds(task, polarizations, local_options, sequence_options, local_options)
 
-      # @private
-      def self.normalize_options(normalizer, task, options)
-        keywords = extract_dsl_keywords(options)
-
-         # sort through the "original" user DSL options.
-        options, local_options          = normalize( options, keywords ) # DISCUSS:
-        local_options, sequence_options = normalize( local_options, sequence_keywords )
-
-        task, local_options, options, sequence_options = normalizer.(task, local_options, options, sequence_options)
-
-        return task, local_options, options, sequence_options
+        return result + (local_options[:adds] || []) + additional_adds, task, local_options, connection_options, sequence_options
       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])
-        options.keys - options.keys.find_all { |k| connection_classes.include?( k.class ) }
+      def self.process_dsl_options(options, id:nil, plus_poles:, **, &block)
+        DSL::ProcessOptions.(id, options, plus_poles, &block)
       end
 
       # Low-level interface for DSL calls (e.g. Start, where "you know what you're doing")
       # @private
-      def self.adds(id, task, initial_plus_poles, polarization, polarizations_from_user_options, options, sequence_options, magnetic_to = nil)
+      def self.adds(task, polarizations, options, sequence_options, magnetic_to:nil, id:nil, plus_poles:, **) # DISCUSS: no :id ?
         magnetic_to, plus_poles = apply_polarizations(
-          polarization + polarizations_from_user_options,
+          polarizations,
           magnetic_to,
-          initial_plus_poles,
+          plus_poles,
           options
         )
 
@@ -142,22 +103,6 @@ module Trailblazer
           [ :add, [id, [ magnetic_to, task, plus_poles.to_a ], sequence_options] ],
         ]
       end
-
-      class DefaultNormalizer
-        def initialize( **default_options )
-          raise "you didn't specify default :plus_poles" unless default_options[:plus_poles]
-
-          @default_options = default_options
-        end
-
-        # called for every ::task, ::step call etc to defaultize the `local_options`.
-        def call(task, local_options, options, sequence_options)
-          local_options = @default_options.merge(local_options) # here, we merge default :plus_poles.
-
-          return task, local_options, options, sequence_options
-        end
-      end
-
     end # Builder
   end
 end

data/lib/trailblazer/activity/magnetic/builder/default_normalizer.rb

@@ -0,0 +1,26 @@
+module Trailblazer
+  module Activity::Magnetic
+    # This normalizer only processes basic input and is meant for bootstrapping.
+    #
+    #   task Callable, id: "success", before: "another"
+    class DefaultNormalizer
+      # Declarative::Variables
+      def self.build(plus_poles:, extension:[], **options)
+        return new(plus_poles: plus_poles, extension: extension), options
+      end
+
+      def initialize(**default_options)
+        @default_options = default_options
+      end
+
+      # Processes the user arguments from the DSL
+      def call(task, options)
+        local_options = @default_options.merge(options) # here, we merge default :plus_poles.
+
+        local_options, sequence_options = Options.normalize( local_options, Activity::Schema::Dependencies.sequence_keywords )
+
+        return task, local_options, {}, sequence_options
+      end
+    end
+  end
+end

data/lib/trailblazer/activity/magnetic/builder/fast_track.rb

@@ -12,10 +12,6 @@ module Trailblazer
           )
         end
 
-        def self.plan(options={}, normalizer=DefaultNormalizer.new(plus_poles: default_plus_poles), &block)
-          plan_for( *FastTrack.for(normalizer, options), &block )
-        end
-
         def self.StepPolarizations(**options)
           [
             *Railway.StepPolarizations(options),
@@ -90,26 +86,28 @@ module Trailblazer
 
           ends =
             adds(
-              "End.pass_fast", pass_fast_end,
+              pass_fast_end,
 
-              {}, # plus_poles
               Path::TaskPolarizations(builder_options.merge( type: :End )),
-              [],
 
               {},
               { group: :end },
-              [:pass_fast]
+
+              id:           "End.pass_fast",
+              magnetic_to:  [:pass_fast],
+              plus_poles:   {},
             )+
             adds(
-              "End.fail_fast", fail_fast_end,
+              fail_fast_end,
 
-              {}, # plus_poles
               Path::TaskPolarizations(builder_options.merge( type: :End )),
-              [],
 
               {},
               { group: :end },
-              [:fail_fast]
+
+              magnetic_to:  [:fail_fast],
+              id:           "End.fail_fast",
+              plus_poles:   {},
             )
 
           path_adds + ends
@@ -120,15 +118,15 @@ module Trailblazer
         PassFast = Class.new(Activity::Signal)
 
         def step(task, options={}, &block)
-          insert_element( FastTrack, FastTrack.StepPolarizations(@builder_options), task, options, &block )
+          return FastTrack, FastTrack.StepPolarizations(@builder_options), task, options, block
         end
 
         def fail(task, options={}, &block)
-          insert_element( FastTrack, FastTrack.FailPolarizations(@builder_options), task, options, &block )
+          return FastTrack, FastTrack.FailPolarizations(@builder_options), task, options, block
         end
 
         def pass(task, options={}, &block)
-          insert_element( FastTrack, FastTrack.PassPolarizations(@builder_options), task, options, &block )
+          return FastTrack, FastTrack.PassPolarizations(@builder_options), task, options, block
         end
       end
     end