trailblazer-future 2.1.0.rc1

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

@@ -0,0 +1,23 @@
+module Trailblazer::V2_1
+  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/v2_1/activity/dsl/record.rb

@@ -0,0 +1,11 @@
+module Trailblazer::V2_1
+  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/v2_1/activity/dsl/schema/dependencies.rb

@@ -0,0 +1,46 @@
+module Trailblazer::V2_1
+  module Activity::Schema
+    # Helps organizing the structure of the circuit and allows to define steps that
+    # might be inserted in a completely different order, but it's experimental.
+    #
+    # Translates linear DSL calls that might refer to the same task several times into a linear "drawing instruction"
+    # that can be consumed by Schema.bla.
+    #
+    # This class is experimental.
+    class Dependencies
+      def initialize
+        @groups  = {
+          start:      Sequence.new,
+          main:       Sequence.new, # normal steps
+          end:        Sequence.new, # ends
+          unresolved: Sequence.new, # div
+        }
+
+        @order = [ :start, :main, :end, :unresolved ]
+      end
+
+      def add(id, seq_options, group: :main, **sequence_options)
+        group = @groups[group] or raise "unknown group #{group}, implement me"
+
+        group.add(id, seq_options, **sequence_options) # handles
+      end
+
+      def to_a
+        @order.collect{ |name| @groups[name].to_a }.flatten(1)
+      end
+
+      # @api private
+      def find(id)
+        @groups.find do |name, group|
+          index = group.send( :find_index, id )
+          return group, index if index
+        end
+      end
+
+      # @api private
+      def self.sequence_keywords
+        [ :group, :before, :after, :replace, :delete ]
+      end
+    end
+  end
+end

data/lib/trailblazer/v2_1/activity/dsl/schema/sequence.rb

@@ -0,0 +1,46 @@
+module Trailblazer::V2_1
+  module Activity::Schema
+    #  the list of what tasks to add to the graph, for the "drawer"
+    # produces immutable list of: (node, magnetic_to (incoming colors), outgoing colors)
+    #  via #to_a
+
+    #mutable, for DSL
+    #
+    # @api private
+    class Sequence < ::Array
+      Element = Struct.new(:id, :configuration)
+
+      # Insert the task into {Sequence} array by respecting options such as `:before`.
+      # This mutates the object per design.
+      #
+      # @param wiring [ [:success, :special_1], A, [ Output, Output ] ]
+      def add(id, wiring, before:nil, after:nil, replace:nil, delete:nil)
+        element = Element.new(id, wiring).freeze
+
+        return insert(find_index!(before),  element) if before
+        return insert(find_index!(after)+1, element) if after
+        return self[find_index!(replace)] = element  if replace
+        return delete_at(find_index!(delete))        if delete
+
+        self << element
+      end
+
+      def to_a
+        collect { |element| element.configuration }
+      end
+
+      private
+
+      def find_index(id)
+        element = find { |el| el.id == id }
+        index(element)
+      end
+
+      def find_index!(id)
+        find_index(id) or raise IndexError.new(id)
+      end
+
+      class IndexError < IndexError; end
+    end
+  end
+end

data/lib/trailblazer/v2_1/activity/dsl/strategy/build_state.rb

@@ -0,0 +1,32 @@
+class Trailblazer::V2_1::Activity < Module
+  module BuildState
+    # Compute all objects that need to be passed into the new Activity module.
+    # 1. Build the normalizer (unless passed with :normalizer)
+    # 2. Build the builder (in State)
+    # 3. Let State compute all state variables (that implies recompiling the Process)
+    #
+    # @return [Builder, Adds, Process, Outputs, remaining options]
+    # @api private
+    def self.build_state_for(default_options, options)
+      options                                  = default_options.merge(options) # TODO: use Variables::Merge() here.
+      normalizer, options                      = build_normalizer(options)
+      builder, adds, circuit, outputs, options = build_state(normalizer, options)
+    end
+
+    # Builds the normalizer (to process options in DSL calls) unless {:normalizer} is already set.
+    #
+    # @api private
+    def self.build_normalizer(normalizer_class:, normalizer: false, **options)
+      normalizer, options = normalizer_class.build( options ) unless normalizer
+
+      return normalizer, options
+    end
+
+    # @api private
+    def self.build_state(normalizer, builder_class:, builder_options: {}, **options)
+      builder, adds, circuit, outputs = Magnetic::Builder::State.build(builder_class, normalizer, options.merge(builder_options))
+
+      return builder, adds, circuit, outputs, options
+    end
+  end
+end

data/lib/trailblazer/v2_1/activity/dsl/strategy/fast_track.rb

@@ -0,0 +1,24 @@
+class Trailblazer::V2_1::Activity < Module
+  def self.FastTrack(options={})
+    FastTrack.new(FastTrack, options)
+  end
+
+  # Implementation module that can be passed to `Activity[]`.
+  class FastTrack < Trailblazer::V2_1::Activity
+    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),
+          DSL.def_dsl(:_end, Magnetic::Builder::Path,      :EndEventPolarizations), # TODO: TEST ME
+        ],
+      )
+    end
+
+    # Signals
+    FailFast = Class.new(Signal)
+    PassFast = Class.new(Signal)
+  end
+end

data/lib/trailblazer/v2_1/activity/dsl/strategy/path.rb

@@ -0,0 +1,26 @@
+module Trailblazer::V2_1
+  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,
+          default_outputs:  Magnetic::Builder::Path.default_outputs, # binary outputs
+
+          extend:           [
+            # DSL.def_dsl(:task, Magnetic::Builder::Path,    :PassPolarizations),
+            DSL.def_dsl(:_end, Magnetic::Builder::Path,    :EndEventPolarizations),
+            DSL.def_dsl(:task, Magnetic::Builder::Railway, :PassPolarizations),
+          ],
+        }
+      end
+    end # Path
+  end
+end
+

data/lib/trailblazer/v2_1/activity/dsl/strategy/plan.rb

@@ -0,0 +1,36 @@
+module Trailblazer::V2_1
+  class Activity::Path < Activity
+    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
+

data/lib/trailblazer/v2_1/activity/dsl/strategy/railway.rb

@@ -0,0 +1,23 @@
+module Trailblazer::V2_1
+  # 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,
+          default_outputs: Magnetic::Builder::Path.default_outputs,
+          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),
+            DSL.def_dsl(:_end, Magnetic::Builder::Path,    :EndEventPolarizations), # TODO: TEST ME
+          ],
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+class Trailblazer::V2_1::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 to_h # TODO: test me
+      @state.to_h
+    end
+
+    def debug # TODO: TEST ME
+      to_h[:debug]
+    end
+
+    def outputs
+      to_h[:outputs]
+    end
+  end
+end

data/lib/trailblazer/v2_1/activity/introspect.rb

@@ -0,0 +1,167 @@
+module Trailblazer::V2_1
+  class Activity < Module
+    # Compile-time.
+    # Introspection is not used at run-time except for rendering diagrams, tracing, and the like.
+    module Introspect
+      def self.Graph(*args)
+        Graph.new(*args)
+      end
+
+      # @private This API is still under construction.
+      class Graph
+        def initialize(activity)
+          @activity = activity
+          @circuit  = activity.to_h[:circuit]
+          @adds     = activity.to_h[:adds].compact # FIXME: why are there nils in Adds?
+        end
+
+        def find(id=nil, &block)
+          return find_by_id(id) unless block_given?
+          find_with_block(&block)
+        end
+
+        private
+
+        def find_by_id(id)
+          (_, (id, triplett)) = @adds.find { |(op, (_id, triplett))| _id == id }
+
+          Node(triplett[1], id, triplett[0])
+        end
+
+        def find_with_block(&block)
+          adds = @adds.find { |(op, (id, triplett))| yield( Node(triplett[1], id, triplett[0]) ) }
+          return nil unless adds
+
+          (op, (id, triplett)) = adds
+
+          Node(triplett[1], id, triplett[0])
+        end
+
+        def Node(*args)
+          Node.new(*args).freeze
+        end
+
+        Node = Struct.new(:task, :id, :magnetic_to)
+      end
+
+
+      # FIXME: remove this
+      # @private This will be removed shortly.
+      def self.collect(activity, options={}, &block)
+        circuit      = activity.to_h[:circuit]
+        circuit_hash = circuit.to_h[:map]
+
+        locals = circuit_hash.collect do |task, connections|
+          [
+            yield(task, connections),
+            *options[:recursive] && task.is_a?(Activity::Interface) ? collect(task, options, &block) : []
+          ]
+        end.flatten(1)
+      end
+
+
+      def self.inspect_task_builder(task)
+        proc = task.instance_variable_get(:@user_proc)
+        match = proc.inspect.match(/(\w+)>$/)
+
+        %{#<TaskBuilder{.#{match[1]}}>}
+      end
+
+        # FIXME: clean up that shit below.
+
+# render
+      def self.Cct(circuit, **options)
+        circuit_hash( circuit.to_h[:map], **options )
+      end
+
+      def self.circuit_hash(circuit_hash, show_ids:false, **options)
+        content =
+          circuit_hash.collect do |task, connections|
+            conns = connections.collect do |signal, target|
+              " {#{signal}} => #{inspect_with_matcher(target, **options)}"
+            end
+
+            [ inspect_with_matcher(task, **options), conns.join("\n") ]
+          end
+
+          content = content.join("\n")
+
+          return "\n#{content}" if show_ids
+          return "\n#{content}".gsub(/0x\w+/, "0x").gsub(/0.\d+/, "0.")
+      end
+
+      def self.Ends(activity)
+        end_events = activity.to_h[:end_events]
+        ends = end_events.collect { |evt| inspect_end(evt) }.join(",")
+        "[#{ends}]".gsub(/\d\d+/, "")
+      end
+
+
+      def self.Outputs(outputs)
+        outputs.collect { |semantic, output| "#{semantic}=> (#{output.signal}, #{output.semantic})" }.
+          join("\n").gsub(/0x\w+/, "").gsub(/\d\d+/, "")
+      end
+
+      # If Ruby had pattern matching, this function wasn't necessary.
+      def self.inspect_with_matcher(task, inspect_task: method(:inspect_task), inspect_end: method(:inspect_end))
+        return inspect_task.(task) unless task.kind_of?(Trailblazer::V2_1::Activity::End)
+        inspect_end.(task)
+      end
+
+      def self.inspect_task(task)
+        task.inspect
+      end
+
+      def self.inspect_end(task)
+        class_name = strip(task.class)
+        options    = task.to_h
+
+        "#<#{class_name}/#{options[:semantic].inspect}>"
+      end
+
+      def self.strip(string)
+        string.to_s.sub("Trailblazer::V2_1::Activity::", "")
+      end
+    end #Introspect
+  end
+
+  module Activity::Magnetic
+    module Introspect
+      def self.seq(activity)
+        adds = activity.instance_variable_get(:@adds)
+        tripletts = Builder::Finalizer.adds_to_tripletts(adds)
+
+        Seq(tripletts)
+      end
+
+      def self.cct(builder)
+        adds = builder.instance_variable_get(:@adds)
+        circuit, _ = Builder::Finalizer.(adds)
+
+        Cct(circuit)
+      end
+
+      private
+
+      def self.Seq(sequence)
+        content =
+          sequence.collect do |(magnetic_to, task, plus_poles)|
+            pluses = plus_poles.collect { |plus_pole| PlusPole(plus_pole) }
+
+%{#{magnetic_to.inspect} ==> #{Activity::Introspect.inspect_with_matcher(task)}
+#{pluses.empty? ? " []" : pluses.join("\n")}}
+          end.join("\n")
+
+    "\n#{content}\n".gsub(/\d\d+/, "").gsub(/0x\w+/, "0x")
+      end
+
+      def self.PlusPole(plus_pole)
+        signal = plus_pole.signal.to_s.sub("Trailblazer::V2_1::Activity::", "")
+        semantic = plus_pole.send(:output).semantic
+        " (#{semantic})/#{signal} ==> #{plus_pole.color.inspect}"
+      end
+
+
+    end
+  end
+end