rails-workflow 1.4.5.4 → 1.4.6.4

data/lib/workflow/callbacks/callback.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Workflow
   module Callbacks
     #
@@ -10,26 +11,35 @@ module Workflow
       include Comparable
 
       attr_reader :expression, :callback
-      def initialize(expression, inverted=false)
+      def initialize(expression, inverted = false)
         @expression = expression
-        @callback     = make_lambda(expression)
-        if inverted
-          @callback = invert_lambda(@callback)
-        end
+        @callback = make_lambda(expression)
+        @callback = invert_lambda(@callback) if inverted
       end
 
       def call(target)
-        callback.call(target, ->{})
+        callback.call(target, -> {})
       end
 
-      def self.build_inverse(expression)
-        new expression, true
+      def self.inverted(expression)
+        build(expression, true)
+      end
+
+      def self.build(expression, inverted = false)
+        case expression
+        when Symbol
+          MethodCallback.new(expression, inverted)
+        when String
+          StringCallback.new(expression, inverted)
+        when Proc
+          ProcCallback.new(expression, inverted)
+        end
       end
 
       private
 
       def invert_lambda(l)
-        lambda { |*args, &blk| !l.call(*args, &blk) }
+        ->(*args, &blk) { !l.call(*args, &blk) }
       end
 
       # Filters support:
@@ -42,34 +52,6 @@ module Workflow
       # All of these objects are converted into a lambda and handled
       # the same after this point.
       def make_lambda(filter)
-        case filter
-        when Symbol
-          lambda { |target, _, &blk| target.send filter, &blk }
-        when String
-          l = eval "lambda { |value| #{filter} }"
-          lambda { |target, value| target.instance_exec(value, &l) }
-        # when Conditionals::Value then filter
-        when ::Proc
-          if filter.arity > 1
-            return lambda { |target, _, &block|
-              raise ArgumentError unless block
-              target.instance_exec(target, block, &filter)
-            }
-          end
-
-          if filter.arity <= 0
-            lambda { |target, _| target.instance_exec(&filter) }
-          else
-            lambda { |target, _| target.instance_exec(target, &filter) }
-          end
-        else
-          scopes = Array(chain_config[:scope])
-          method_to_call = scopes.map{ |s| public_send(s) }.join("_")
-
-          lambda { |target, _, &blk|
-            filter.public_send method_to_call, target, &blk
-          }
-        end
       end
 
       def compute_identifier(filter)
@@ -83,3 +65,7 @@ module Workflow
     end
   end
 end
+
+require 'workflow/callbacks/proc_callback'
+require 'workflow/callbacks/string_callback'
+require 'workflow/callbacks/method_callback'

data/lib/workflow/callbacks/method_callback.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Workflow
+  module Callbacks
+    class MethodCallback < Callback
+      private
+
+      def make_lambda(filter)
+        ->(target, _, &blk) { target.send filter, &blk }
+      end
+    end
+  end
+end

data/lib/workflow/callbacks/proc_callback.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module Workflow
+  module Callbacks
+    class ProcCallback < Callback
+      private
+
+      def make_lambda(filter)
+        if filter.arity > 1
+          return lambda do |target, _, &block|
+            raise ArgumentError unless block
+            target.instance_exec(target, block, &filter)
+          end
+        end
+
+        if filter.arity <= 0
+          ->(target, _) { target.instance_exec(&filter) }
+        else
+          ->(target, _) { target.instance_exec(target, &filter) }
+        end
+      end
+    end
+  end
+end

data/lib/workflow/callbacks/string_callback.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Workflow
+  module Callbacks
+    class StringCallback < Callback
+      private
+
+      def make_lambda(filter)
+        ->(target, _value) { target.instance_eval(filter) }
+      end
+    end
+  end
+end

data/lib/workflow/callbacks/transition_callback.rb

@@ -1,6 +1,14 @@
 
+# frozen_string_literal: true
 module Workflow
   module Callbacks
+    # @api private
+    # Wrapper object for proc and method callbacks, when that proc or method
+    # is intended to receive arguments that were passed to the transition.
+    # When the method/proc is to be called, a {MethodArgumentBuilder} determines
+    # and generates the array of arguments to send to the method.
+    # @see Workflow::Callbacks::TransitionCallbacks::MethodCaller
+    # @see Workflow::Callbacks::TransitionCallbacks::ProcCaller
     class TransitionCallback
       attr_reader :callback_type, :raw_proc, :calling_class
       def initialize(callback_type, raw_proc, calling_class)
@@ -9,108 +17,110 @@ module Workflow
         @calling_class = calling_class
       end
 
-      def self.build_wrapper(callback_type, raw_proc, calling_class)
-        if raw_proc.kind_of? ::Proc
-          TransitionCallbacks::ProcWrapper.new(callback_type, raw_proc, calling_class)
-        elsif raw_proc.kind_of? ::Symbol
-          if zero_arity_method?(raw_proc, calling_class)
-            raw_proc
-          else
-            TransitionCallbacks::MethodWrapper.new(callback_type, raw_proc, calling_class)
-          end
+      def call(target, _value, &block)
+        if around_callback?
+          around_proc(target, block)
         else
-          raw_proc
+          normal_proc(target)
         end
       end
 
-      def wrapper
-        raise NotImplementedError.new "Abstract Method Called"
-      end
-
-      protected
-
-      # Returns true if the method has arity zero.
-      # Returns false if the method is defined and has non-zero arity.
-      # Returns nil if the method has not been defined.
-      def self.zero_arity_method?(method, calling_class)
-        if calling_class.instance_methods.include?(method)
-          method = calling_class.instance_method(method)
-          method.arity == 0
+      class << self
+        def build(callback_type, raw_proc, calling_class)
+          case raw_proc
+          when ::Proc
+            TransitionCallbacks::ProcCaller.build(callback_type, raw_proc, calling_class)
+          when ::Symbol
+            TransitionCallbacks::MethodCaller.build(callback_type, raw_proc, calling_class)
+          else raw_proc
+          end
         end
       end
 
-      def build_proc(proc_body)
-        <<-EOF
-          Proc.new do |target#{', callbacks' if around_callback?}|
-            from, to, event, event_args, attributes = transition_context.values
-            name_proc  = Proc.new {|name|
-              case name
-              when :to then to
-              when :from then from
-              when :event then event
-              else (attributes.delete(name) || event_args.shift)
-              end
-            }
-            #{proc_body}
-          end
-        EOF
-      end
+      protected
 
       def around_callback?
         callback_type == :around
       end
 
-      def name_arguments_string
-        raise NotImplementedError.new "Abstract Method Called"
-      end
+      # Builds arguments appropriate for calling the wrapped proc or method.
+      class MethodArgumentBuilder
+        attr_reader :transition_context, :method, :event, :from, :to, :attributes, :event_args
+        attr_reader :args
+        def initialize(transition_context, method)
+          @transition_context = transition_context
+          @method = method
+          @from, @to, @event, @event_args, @attributes = transition_context.values
+          build_args
+        end
 
-      def kw_arguments_string
-        params = kw_params.map do |name|
-          "#{name}: attributes.delete(#{name.inspect})"
+        def build_args
+          @args = name_arguments + rest_arguments
+          kwargs = keyword_arguments.merge(keyrest_arguments)
+          @args << kwargs unless kwargs.empty?
         end
-        params.join(', ') if params.any?
-      end
 
-      def keyrest_string
-        '**attributes' if keyrest_param
-      end
+        def name_arguments
+          name_params.map do |name|
+            case name
+            when :to then to
+            when :from then from
+            when :event then event
+            else (attributes.delete(name) || event_args.shift)
+            end
+          end
+        end
 
-      def rest_param_string
-        '*event_args' if rest_param
-      end
+        def rest_arguments
+          if rest_param
+            event_args
+          else
+            []
+          end
+        end
 
-      def procedure_string
-        raise NotImplementedError.new "Abstract Method Called"
-      end
+        def keyword_arguments
+          kw_params.map do |name|
+            [name, attributes.delete(name)]
+          end.to_h
+        end
 
-      def name_params
-        params_by_type :opt, :req
-      end
+        def keyrest_arguments
+          if keyrest_param
+            attributes
+          else
+            {}
+          end
+        end
 
-      def kw_params
-        params_by_type :keyreq, :keyopt
-      end
+        def name_params
+          params_by_type :opt, :req
+        end
 
-      def keyrest_param
-        params_by_type(:keyrest).first
-      end
+        def kw_params
+          params_by_type :keyreq, :keyopt
+        end
 
-      def rest_param
-        params_by_type(:rest).first
-      end
+        def keyrest_param
+          params_by_type(:keyrest).first
+        end
 
-      def params_by_type(*types)
-        parameters.select do |type, name|
-          types.include? type
-        end.map(&:last)
-      end
+        def rest_param
+          params_by_type(:rest).first
+        end
 
-      def parameters
-        raise NotImplementedError.new "Abstract Method Called"
-      end
+        def params_by_type(*types)
+          parameters.select do |type, _name|
+            types.include? type
+          end.map(&:last)
+        end
 
-      def arity
-        raise NotImplementedError.new "Abstract Method Called"
+        # Parameter definition for the object.  See UnboundMethod#parameters
+        #
+        # @return [Array] Parameters
+        def parameters
+          method.parameters
+        end
       end
     end
   end

data/lib/workflow/callbacks/transition_callbacks/method_caller.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module Workflow
+  module Callbacks
+    module TransitionCallbacks
+      # @api private
+      # A {Workflow::Callbacks::TransitionCallback} that calls an instance method
+      # With arity != 0.
+      class MethodCaller < ::Workflow::Callbacks::TransitionCallback
+        attr_reader :calling_class
+
+        def normal_proc(target)
+          transition_context = target.send :transition_context
+          method = target.method(raw_proc)
+          builder = MethodArgumentBuilder.new(transition_context, method)
+          target.instance_exec(*builder.args, &method)
+        end
+
+        def around_proc(target, callbacks)
+          transition_context = target.send :transition_context
+          method = target.method(raw_proc)
+          builder = MethodArgumentBuilder.new(transition_context, method)
+          target.send raw_proc, *builder.args, &callbacks
+        end
+
+        class << self
+          def build(callback_type, raw_proc, calling_class)
+            return raw_proc if zero_arity_method?(raw_proc, calling_class)
+            new(callback_type, raw_proc, calling_class)
+          end
+
+          private
+
+          # Returns true if the method has arity zero.
+          # Returns false if the method is defined and has non-zero arity.
+          # Returns nil if the method has not been defined.
+          def zero_arity_method?(method, calling_class)
+            return false unless calling_class.instance_methods.include?(method)
+            method = calling_class.instance_method(method)
+            method.arity.zero?
+          end
+        end
+
+        private
+
+        # @return [UnboundMethod] Method representation from class
+        #                         {#calling_class}, named by {#raw_proc}
+        def callback_method
+          @meth ||= calling_class.instance_method(raw_proc)
+        end
+      end
+    end
+  end
+end

data/lib/workflow/callbacks/transition_callbacks/proc_caller.rb

@@ -0,0 +1,60 @@
+
+# frozen_string_literal: true
+module Workflow
+  module Callbacks
+    module TransitionCallbacks
+      # @api private
+      # A {Workflow::Callbacks::TransitionCallback} that wraps a callback proc.
+      class ProcCaller < ::Workflow::Callbacks::TransitionCallback
+        def normal_proc(target)
+          transition_context = target.send :transition_context
+          builder = NormalProcArgBuilder.new(transition_context, raw_proc)
+          target.instance_exec target, *builder.args, &raw_proc
+        end
+
+        def around_proc(target, callbacks)
+          transition_context = target.send :transition_context
+          builder = AroundProcArgBuilder.new(transition_context, raw_proc)
+          target.instance_exec target, callbacks, *builder.args, &raw_proc
+        end
+
+        class << self
+          def build(callback_type, raw_proc, calling_class)
+            return raw_proc if basic_callback?(raw_proc, callback_type)
+            new(callback_type, raw_proc, calling_class)
+          end
+
+          private
+
+          # Returns true if the method has arity zero.
+          # Returns false if the method is defined and has non-zero arity.
+          # Returns nil if the method has not been defined.
+          def basic_callback?(method, callback_type)
+            case method.arity
+            when 0 then true
+            when 1 then [:req, :opt].include?(method.parameters[0][0])
+            when 2 then callback_type == :around
+            else false
+            end
+          end
+        end
+
+        class NormalProcArgBuilder < MethodArgumentBuilder
+          private
+
+          def name_params
+            super[1..-1] || []
+          end
+        end
+
+        class AroundProcArgBuilder < MethodArgumentBuilder
+          private
+
+          def name_params
+            super[2..-1] || []
+          end
+        end
+      end
+    end
+  end
+end