rails-workflow 1.4.5.4 → 1.4.6.4

data/lib/workflow/adapters/active_record.rb

@@ -1,43 +1,40 @@
+# frozen_string_literal: true
 module Workflow
-  module Adapter
+  module Adapters
     module ActiveRecord
-      def self.included(klass)
-        klass.send :include, Adapter::ActiveRecord::InstanceMethods
-        klass.send :extend, Adapter::ActiveRecord::Scopes
-        klass.before_validation :write_initial_state
+      extend ActiveSupport::Concern
+
+      included do
+        before_validation :write_initial_state
       end
 
-      module InstanceMethods
-        def load_workflow_state
-          read_attribute(self.class.workflow_column)&.to_sym
-        end
+      def load_workflow_state
+        read_attribute(self.class.workflow_column)&.to_sym
+      end
 
-        # On transition the new workflow state is immediately saved in the
-        # database, if configured to do so.
-        def persist_workflow_state(new_value)
-          # Rails 3.1 or newer
-          if persisted? && Workflow.config.persist_workflow_state_immediately
-            attrs = {self.class.workflow_column => new_value}
-            if Workflow.config.touch_on_update_column
-              attrs[:updated_at] = DateTime.now
-            end
-            update_columns attrs
-            new_value
-          else
-            self[self.class.workflow_column] = new_value
+      # On transition the new workflow state is immediately saved in the
+      # database, if configured to do so.
+      def persist_workflow_state(new_value)
+        # Rails 3.1 or newer
+        if persisted? && Workflow.config.persist_workflow_state_immediately
+          attrs = { self.class.workflow_column => new_value }
+          if Workflow.config.touch_on_update_column
+            attrs[:updated_at] = DateTime.now
           end
+          update_columns attrs
+          new_value
+        else
+          self[self.class.workflow_column] = new_value
         end
+      end
 
-        private
-
-        # Motivation: even if NULL is stored in the workflow_state database column,
-        # the current_state is correctly recognized in the Ruby code. The problem
-        # arises when you want to SELECT records filtering by the value of initial
-        # state. That's why it is important to save the string with the name of the
-        # initial state in all the new records.
-        def write_initial_state
-          write_attribute self.class.workflow_column, current_state.name
-        end
+      # Motivation: even if NULL is stored in the workflow_state database column,
+      # the current_state is correctly recognized in the Ruby code. The problem
+      # arises when you want to SELECT records filtering by the value of initial
+      # state. That's why it is important to save the string with the name of the
+      # initial state in all the new records.
+      private def write_initial_state
+        write_attribute self.class.workflow_column, current_state.name
       end
 
       # This module will automatically generate ActiveRecord scopes based on workflow states.
@@ -47,31 +44,41 @@ module Workflow
       #
       # Article.with_pending_state # => ActiveRecord::Relation
       # Payment.without_refunded_state # => ActiveRecord::Relation
-      #`
+      # `
       # Example above just adds `where(:state_column_name => 'pending')` or
       # `where.not(:state_column_name => 'pending')` to AR query and returns
       # ActiveRecord::Relation.
-      module Scopes
-        def self.extended(object)
-          class << object
-            alias_method :workflow_without_scopes, :workflow unless method_defined?(:workflow_without_scopes)
-            alias_method :workflow, :workflow_with_scopes
-          end
+      module ClassMethods
+        # Instructs Workflow which column to use to persist workflow state.
+        #
+        # @param [Symbol] column_name If provided, will set a new workflow column name.
+        # @return [Symbol] The current (or new) name for the workflow column on this class.
+        def workflow_column(column_name = nil)
+          @workflow_column = column_name.to_sym if column_name
+          @workflow_column ||= superclass_workflow || :workflow_state
         end
 
-        def workflow_with_scopes(&specification)
-          workflow_without_scopes(&specification)
-          states = workflow_spec.states
+        def workflow(&specification)
+          super
+          workflow_spec.states.each { |state| define_scopes(state) }
+        end
 
-          states.map(&:name).each do |state|
-            define_singleton_method("with_#{state}_state") do
-              where(self.workflow_column.to_sym => state.to_s)
-            end
+        private
 
-            define_singleton_method("without_#{state}_state") do
-              where.not(self.workflow_column.to_sym => state.to_s)
-            end
-          end
+        def superclass_workflow
+          superclass.workflow_column if superclass.respond_to?(:workflow_column)
+        end
+
+        def define_scopes(state)
+          state_name = state.name
+
+          scope "with_#{state_name}_state", lambda {
+            where(workflow_column => state_name)
+          }
+
+          scope "without_#{state_name}_state", lambda {
+            where.not(workflow_column => state_name)
+          }
         end
       end
     end

data/lib/workflow/adapters/active_record_validations.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
 require 'active_support/concern'
+require 'English'
 
 module Workflow
-  module Adapter
+  module Adapters
     module ActiveRecordValidations
       extend ActiveSupport::Concern
 
@@ -14,13 +16,14 @@ module Workflow
       # Captures instance method calls of the form `:transitioning_from_<state_name>`
       #   and `:transitioning_to_<state_name>`.
       #
-      # For use with validators, e.g. `validates :foobar, presence: true, if: :transitioning_to_some_state?`
+      # For use with validators, e.g. `validates :foobar, presence: true,
+      #   if: :transitioning_to_some_state?`
       #
       def method_missing(method, *args, &block)
         if method.to_s =~ /^transitioning_(from|to|via_event)_([\w_-]+)\?$/
           class_eval "
           def #{method}
-            transitioning? direction: '#{$~[1]}', state: '#{$~[2]}'
+            transitioning? direction: '#{$LAST_MATCH_INFO[1]}', state: '#{$LAST_MATCH_INFO[2]}'
           end
           "
           send method
@@ -29,6 +32,10 @@ module Workflow
         end
       end
 
+      def respond_to_missing?(method_name, _include_private = false)
+        method_name.to_s =~ /^transitioning_(from|to|via_event)_([\w_-]+)\?$/
+      end
+
       def can_transition?(event_id)
         event = current_state.find_event(event_id)
         return false unless event
@@ -51,7 +58,8 @@ module Workflow
       # correct answers to the questions, `:transitioning_from_<old_state>?`.
       # `:transitioning_to_<new_state>`, `:transitioning_via_event_<event_name>?`
       #
-      # For use with validators, e.g. `validates :foobar, presence: true, if: :transitioning_to_some_state?`
+      # For use with validators, e.g. `validates :foobar, presence: true,
+      # if: :transitioning_to_some_state?`
       #
       # = Example:
       #
@@ -61,19 +69,17 @@ module Workflow
       #      end
       #    end
       #
-      def within_transition(from, to, event, &block)
-        begin
-          @transition_context = TransitionContext.new \
-            from: from,
-            to: to,
-            event: event,
-            attributes: {},
-            event_args: []
-
-          return block.call()
-        ensure
-          @transition_context = nil
-        end
+      def within_transition(from, to, event)
+        @transition_context = TransitionContext.new \
+          from: from,
+          to: to,
+          event: event,
+          attributes: {},
+          event_args: []
+
+        return yield
+      ensure
+        @transition_context = nil
       end
 
       # Override for ActiveRecord::Validations#valid?
@@ -89,7 +95,7 @@ module Workflow
       # meaning that one should call `errors.clear` before {#valid?} will
       # trigger validations to run anew.
       module RevalidateOnlyAfterAttributesChange
-        def valid?(context=nil)
+        def valid?(context = nil)
           if errors.any? && !@changed_since_validation
             false
           else
@@ -109,7 +115,7 @@ module Workflow
 
       module ClassMethods
         def halt_transition_unless_valid!
-          before_transition unless: :valid? do |model|
+          before_transition unless: :valid? do |_model|
             throw :abort
           end
         end

data/lib/workflow/adapters/adapter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module Workflow
+  module Adapters
+    module Adapter
+      extend ActiveSupport::Concern
+      included do
+        # Look for a hook; otherwise detect based on ancestor class.
+        if respond_to?(:workflow_adapter)
+          include workflow_adapter
+        else
+          if Adapters.const_defined?(:ActiveRecord) && self < ::ActiveRecord::Base
+            include Adapters::ActiveRecord
+            include ActiveRecordValidations
+          end
+
+          if Object.const_defined?(:Remodel) && klass < Adapter::Remodel::Entity
+            include :Remodel
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workflow/adapters/remodel.rb

@@ -1,15 +1,14 @@
+# frozen_string_literal: true
 module Workflow
-  module Adapter
+  module Adapters
     module Remodel
-      module InstanceMethods
-        def load_workflow_state
-          send(self.class.workflow_column)
-        end
+      def load_workflow_state
+        send(self.class.workflow_column)
+      end
 
-        def persist_workflow_state(new_value)
-          update(self.class.workflow_column => new_value)
-        end
+      def persist_workflow_state(new_value)
+        update(self.class.workflow_column => new_value)
       end
     end
   end
-end
+end

data/lib/workflow/callbacks.rb

@@ -1,68 +1,70 @@
+# frozen_string_literal: true
 require 'workflow/callbacks/callback'
 require 'workflow/callbacks/transition_callback'
-require 'workflow/callbacks/transition_callbacks/method_wrapper'
-require 'workflow/callbacks/transition_callbacks/proc_wrapper'
+require 'workflow/callbacks/transition_callbacks/method_caller'
+require 'workflow/callbacks/transition_callbacks/proc_caller'
 
 module Workflow
   module Callbacks
-
     extend ActiveSupport::Concern
     include ActiveSupport::Callbacks
 
-    CALLBACK_MAP =   {
+    CALLBACK_MAP = {
       transition: :event,
       exit: :from,
       enter: :to
     }.freeze
 
-    # @!attribute [r] transition_context
-    #   During state transition events, contains a {TransitionContext} representing the transition underway.
-    #   @return [TransitionContext] representation of current state transition
-    #
     included do
       CALLBACK_MAP.keys.each do |type|
         define_callbacks type,
-          skip_after_callbacks_if_terminated: true
+                         skip_after_callbacks_if_terminated: true
       end
     end
 
     module ClassMethods
-      def ensure_after_transitions(name=nil, **opts, &block)
-        _ensure_procs  = [name, block].compact.map do |exe|
-          Callback.new(exe)
+      def ensure_after_transitions(name = nil, **opts, &block)
+        ensure_procs = [name, block].compact.map do |exe|
+          Callback.build(exe)
         end
 
-        prepend_around_transition **opts do |obj, callbacks|
+        prepend_around_transition(**opts) do |obj, callbacks|
           begin
-            callbacks.call()
+            callbacks.call
           ensure
-            _ensure_procs.each {|l| l.callback.call obj, ->{}}
+            ensure_procs.each { |l| l.callback.call obj, -> {} }
           end
         end
       end
 
-      def on_error(error_class=Exception, **opts, &block)
-        _error_procs  = [opts.delete(:rescue)].compact.map do |exe|
-          Callback.new(exe)
-        end
+      EMPTY_LAMBDA = -> {}
 
-        _ensure_procs = [opts.delete(:ensure)].compact.map do |exe|
-          Callback.new(exe)
-        end
+      def on_error(error_class = Exception, **opts, &block)
+        error_procs  = build_lambdas([opts.delete(:rescue), block])
+        ensure_procs = build_lambdas(opts.delete(:ensure))
+
+        prepend_around_transition(**opts, &on_error_proc(error_class, error_procs, ensure_procs))
+      end
 
-        prepend_around_transition **opts do |obj, callbacks|
+      private def on_error_proc(error_class, error_procs, ensure_procs)
+        proc do |_obj, callbacks|
           begin
             callbacks.call
           rescue error_class => ex
-            self.instance_exec(ex, &block) if block_given?
-            # block.call(ex) if block_given?
-            _error_procs.each {|l| l.callback.call self, ->{}}
+            instance_exec(ex, &block) if block_given?
+            error_procs.each { |l| l.callback.call self, EMPTY_LAMBDA }
           ensure
-            _ensure_procs.each {|l| l.callback.call self, ->{}}
+            ensure_procs.each { |l| l.callback.call self, EMPTY_LAMBDA }
           end
         end
       end
 
+      private def build_lambdas(*names)
+        [names].flatten.compact.map do |name|
+          Callback.build name
+        end
+      end
+
       ##
       # @!method before_transition
       #
@@ -247,13 +249,13 @@ module Workflow
         CALLBACK_MAP.each do |type, context_attribute|
           define_method "#{callback}_#{type}" do |*names, &blk|
             _insert_callbacks(names, context_attribute, blk) do |name, options|
-              set_callback(type, callback, Callbacks::TransitionCallback.build_wrapper(callback, name, self), options)
+              set_callback(type, callback, cb(callback, name, self), options)
             end
           end
 
           define_method "prepend_#{callback}_#{type}" do |*names, &blk|
             _insert_callbacks(names, context_attribute, blk) do |name, options|
-              set_callback(type, callback, Callbacks::TransitionCallback.build_wrapper(callback, name, self), options.merge(prepend: true))
+              set_callback(type, callback, cb(callback, name, self), options.merge(prepend: true))
             end
           end
 
@@ -270,17 +272,19 @@ module Workflow
         end
       end
 
-      def applicable_callback?(callback, procedure)
+      private def cb(callback, name, target)
+        Callbacks::TransitionCallback.build(callback, name, target)
+      end
+
+      def applicable_callback?(_callback, procedure)
         arity = procedure.arity
-        return true if arity < 0 || arity > 2
-        if [:key, :keyreq, :keyrest].include? procedure.parameters[-1][0]
-          return true
-        else
-          return false
-        end
+        return true if arity.negative? || arity > 2
+
+        [:key, :keyreq, :keyrest].include?(procedure.parameters[-1][0])
       end
 
       private
+
       def _insert_callbacks(callbacks, context_attribute, block = nil)
         options = callbacks.extract_options!
         _normalize_callback_options(options, context_attribute)
@@ -296,30 +300,41 @@ module Workflow
       end
 
       def _normalize_callback_option(options, context_attribute, from, to) # :nodoc:
-        if from = options[from]
-          _from = Array(from).map(&:to_sym).to_set
-          from = proc { |record|
-            _from.include? record.transition_context.send(context_attribute).to_sym
-          }
-          options[to] = Array(options[to]).unshift(from)
+        return unless options[from]
+
+        all_names = Array(options[from]).map(&:to_sym).to_set
+        from = proc do |record|
+          all_names.include? record.transition_context.send(context_attribute).to_sym
         end
+        options[to] = Array(options[to]).unshift(from)
       end
     end
 
     private
+
     #  TODO: Do something here.
     def halted_callback_hook(filter)
       # byebug
     end
 
-    def run_all_callbacks(&block)
+    def run_all_callbacks
       catch(:abort) do
         run_callbacks :transition do
-          throw(:abort) if false == run_callbacks(:exit) do
-            throw(:abort) if false == run_callbacks(:enter, &block)
+          aborting_callbacks(:exit) do
+            aborting_callbacks(:enter) do
+              yield
+            end
           end
         end
       end
     end
+
+    def aborting_callbacks(kind)
+      return_value = run_callbacks(kind) do
+        yield
+      end
+      throw(:abort) if false == return_value
+      return_value
+    end
   end
 end