rails-workflow 1.4.2.4 → 1.4.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44851c558cacf48d320f22b1b2f644507999f8ac
-  data.tar.gz: 034320eef361e79282e3a215094c99733b079fbf
+  metadata.gz: fef57b053c2e5b632d435a9e6c98dc8da4b28117
+  data.tar.gz: 90121871ed2d3df2a3417276683a36a44687d87a
 SHA512:
-  metadata.gz: 46d9a44561d2959736533d1d2095756420a3bd15b6449e19fc09ccb4a741d998c9e4c76aaeb32b7f4fce1ee5bc0fa9e16da135fb3bb76cc17a2b2930171085af
-  data.tar.gz: 097c8593b99ea4512f983bf0f40f961ee31e21b23d8b115c6dbde809896e6b96ec2e23f1d0aa25774d172a74eec2477d3bb5169bd69289bf42f1a2d903a52a9c
+  metadata.gz: b7c57936b5570cc3c0eea2973a07cdc1419333d3e02ca370c2a69fe49aafe151b33d0d53bc43304fdc32ac7f46c0bf541687c525955f2652f6ad735a873cfc69
+  data.tar.gz: 159494b51e3e3ce814b34390f25fbc4e367993b893beb2bb517e161e3c7b50f2d38c3c3b7ccaa7dfa9d4c752317839d62fc7c825f7f0334019f57497efafce05

data/.gitignore

@@ -20,3 +20,5 @@ test/version_tmp
 tmp
 
 .byebug_history
+
+lib/active_support/callbacks.rb

data/README.markdown

@@ -298,24 +298,78 @@ The three callback classes accept `:only` and `:except` parameters, and treat th
 ## Parameterized Callbacks
 
 If you're passing parameters through the `transition!` method, you can receive
-them easily in your callbacks.  For example:
+them easily in your callbacks.  Workflow::Callbacks will inspect the parameters of
+your block or method and pass just the ones you ask for.
+
+Three magic names apply to parameter names defined on callbacks:
+
+* `event` will be set to the name of the event being processed.
+* `to` will be set to the name of the destination state.
+* `from` will be set to the name of the state being exited.
+
+Other parameters will be `shift`ed from what you pass in, so they should be taken
+back in order.  As in:
 
 ```ruby
-class Article
-  include Workflow
-  workflow do
-    event_args :review_date
+  def my_after_submit(from, cool, *args)
+    logger.warn [from, cool, args]
+  end
+  after_transition :my_after_submit, only: :submit
+
+  an_article.submit! :rad, 1, 2, 3
+  # => [:submit, :rad, [1, 2, 3]]
+```
+
+You can also use keyword arguments:
+
+```ruby
+  def my_after_submit(to, hype:, **args)
+    logger.warn [to, hype, args]
   end
+  after_transition :my_after_submit, only: :submit
+
+  an_article.submit! a: 1, b: 2, hype: 4.5, c: 3
+  # => [:awaiting_review, 4.5, {a: 1, b: 2, c: 3}]
+```
+
+Around callbacks should be sure to yield the block given:
+
+```ruby
+after_transition :my_after_submit, only: :submit
+
+def my_after_submit(to, hype:, **args)
+  logger.warn [to, hype, args]
+  yield
+end
+
+def my_after_submit(to, hype:, **args, &bloci)
+  logger.warn [to, hype, args]
+  block.call
+end
+
+```
+
+Note that in order to use block-style callbacks with special arguments, unless you
+use strictly keyword arguments, the first
+parameters to your block must be the object and callback block (for around callbacks):
+
+```ruby
   before_transition do |reviewer:|
     logger.debug reviewer.name
   end
-  after_transition do |author:, **arguments|
-    logger.debug arguments[:reviewer].name
-    logger.debug author.name
+  Article.last.transition! :submit, reviewer: current_user
+
+  before_transition do |obj, reviewer|
+    logger.debug reviewer.name
+  end
+  Article.last.transition! :submit, current_user
+
+  around_transition do |obj, callbacks, reviewer|
+    logger.debug reviewer.name
+    callbacks.call
   end
-end
+  Article.last.transition! :submit, current_user
 
-Article.last.transition! :submit, reviewer: current_user
 ```
 
 If you don't like keyword arguments you can use standard arguments, but you

data/bin/console

@@ -2,6 +2,7 @@
 
 require "bundler/setup"
 require "workflow"
+
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 

data/bin/deploy

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+rm *.gem
+gem build `ls *.gemspec`
+gem push `ls *.gem`

data/lib/workflow.rb

@@ -18,6 +18,29 @@ module Workflow
   include Callbacks
   include Errors
 
+  module ComputeIdentifier
+    private
+    def make_lambda(filter)
+      if filter.kind_of? Workflow::Callbacks::TransitionCallbackWrapper
+        super(filter.wrapper)
+      else
+        super
+      end
+    end
+
+    def compute_identifier(filter)
+      if filter.kind_of? Workflow::Callbacks::TransitionCallbackWrapper
+        super(filter.raw_proc)
+      else
+        super
+      end
+    end
+  end
+
+  class ::ActiveSupport::Callbacks::Callback
+    prepend ComputeIdentifier
+  end
+
   def self.configure(&block)
     block.call(config) if block_given?
   end

data/lib/workflow/callbacks.rb

@@ -1,5 +1,6 @@
 require 'workflow/callbacks/callback'
 require 'workflow/callbacks/transition_callback_wrapper'
+require 'workflow/callbacks/transition_callback_method_wrapper'
 
 module Workflow
   module Callbacks
@@ -246,13 +247,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, TransitionCallbackWrapper.build_wrapper(callback, name), options)
+              set_callback(type, callback, TransitionCallbackWrapper.build_wrapper(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, TransitionCallbackWrapper.build_wrapper(callback, name), options.merge(prepend: true))
+              set_callback(type, callback, TransitionCallbackWrapper.build_wrapper(callback, name, self), options.merge(prepend: true))
             end
           end
 
@@ -260,7 +261,7 @@ module Workflow
           # for details on the allowed parameters.
           define_method "skip_#{callback}_#{type}" do |*names|
             _insert_callbacks(names, context_attribute) do |name, options|
-              skip_callback(type, callback, TransitionCallbackWrapper.build_wrapper(callback, name), options)
+              skip_callback(type, callback, name, options)
             end
           end
 

data/lib/workflow/callbacks/transition_callback_method_wrapper.rb

@@ -0,0 +1,65 @@
+module Workflow
+  module Callbacks
+    class TransitionCallbackMethodWrapper < TransitionCallbackWrapper
+      attr_reader :calling_class
+
+      def wrapper
+        cb_object = self
+        proc_string = build_proc(<<-EOF)
+          arguments = [
+            cb_object.send(:raw_proc).inspect,
+            cb_object.send(:name_arguments_string),
+            cb_object.send(:rest_param_string),
+            cb_object.send(:kw_arguments_string),
+            cb_object.send(:keyrest_string),
+            cb_object.send(:procedure_string)].compact.join(', ')
+          target.instance_eval("send(\#{arguments})")
+        EOF
+        p = eval(proc_string)
+        return overload_equality_operator(p)
+      end
+
+      # protected
+
+      def overload_equality_operator(outer_proc)
+        raw_proc = raw_proc
+        def outer_proc.raw_proc
+          raw_proc
+        end
+        def outer_proc.==(other)
+          if other.kind_of?(::Proc)
+            if other.respond_to?(:raw_proc)
+              self.raw_proc == other.raw_proc
+            else
+              self == other
+            end
+          elsif other.kind_of?(Symbol)
+            self.raw_proc == other
+          else
+            false
+          end
+        end
+        return outer_proc
+      end
+      def name_arguments_string
+        name_params.map{|name| "name_proc.call(:#{name})"} if name_params.any?
+      end
+
+      def procedure_string
+        '&callbacks' if around_callback?
+      end
+
+      def callback_method
+        @meth ||= calling_class.instance_method(raw_proc)
+      end
+
+      def parameters
+        callback_method.parameters
+      end
+
+      def arity
+        callback_method.arity
+      end
+    end
+  end
+end

data/lib/workflow/callbacks/transition_callback_wrapper.rb

@@ -1,17 +1,21 @@
+
 module Workflow
   module Callbacks
     class TransitionCallbackWrapper
-      attr_reader :callback_type, :inner_procedure
-      def initialize(callback_type, inner_procedure)
+      attr_reader :callback_type, :raw_proc
+      def initialize(callback_type, raw_proc, calling_class)
         @callback_type = callback_type
-        @inner_procedure      = inner_procedure
+        @raw_proc      = raw_proc
+        @calling_class = calling_class
       end
 
-      def self.build_wrapper(callback_type, inner_procedure)
-        if inner_procedure.kind_of? ::Proc
-          new(callback_type, inner_procedure).wrapper
+      def self.build_wrapper(callback_type, raw_proc, calling_class)
+        if raw_proc.kind_of? ::Proc
+          new(callback_type, raw_proc, calling_class).wrapper
+        elsif raw_proc.kind_of? ::Symbol
+          TransitionCallbackMethodWrapper.new(callback_type, raw_proc, calling_class)
         else
-          inner_procedure
+          raw_proc
         end
       end
 
@@ -23,21 +27,30 @@ module Workflow
           keyrest_string,
           procedure_string].compact.join(', ')
 
-        inner_procedure = self.inner_procedure
-        str = <<-EOF
+        raw_proc = self.raw_proc
+        str = build_proc("target.instance_exec(#{arguments})")
+        eval(str)
+      end
+
+      protected
+
+      def build_proc(proc_body)
+        <<-EOF
           Proc.new do |target#{', callbacks' if around_callback?}|
-            attributes = transition_context.attributes.dup
-            event_args = transition_context.event_args.dup
-            name_arg = -> (name) { attributes.delete(name) || event_args.shift }
-            target.instance_exec(#{arguments})
+            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
-        # puts str
-        eval(str)
       end
 
-      private
-
       def around_callback?
         callback_type == :around
       end
@@ -47,7 +60,7 @@ module Workflow
         names  = []
         names << 'target'   if params.shift
         (names << 'callbacks') && params.shift if around_callback?
-        names += params.map{|name| "name_arg.call(:#{name})"}
+        names += params.map{|name| "name_proc.call(:#{name})"}
         return names.join(', ') if names.any?
       end
 
@@ -67,7 +80,7 @@ module Workflow
       end
 
       def procedure_string
-        '&inner_procedure'
+        '&raw_proc'
       end
 
       def name_params
@@ -93,10 +106,11 @@ module Workflow
       end
 
       def parameters
-        inner_procedure.parameters
+        raw_proc.parameters
       end
+
       def arity
-        inner_procedure.arity
+        raw_proc.arity
       end
     end
   end

data/lib/workflow/transition_context.rb

@@ -40,7 +40,7 @@ module Workflow
     end
 
     def values
-      [from, to, event, event_args]
+      [from, to, event, event_args.dup, attributes.dup]
     end
 
     def respond_to?(method)

data/lib/workflow/version.rb

@@ -1,3 +1,3 @@
 module Workflow
-  VERSION = "1.4.2.4"
+  VERSION = "1.4.4.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-workflow
 version: !ruby/object:Gem::Version
-  version: 1.4.2.4
+  version: 1.4.4.4
 platform: ruby
 authors:
 - Tyler Gannon
@@ -209,6 +209,7 @@ files:
 - Rakefile
 - asdf
 - bin/console
+- bin/deploy
 - bin/setup
 - gemfiles/Gemfile.rails-3.x
 - gemfiles/Gemfile.rails-4.0
@@ -220,6 +221,7 @@ files:
 - lib/workflow/adapters/remodel.rb
 - lib/workflow/callbacks.rb
 - lib/workflow/callbacks/callback.rb
+- lib/workflow/callbacks/transition_callback_method_wrapper.rb
 - lib/workflow/callbacks/transition_callback_wrapper.rb
 - lib/workflow/configuration.rb
 - lib/workflow/draw.rb