trailblazer-activity 0.7.1 → 0.8.0

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

@@ -1,113 +0,0 @@
-module Trailblazer
-  module Activity::Magnetic
-    # One {Normalizer} instance is called for every DSL call (step/pass/fail etc.) and normalizes/defaults
-    # the user options, such as setting `:id`, connecting the task's outputs or wrapping the user's
-    # task via {TaskBuilder::Binary} in order to translate true/false to `Right` or `Left`.
-    #
-    # The Normalizer sits in the `@builder`, which receives all DSL calls from the Operation subclass.
-    class Normalizer
-      def self.build(task_builder: Activity::TaskBuilder.method(:Binary), default_outputs: Builder::Path.default_outputs, pipeline: Pipeline, extension:[], **options)
-        return new(
-          default_outputs: default_outputs,
-          extension:       extension,
-          task_builder:    task_builder,
-          pipeline:        pipeline,
-        ), options
-      end
-
-      def initialize(task_builder:, default_outputs:, pipeline:, **options)
-        @task_builder    = task_builder
-        @default_outputs = default_outputs
-        @pipeline        = pipeline # TODO: test me.
-        freeze
-      end
-
-      def call(task, options)
-        ctx = {
-          task:            task,
-          options:         options,
-          task_builder:    @task_builder,
-          default_outputs: @default_outputs,
-        }
-
-        signal, (ctx, ) = @pipeline.( [ctx], {} )
-
-        return ctx[:options][:task], ctx[:local_options], ctx[:connection_options], ctx[:sequence_options], ctx[:extension_options]
-      end
-
-      # needs the basic Normalizer
-
-      # :default_plus_poles is an injectable option.
-      module Pipeline
-        extend Trailblazer::Activity::Path( normalizer_class: DefaultNormalizer, plus_poles: PlusPoles.new.merge( Builder::Path.default_outputs.values ) ) # FIXME: the DefaultNormalizer actually doesn't need Left.
-
-        def self.split_options( ctx, task:, options:, ** )
-          keywords   = extract_dsl_keywords(options)
-          extensions = extract_extensions(options)
-
-           # sort through the "original" user DSL options.
-          options, extension_options      = Options.normalize( options, extensions ) # DISCUSS:
-          options, local_options          = Options.normalize( options, keywords ) # DISCUSS:
-          local_options, sequence_options = Options.normalize( local_options, Activity::Schema::Dependencies.sequence_keywords )
-
-          ctx[:local_options],
-          ctx[:connection_options],
-          ctx[:sequence_options],
-          ctx[:extension_options] = local_options, options, sequence_options, extension_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, Activity::DSL::OutputSemantic])
-          options.keys - options.keys.find_all { |k| connection_classes.include?( k.class ) }
-        end
-
-        def self.extract_extensions(options, extensions_classes = [Activity::DSL::Extension])
-          options.keys.find_all { |k| extensions_classes.include?( k.class ) }
-        end
-
-        # FIXME; why don't we use the extensions passed into the initializer?
-        def self.initialize_extension_option( ctx, options:, ** )
-          ctx[:options] = options.merge( Activity::DSL::Extension.new( Activity::DSL.method(:record) ) => true )
-        end
-
-        # Normalizes ctx[:options] (the user-options via the DSL) into the internal Hash format.
-        def self.normalize_for_macro( ctx, task:, options:, task_builder:, ** )
-          ctx[:options] =
-            if task.is_a?(::Hash) # macro.
-              task.merge(options) # Note that the user options are merged over the macro options.
-            else # user step
-              { id: task }
-                .merge(options)                     # default :id
-                .merge( task: task_builder.(task) )
-            end
-        end
-
-        # :outputs passed: I know what I want to have connected.
-        # no :outputs: use default_outputs
-        # ALWAYS connect all outputs to their semantic-color.
-
-        # Create the `plus_poles: <PlusPoles>` tuple where the PlusPoles instance will act as the interface
-        # to rewire or add connections for the DSL.
-        def self.initialize_plus_poles( ctx, local_options:, default_outputs:, ** )
-          outputs = local_options[:outputs] || default_outputs
-
-          ctx[:local_options] =
-            {
-              plus_poles: PlusPoles.initial(outputs),
-            }
-            .merge(local_options)
-        end
-
-        task Activity::TaskBuilder::Binary( method(:initialize_extension_option) ), id: "initialize_extension_option"
-        task Activity::TaskBuilder::Binary( method(:normalize_for_macro) ),        id: "normalize_for_macro"
-
-        task Activity::TaskBuilder::Binary( Activity::TaskWrap::VariableMapping.method(:normalizer_step_for_input_output) )
-
-        task Activity::TaskBuilder::Binary( method(:split_options) ),              id: "split_options"
-        task Activity::TaskBuilder::Binary( method(:initialize_plus_poles) ),      id: "initialize_plus_poles"
-        # task ->((ctx, _), **) { pp ctx; [Activity::Right, [ctx, _]] }
-      end
-    end # Normalizer
-
-  end
-end

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

@@ -1,105 +0,0 @@
-module Trailblazer
-  module Activity::Magnetic
-    class Builder
-
-      class Path < Builder
-          # strategy_options:
-          #   :track_color
-          #   :end_semantic
-        def self.for(normalizer, builder_options={}) # Build the Builder.
-          Activity::Magnetic::Builder(
-            Path,
-            normalizer,
-            { track_color: :success, end_semantic: :success }.merge( builder_options )
-          )
-        end
-
-        # In most cases, a task has a binary signal, which is why we decided to make that
-        # the default output set.
-        def self.default_outputs
-          {
-            :success => Activity.Output(Activity::Right, :success),
-            :failure => Activity.Output(Activity::Left,  :failure)
-          }
-        end
-
-        # @return [Adds] list of Adds instances that can be chained or added to an existing sequence.
-        def self.InitialAdds(**options)
-          StartAdds(**options) + EndAdds(**options)
-        end
-
-        # TODO: make this nicer.
-        def self.StartAdds(track_color:, end_semantic:, start_outputs: {success: self.default_outputs[:success]}, **)
-          builder_options={ track_color: track_color, end_semantic: end_semantic }
-
-          adds(
-            Activity::Start.new(semantic: :default),
-
-            TaskPolarizations(builder_options),
-
-            {}, { group: :start },
-
-            id:           "Start.default",
-            magnetic_to:  [],
-            plus_poles:   PlusPoles.initial(start_outputs), # FIXME: this is actually redundant with Normalizer
-          )
-        end
-
-        # TODO: make this nicer.
-        def self.EndAdds(track_color:, end_semantic:, track_end: Activity.End(end_semantic), end_id: nil, **)
-          # an end can either be a reference to another task,
-          # or a "real" end event.
-          if end_id
-            [[:magnetic_to,
-              [ end_id, [track_color] ] ]
-            ]
-          else
-            builder_options={ track_color: track_color, end_semantic: end_semantic }
-
-            adds(
-              track_end,
-
-              EndEventPolarizations(builder_options), # only sets :magnetic_to.
-
-              {}, { group: :end },
-
-              id:         "End.#{track_color}",
-              plus_poles: {},
-              magnetic_to: nil,
-            )
-          end
-        end
-
-        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
-          end
-
-          def call(magnetic_to, plus_poles, options)
-            [
-              magnetic_to || [@track_color],
-              plus_poles.reconnect( :success => @track_color )
-            ]
-          end
-        end # TaskPolarization
-
-        class EndEventPolarization < TaskPolarization
-          def call(magnetic_to, plus_poles, options)
-            [
-              magnetic_to || [@track_color],
-              {}
-            ]
-          end
-        end # EndEventPolarization
-      end # Path
-    end # Builder
-  end
-end

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

@@ -1,97 +0,0 @@
-module Trailblazer
-  module Activity::Magnetic
-    class Builder
-      class Railway < Builder
-        def self.for(normalizer, builder_options={}) # Build the Builder.
-          Activity::Magnetic::Builder(
-            Railway,
-            normalizer,
-            { track_color: :success, end_semantic: :success, failure_color: :failure }.merge( builder_options )
-          )
-        end
-
-        # Adds the End.failure end to the Path sequence.
-        # @return [Adds] list of Adds instances that can be chained or added to an existing sequence.
-        def self.InitialAdds(failure_color:raise, failure_end: Activity.End(failure_color), **builder_options)
-          path_adds = Path.InitialAdds(**builder_options)
-
-          end_adds = adds(
-            failure_end,
-
-            Path::EndEventPolarizations(builder_options),
-
-            {},
-            { group: :end },
-
-            magnetic_to:  [failure_color],
-            id:           "End.#{failure_color}",
-            plus_poles:   {},
-          )
-
-          path_adds + end_adds
-        end
-
-        # ONLY JOB: magnetic_to and Outputs ("Polarization") via PlusPoles.merge
-        def self.StepPolarizations(**options)
-          [
-            *Path.TaskPolarizations(options),
-            StepPolarization.new(options)
-          ]
-        end
-
-        def self.PassPolarizations(options)
-          [
-            Railway::PassPolarization.new( options )
-          ]
-        end
-
-        def self.FailPolarizations(options)
-          [
-            Railway::FailPolarization.new( options )
-          ]
-        end
-
-        class StepPolarization
-          def initialize(track_color: :success, failure_color: :failure, **o)
-            @track_color, @failure_color = track_color, failure_color
-          end
-
-          # Returns the polarization for a DSL call. Takes care of user options such as :magnetic_to.
-          def call(magnetic_to, plus_poles, options)
-            [
-              magnetic_to || default_magnetic_to,
-              plus_poles_for(plus_poles, options),
-            ]
-          end
-
-          private
-
-          def plus_poles_for(plus_poles, options)
-            plus_poles.reconnect( :failure => @failure_color )
-          end
-
-          def default_magnetic_to
-            [@track_color]
-          end
-        end
-
-        class PassPolarization < StepPolarization
-          def plus_poles_for(plus_poles, options)
-            plus_poles.reconnect( :failure => @track_color, :success => @track_color )
-          end
-        end
-
-        class FailPolarization < StepPolarization
-          def default_magnetic_to
-            [@failure_color]
-          end
-
-          def plus_poles_for(plus_poles, options)
-            plus_poles.reconnect( :failure => @failure_color, :success => @failure_color )
-          end
-        end
-
-      end # Railway
-    end # Builder
-  end
-end

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

@@ -1,58 +0,0 @@
-module Trailblazer
-  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.
-
-        recompile(builder.freeze, adds.freeze)
-      end
-
-      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
-
-        recompile(builder, adds.freeze, returned_options)
-      end
-
-      private
-
-      # @return {builder, Adds, Process, outputs}, returned_options
-      def self.recompile(builder, adds, *args)
-        circuit, outputs = recompile_circuit(adds)
-
-        return builder, adds, circuit.freeze, outputs.freeze, *args
-      end
-
-      def self.recompile_circuit(adds)
-        circuit, outputs = Recompile.( adds )
-      end
-
-      module Recompile
-        # Recompile the circuit and outputs from the {ADDS} instance that collects circuit tasks and connections.
-        #
-        # @return [Process, Hash] The {Process} instance and its outputs hash.
-        def self.call(adds)
-          circuit, end_events = Finalizer.(adds)
-          outputs             = recompile_outputs(end_events)
-
-          return circuit, outputs
-        end
-
-        private
-
-        def self.recompile_outputs(end_events)
-          ary = end_events.collect do |evt|
-            [
-              semantic = evt.to_h[:semantic],
-              Activity::Output(evt, semantic)
-            ]
-          end
-
-          ::Hash[ ary ]
-        end
-      end # Recompile
-    end # State
-  end
-end

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

@@ -1,51 +0,0 @@
-module Trailblazer
-  module Activity::Magnetic
-    class Builder
-      module Finalizer
-
-        def self.call(adds)
-          tripletts = adds_to_tripletts(adds)
-
-          circuit_hash = tripletts_to_circuit_hash( tripletts )
-
-          circuit_hash_to_process( circuit_hash )
-        end
-
-        def self.adds_to_tripletts(adds)
-          alterations = adds_to_alterations(adds)
-
-          alterations.to_a
-        end
-
-        def self.adds_to_alterations(adds)
-          alterations = DSL::Alterations.new
-
-          adds = adds.compact # TODO: test me explicitly, and where does this come from anyway?
-
-          adds.each { |method, cfg| alterations.send( method, *cfg ) }
-
-          alterations
-        end
-
-        def self.tripletts_to_circuit_hash(tripletts)
-          Activity::Magnetic::Generate.( tripletts )
-        end
-
-        def self.circuit_hash_to_process(circuit_hash)
-          end_events = end_events_for(circuit_hash)
-
-          return Circuit.new(circuit_hash, end_events, start_task: circuit_hash.keys.first), end_events
-        end
-
-        # Find all end events that don't have outgoing connections.
-        def self.end_events_for(circuit_hash)
-          ary = circuit_hash.collect do |task, connections|
-            task.kind_of?(Activity::End) && connections.empty? ? task : nil
-          end
-
-          ary.compact
-        end
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-module Trailblazer
-  module Activity::Magnetic
-    # Transforms an array of {Triplett}s into a circuit hash.
-    module Generate
-      Line      = Struct.new(:source, :output)
-      MinusPole = Struct.new(:color)
-
-      class OpenLines
-        def initialize
-          @arr = []
-        end
-
-        def pop(signal, &block)
-          lines = @arr.find_all { |line| line.output.color == signal }
-          @arr -= lines
-
-          lines.each(&block)
-          lines.any?
-        end
-
-        def <<((node, output))
-          @arr << Line.new(node, output)
-        end
-      end
-
-      def self.call(tasks)
-        open_plus_poles  = OpenLines.new
-        open_minus_poles = OpenLines.new
-        circuit_hash     = {}
-
-        tasks.each do |(magnetic_to, node, outputs)|
-          circuit_hash[ node ] ||= {} # DISCUSS: or needed?
-
-          magnetic_to.each do |edge_color| # minus poles
-            open_plus_poles.pop(edge_color) do |line|
-              connect( circuit_hash, line.source, line.output.signal, node )
-            end and next
-
-            # only run when there were no open_minus_poles
-            open_minus_poles << [node, MinusPole.new(edge_color)] # open inputs on a node, waiting to be connected.
-          end
-
-          outputs.each do |output|
-            open_minus_poles.pop(output.color) do |line|
-              connect( circuit_hash, node, output.signal, line.source )
-            end and next
-
-            # only run when there were no open_plus_poles
-            open_plus_poles << [node, output]
-          end
-        end
-
-        circuit_hash
-      end
-
-      #                               plus            minus
-      def self.connect(circuit_hash, source, signal, target)
-        circuit_hash[ source ][ signal ] = target
-      end
-    end # Magnetic
-  end
-end