trailblazer-activity 0.7.1 → 0.8.0

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

@@ -1,23 +0,0 @@
-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,
-          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/activity/interface.rb

@@ -1,16 +0,0 @@
-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 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/activity/task_wrap/merge.rb

@@ -1,23 +0,0 @@
-module Trailblazer
-  module Activity::TaskWrap
-    # This is instantiated via the DSL, and passed to the :extension API,
-    # allowing to add steps to the Activity's static_wrap.
-    # Compile-time function
-    class Merge
-      def initialize(extension_plan)
-        @extension_plan = extension_plan
-      end
-
-      # {:extension API}
-      def call(activity, task, local_options, *returned_options)
-        # we could make the default initial_activity injectable via the DSL, the value would sit in returned_options or local_options.
-        static_wrap = Activity::TaskWrap.wrap_static_for(task, activity: activity)
-
-        # # macro might want to apply changes to the static task_wrap (e.g. Inject)
-        new_wrap =  Activity::Path::Plan.merge( static_wrap, @extension_plan )
-
-        activity[:wrap_static, task] = new_wrap
-      end
-    end
-  end
-end

data/lib/trailblazer/activity/task_wrap/trace.rb

@@ -1,44 +0,0 @@
-class Trailblazer::Activity < Module
-  module TaskWrap
-    # TaskWrap tasks for tracing.
-    module Trace
-      module_function
-
-      # taskWrap step to capture incoming arguments of a step.
-      # def self.capture_args(direction, options, flow_options, wrap_config, original_flow_options)
-      def capture_args((wrap_config, original_args), **circuit_options)
-
-        original_args = capture_for(wrap_config[:task], *original_args)
-
-        return Trailblazer::Activity::Right, [wrap_config, original_args], circuit_options
-      end
-
-      # taskWrap step to capture outgoing arguments from a step.
-      def capture_return((wrap_config, original_args), **circuit_options)
-        (original_options, original_flow_options, _) = original_args[0]
-
-        original_flow_options[:stack] << Trailblazer::Activity::Trace::Entity::Output.new(
-          wrap_config[:task], {}, wrap_config[:return_signal]
-        ).freeze
-
-        original_flow_options[:stack].unindent!
-
-
-        return Trailblazer::Activity::Right, [wrap_config, original_args], circuit_options
-      end
-
-      # It's important to understand that {flow[:stack]} is mutated by design. This is needed so
-      # in case of exceptions we still have a "global" trace - unfortunately Ruby doesn't allow
-      # us a better way.
-      def capture_for(task, (ctx, flow), activity:, **circuit_options)
-        flow[:stack].indent!
-
-        flow[:stack] << Trailblazer::Activity::Trace::Entity::Input.new(
-          task, activity
-        ).freeze
-
-        return [ctx, flow], circuit_options.merge(activity: activity)
-      end
-    end
-  end
-end

data/lib/trailblazer/circuit.rb

@@ -1,71 +0,0 @@
-module Trailblazer
-  # Running a Circuit instance will run all tasks sequentially depending on the former's result.
-  # Each task is called and retrieves the former task's return values.
-  #
-  # Note: Please use #Activity as a public circuit builder.
-  #
-  # @param map         [Hash] Defines the wiring.
-  # @param stop_events [Array] Tasks that stop execution of the circuit.
-  #
-  #   result = circuit.(start_at, *args)
-  #
-  # @see Activity
-  # @api semi-private
-  #
-  # This is the "pipeline operator"'s implementation.
-  class Circuit
-    def initialize(map, stop_events, start_task:, name: nil)
-      @map         = map
-      @stop_events = stop_events
-      @name        = name
-      @start_task  = start_task
-    end
-
-    # @param args [Array] all arguments to be passed to the task's `call`
-    # @param task [callable] task to call
-    Run = ->(task, args, **circuit_options) { task.(args, **circuit_options) }
-
-    # Runs the circuit until we hit a stop event.
-    #
-    # This method throws exceptions when the returned value of a task doesn't match
-    # any wiring.
-    #
-    # @param task An event or task of this circuit from where to start
-    # @param options anything you want to pass to the first task
-    # @param flow_options Library-specific flow control data
-    # @return [last_signal, options, flow_options, *args]
-    #
-    # NOTE: returned circuit_options are discarded when calling the runner.
-    def call(args, start_task: @start_task, runner: Run, **circuit_options)
-      circuit_options = circuit_options.merge( runner: runner ).freeze # TODO: set the :runner option via arguments_for_call to save the merge?
-      task            = start_task
-
-      loop do
-        last_signal, args, _discarded_circuit_options = runner.(
-          task,
-          args,
-          circuit_options
-        )
-
-        # Stop execution of the circuit when we hit a stop event (< End). This could be an task's End or Suspend.
-        return [ last_signal, args ] if @stop_events.include?(task) # DISCUSS: return circuit_options here?
-
-        task = next_for(task, last_signal) or raise IllegalSignalError.new("<#{@name}>[#{task}][ #{last_signal.inspect} ]")
-      end
-    end
-
-    # Returns the circuit's components.
-    def to_h
-      { map: @map, end_events: @stop_events, start_task: @start_task }
-    end
-
-  private
-    def next_for(last_task, signal)
-      outputs = @map[last_task]
-      outputs[signal]
-    end
-
-    class IllegalSignalError < RuntimeError
-    end
-  end
-end