crack_pipe 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b90ccb391cbc78b10497f1978236cac94de4f715
-  data.tar.gz: 12f9809281e638984c9d59ac340f5cef7e5c6592
+  metadata.gz: ee187d314abb9bfab155824f0d2c92825ef2f0e7
+  data.tar.gz: fc720da093abcfbf35c625488d3904012114b193
 SHA512:
-  metadata.gz: 8e53e038a829b08417c47ab9a961dc76169be2d6ca6393f70ab0bb2e4f1c249a17b2f58851354f1500e55515ab07d0f07060ac14822bb0e440a1c60665dc4168
-  data.tar.gz: 3d4f43c12cc6d2c9af68c2b28395d7fdf4da17bc81afbac25bdd9e07ee34b3051097f54044e330e277d2c03107f3a2e50fd3e5ce48892aed8ce2c18db522aa71
+  metadata.gz: 4704be40ad6adbf04cd9ed32a03915294e36479481aa1b2711171023d12d9ec17176b0286dd109e74c296fef46fc147e67211f1a27e79d55b257811137378052
+  data.tar.gz: fcfef7cacbaafd4ab99ccdc65ee8fe7daeb5b5c6cf0769ddbc3d841faee17a29e9b896217ed7b68feae10fde546c40920c342e57f172465d45066779eed5f8f6

data/lib/crack_pipe/action/exec.rb

@@ -0,0 +1,80 @@
+# frozen-string-literal: true
+
+require 'crack_pipe/action/signal'
+
+module CrackPipe
+  class Action
+    module Exec
+      class << self
+        def call(action, context, track = :default)
+          Result.new(action(action, context, [], track))
+        end
+
+        def action(action, context, results = [], track = :default)
+          action.steps.each_with_object(results) do |s, rslts|
+            next unless track == s.track
+
+            if s.exec.is_a?(Action)
+              self.action(s.exec, context, rslts)
+            else
+              rslts << step(action, s, context)
+            end
+
+            rslts.last.tap do |r|
+              context = r[:context]
+              track = r[:next]
+              return rslts if r[:signal] == :halt
+            end
+          end
+        end
+
+        def flow_control_hash(action, step, context, output)
+          success = success_with_step?(action, step, output)
+
+          {
+            exec: step.exec,
+            track: step.track,
+            next: success ? step.track : :fail,
+            context: context.dup
+          }.merge(flow_control_with_output(output, success))
+        end
+
+        def flow_control_with_output(output, success)
+          case output
+          when Signal
+            {
+              signal: output.type,
+              output: output.value,
+              success: output.success.nil? ? success : output.success
+            }
+          else
+            { output: output, success: success }
+          end
+        end
+
+        def halt(output, success = nil)
+          throw(:signal, Signal.new(:halt, output, success))
+        end
+
+        def step(action, step, context)
+          output = catch(:signal) do
+            case (e = step.exec)
+            when Symbol
+              action.public_send(e, context, **context)
+            when Proc
+              action.instance_exec(context, **context, &e)
+            else
+              e.call(context, **context)
+            end
+          end
+
+          action.after_step(flow_control_hash(action, step, context, output))
+        end
+
+        def success_with_step?(action, step, output)
+          step.always_pass? || step.track != :fail && !action.failure?(output)
+        end
+      end
+    end
+  end
+end

data/lib/crack_pipe/action/result.rb

@@ -3,12 +3,14 @@
 module CrackPipe
   class Action
     class Result
-      attr_reader :context, :output
+      attr_reader :context, :history, :output
 
-      def initialize(context: {}, output: nil, success:, **)
-        @context = context
-        @output = output
-        @success = success
+      def initialize(history)
+        last_result = history.last
+        @context = last_result[:context]
+        @history = history
+        @output = last_result[:output]
+        @success = last_result[:success]
       end
 
       def [](key)

data/lib/crack_pipe/action/{short_circuit.rb → signal.rb}

@@ -2,10 +2,11 @@
 
 module CrackPipe
   class Action
-    class ShortCircuit
-      attr_reader :success, :value
+    class Signal
+      attr_reader :success, :type, :value
 
-      def initialize(value, success = nil)
+      def initialize(type, value, success = nil)
+        @type = type
         @value = value
         @success = success
       end

data/lib/crack_pipe/action/step.rb

@@ -3,19 +3,33 @@
 module CrackPipe
   class Action
     class Step
-      attr_reader :exec, :context_override, :desc, :output_override, :track
+      attr_reader :exec, :track
 
-      def initialize(
-        track,
-        exec,
-        output_override = nil,
-        **context_override
-      )
-        @context_override = context_override.dup
-        @exec = exec
-        @output_override = output_override
+      def initialize(exec = nil, always_pass: false, track: :default, **, &blk)
+        if block_given?
+          raise ArgumentError, '`exec` must be `nil` with a block' unless
+            exec.nil?
+          exec = blk
+        end
+
+        @always_pass = always_pass
+        @exec = instantiate_action(exec)
         @track = track
       end
+
+      def always_pass?
+        @always_pass
+      end
+
+      private
+
+      # NOTE: This allows actions to be passed in as a class rather than as an
+      # instance. It's the difference betweem `step SomeAction` vs
+      # `step SomeAction.new` when nesting actions.
+      def instantiate_action(obj)
+        return obj.new if obj.is_a?(Class) && obj < Action
+        obj
+      end
     end
   end
 end

data/lib/crack_pipe/action.rb

@@ -1,10 +1,15 @@
 # frozen-string-literal: true
 
+require 'crack_pipe/action/exec'
 require 'crack_pipe/action/result'
-require 'crack_pipe/action/short_circuit'
+require 'crack_pipe/action/signal'
 require 'crack_pipe/action/step'
 
 module CrackPipe
+  # NOTE: The reason for using an instantiated class rather than doing all of
+  # this functionally, since there is no real state data, is so that symbols
+  # operate as instance methods and that procs and the like are executed with
+  # `instance_exec`, giving them access to the local scope.
   class Action
     @steps = []
 
@@ -12,9 +17,13 @@ module CrackPipe
       attr_reader :steps
 
       def call(context, &blk)
-        new(context, steps, &blk).result
+        new(&blk).call(context)
       end
 
+      # NOTE: In general, the only time you should use inheritence is when
+      # created a more specilized generic action with some of its own methods
+      # similar such as `pass!` or overiding behavior in `after_step` or
+      # `failure?`.
       def inherited(subclass)
         subclass.instance_variable_set(:@steps, @steps.dup)
         super
@@ -27,30 +36,26 @@ module CrackPipe
       end
 
       def pass(exec = nil, **kwargs, &blk)
-        step(exec, kwargs.merge(output_override: true), &blk)
+        step(exec, kwargs.merge(always_pass: true), &blk)
       end
 
-      def step(
-        exec = nil,
-        output_override: nil,
-        track: :default,
-        **opts,
-        &blk
-      )
-        if block_given?
-          raise ArgumentError, '`exec` must be `nil` with a block' unless
-            exec.nil?
-          exec = blk
-        end
-        @steps += [Step.new(track, exec, output_override, opts)]
+      def step(*args, &blk)
+        @steps += [Step.new(*args, &blk)]
       end
     end
 
-    attr_reader :history, :result
+    attr_reader :steps
 
-    def initialize(context, steps = self.class.steps, &blk)
-      @history = []
-      _result!(context.dup, steps.dup, &blk)
+    def initialize(steps = nil, **default_context, &blk)
+      @__default_context__ = default_context.dup
+      @__wrapper__ = block_given? ? blk : nil
+      @steps = steps ? steps.dup : self.class.steps
+    end
+
+    def call(context)
+      context = @__default_context__.merge(context)
+      return @__wrapper__.call(Exec.(self, context)) if @__wrapper__
+      Exec.(self, context)
     end
 
     # NOTE: While this hook does nothing by default, it is here with the
@@ -58,109 +63,20 @@ module CrackPipe
     # for output or adding values to the context. A common example would be
     # returning some kind of default failure object in place of a literal `nil`
     # or `false`.
-    def after_step(output, _context, _step)
-      output
-    end
-
-    def fail!(value)
-      ShortCircuit.new(value, false)
-    end
-
-    def pass!(value)
-      ShortCircuit.new(value, true)
-    end
-
-    def step_failure?(output)
-      case output
-      when Result
-        output.failure?
-      else
-        !output
-      end
-    end
-
-    def to_a
-      history.dup
+    def after_step(flow_control_hash)
+      flow_control_hash
     end
 
-    private
-
-    def _action?(obj)
-      obj.is_a?(Class) && obj < Action
-    end
-
-    def _exec_nested!(context, action)
-      @history += action.new(context).history
-      @history.last.tap { |h| context.merge!(h[:context]) }
+    def fail!(output)
+      Exec.halt(output, false)
     end
 
-    def _exec_step!(context, step)
-      e = step.exec
-      return _exec_nested!(context, e) if _action?(e)
-
-      output =
-        case e
-        when Symbol
-          public_send(e, context, **context)
-        when Proc
-          instance_exec(context, **context, &e)
-        else
-          e.call(context, **context)
-        end
-
-      _wrap_output(after_step(output, context, step), context.dup, step)
-        .tap { |wo| @history << wo }
-    end
-
-    def _exec_steps!(context, steps)
-      next_track = :default
-      steps.map do |s|
-        next unless next_track == s.track
-        _exec_step!(context, s).tap do |wrapped_output|
-          next_track =
-            wrapped_output[:short_circuit] ? nil : wrapped_output[:next_track]
-        end
-      end.compact.last
-    end
-
-    def _output_hash(output, step)
-      output = step.output_override unless step.output_override.nil?
-      success = step.track != :fail && !step_failure?(output)
-      case output
-      when ShortCircuit
-        {
-          output: output.value,
-          short_circuit: true,
-          success: output.success.nil? ? success : output.success
-        }
-      else
-        {
-          output: output,
-          short_circuit: false,
-          success: success
-        }
-      end
-    end
-
-    # NOTE: The optional block here allows you to wrap the the execution in
-    # external functionality, such as a default `rescue` or something like a
-    # database transaction if it's necessary to span multiple steps.
-    def _result!(context, steps)
-      if block_given?
-        yield(@result = Result.new(_exec_steps!(context, steps)))
-      else
-        @result = Result.new(_exec_steps!(context, steps))
-      end
-      @result
+    def failure?(output)
+      !output
     end
 
-    def _wrap_output(output, context, step)
-      wrapped_output = _output_hash(after_step(output, context, step), step)
-      {
-        exec: step.exec,
-        next_track: wrapped_output[:success] ? :default : :fail,
-        context: context
-      }.merge(wrapped_output)
+    def pass!(output)
+      Exec.halt(output, true)
     end
   end
 end

data/lib/crack_pipe/version.rb

@@ -2,7 +2,7 @@
 
 module CrackPipe
   MAJOR = 0
-  MINOR = 1
+  MINOR = 2
   TINY  = 0
   VERSION = [MAJOR, MINOR, TINY].join('.').freeze
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crack_pipe
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Joshua
@@ -39,6 +39,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -64,8 +78,9 @@ files:
 - README.md
 - lib/crack_pipe.rb
 - lib/crack_pipe/action.rb
+- lib/crack_pipe/action/exec.rb
 - lib/crack_pipe/action/result.rb
-- lib/crack_pipe/action/short_circuit.rb
+- lib/crack_pipe/action/signal.rb
 - lib/crack_pipe/action/step.rb
 - lib/crack_pipe/version.rb
 homepage: https://github.com/binarypaladin/crack_pipe