trailblazer-activity 0.7.1 → 0.8.0

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

@@ -1,16 +0,0 @@
-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/dsl/magnetic/process_options.rb

@@ -1,76 +0,0 @@
-module Trailblazer
-  module Activity::Magnetic
-    module DSL
-      # This module only processes additional "wiring" options from the DSL calls
-      #   Output(:success) => End("my.new")
-      #
-      # Returns PlusPoles and additional sequence alterations.
-      module ProcessOptions
-        module_function
-
-        # Output => target (End/"id"/:color)
-        # @return [PlusPole]
-        # @return additional alterations
-        #
-        # options:
-        #   { DSL::Output[::Semantic] => target }
-        #
-        def call(id, options, plus_poles, &block)
-          polarization, adds =
-            options.
-              collect { |key, task|
-                # this method call is the only thing that really matters here. # TODO: make this transformation a bit more obvious.
-                process_tuple(id, key, task, plus_poles, &block)
-              }.
-              inject([[],[]]) { |memo, (polarization, adds)| memo[0]<<polarization; memo[1]<<adds; memo }
-
-          return polarization, adds.flatten(1)
-        end
-
-        def process_tuple(id, output, task, plus_poles, &block)
-          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]] ]
-            ]
-          # procs come from DSL calls such as `Path() do ... end`.
-          elsif task.is_a?(Proc)
-            start_color, activity = task.(block)
-
-            adds = activity.to_h[:adds]
-
-            [
-              Polarization.new( output: output, color: start_color ),
-              # TODO: this is a pseudo-"merge" and should be public API at some point.
-            # TODO: we also need to merge all the other states such as debug.
-              adds[1..-1] # drop start
-            ]
-          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}" # edge from <id> to <target>
-
-            [
-              Polarization.new( output: output, color: new_edge ),
-              [[ :magnetic_to, [ task, [new_edge] ] ]], # mark target (`task`) as magnetic to the new edge.
-            ]
-          end
-        end
-
-        # @param semantic DSL::Output::Semantic
-        def output_for(semantic, plus_poles)
-          # DISCUSS: review PlusPoles#[]
-          output, _ = plus_poles.instance_variable_get(:@plus_poles)[semantic.value]
-          output or raise("Couldn't find existing output for `#{semantic.value.inspect}`.")
-        end
-      end # OptionsProcessing
-    end # DSL
-  end
-end

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

@@ -1,44 +0,0 @@
-module Trailblazer
-  module Activity::Magnetic
-    module DSL
-      # works on a generic Dependencies structure that has no knowledge of magnetism.
-      class Alterations
-        def initialize
-          @groups = Activity::Schema::Dependencies.new
-          @future_magnetic_to = {} # DISCUSS: future - should it be here?
-        end
-
-        def add(id, options, **sequence_options)
-          @groups.add(id, options, **sequence_options)
-
-          # DISCUSS: future - should it be here?
-          if magnetic_to = @future_magnetic_to.delete(id)
-            magnetic_to( id, magnetic_to )
-          end
-
-          self
-        end
-
-        # make `id` magnetic_to
-        def magnetic_to(id, magnetic_to)
-          group, index = @groups.find(id) # this can be a future task!
-
-          unless group # DISCUSS: future - should it be here?
-            @future_magnetic_to[id] = magnetic_to
-            return
-          end
-
-          arr = group[index].configuration.dup
-
-          arr[0] = arr[0] + magnetic_to
-          group.add(id, arr, replace: id)
-        end
-
-        # Returns array of tripletts.
-        def to_a
-          @groups.to_a
-        end
-      end
-    end # DSL
-  end
-end

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

@@ -1,85 +0,0 @@
-module Trailblazer
-  module Activity::Magnetic
-    # A plus pole is associating an Output{:signal, :semantic} to a magnetic :color.
-    #
-    # When it comes to connecting tasks to each other, PlusPoles is the most important object
-    # here. When a task is added via the DSL, a PlusPoles is set up, and the DSL adds polarizations
-    # from the implementation and from the options (e.g. `Outputs(..) => ..`).
-    #
-    # These are then finalized and return the effective plus poles
-
-    # Polarization is one or multiple calls to PlusPoles
-
-
-
-
-
-    # Output(:signal, :semantic) => :color
-    # add / merge
-    #   change existing, => color
-    #
-    #
-    # Produces [ PlusPole, PlusPole, ] via `to_a`.
-    #
-    # @privat
-    # @note This is private until we know what we want.
-    class PlusPoles
-      def initialize(plus_poles={})
-        @plus_poles = plus_poles.freeze
-      end
-
-      #   merge( Activity::Magnetic.Output(Right, :success) => :success
-      def merge(output_to_color)
-        overrides = ::Hash[ output_to_color.collect { |output, color| [ output.semantic, [output, color] ] } ]
-        PlusPoles.new(@plus_poles.merge(overrides))
-      end
-
-      def reverse_merge(output_to_color)
-        existing_colors = @plus_poles.values.collect { |pole_cfg| pole_cfg.last }
-
-        # filter all outputs with a color that already exists.
-        overrides = output_to_color.find_all { |output, color| !existing_colors.include?(color) }
-        merge(overrides)
-      end
-
-      def reconnect(semantic_to_color)
-        ary = semantic_to_color.collect do |semantic, color|
-          existing_output, _ = @plus_poles[semantic]
-
-          next unless existing_output
-
-          [ Activity.Output(existing_output.signal, existing_output.semantic), color ]
-        end
-
-        merge( ::Hash[ary.compact] )
-      end
-
-      # Compile one {PlusPoles} instance from all a sequence of {Polarization}s.
-      # This is usually called once per `step` DSL call.
-      #
-      # @api private
-      def self.apply_polarizations(polarizations, magnetic_to, plus_poles, options)
-        magnetic_to, plus_poles = polarizations.inject([magnetic_to, plus_poles]) do |args, pol|
-          magnetic_to, plus_poles = pol.(*args, options)
-        end
-
-        return magnetic_to, plus_poles.to_a
-      end
-
-      # The DSL is a series of transformations that yield in tasks with several PlusPole instances each.
-      #
-      # @api private
-      def to_a
-        @plus_poles.values.collect { |output, color| PlusPole.new(output, color) }
-      end
-
-      # FIXME: should this be a hash or whatever?
-      #
-      # @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

@@ -1,23 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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/dsl/schema/dependencies.rb

@@ -1,46 +0,0 @@
-module Trailblazer
-  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/activity/dsl/schema/sequence.rb

@@ -1,46 +0,0 @@
-module Trailblazer
-  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/activity/dsl/strategy/build_state.rb

@@ -1,32 +0,0 @@
-class Trailblazer::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/activity/dsl/strategy/fast_track.rb

@@ -1,24 +0,0 @@
-class Trailblazer::Activity < Module
-  def self.FastTrack(options={})
-    FastTrack.new(FastTrack, options)
-  end
-
-  # Implementation module that can be passed to `Activity[]`.
-  class FastTrack < Trailblazer::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/activity/dsl/strategy/path.rb

@@ -1,26 +0,0 @@
-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,
-          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/activity/dsl/strategy/plan.rb

@@ -1,36 +0,0 @@
-module Trailblazer
-  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
-