flow_machine 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cd2fd744bfa9fae413fd4c4f5c9d47d05f80520623fdc5d95dd8be0bf0e13b1
-  data.tar.gz: f8f593c69fe42dbce33166fa81c3a92886bb70fe81169f24f1620f6c7d7733d8
+  metadata.gz: 07e50fbe9241a8d62738c46d08486aa3266540bdf16947f279e6468071381591
+  data.tar.gz: 19837451911696b6789209e65d6189ff65e7a01d05828297827339e3239d5e10
 SHA512:
-  metadata.gz: 1459686da1123e9358ec5bbfc73d52e5db44058aa1f691b9a5ce36f0fddd01ba1a38f28eea8646974c0463843b1c5c2ad26b4d260649431bfade61294e0e9bd6
-  data.tar.gz: 7006a927ea623460f60069e2ae9b082996fa571799651830692920924b61147fec783895093d3b1bf29dbebd76a4777606a61b658ffc3249012e7dfbf3d9d127
+  metadata.gz: 4a150dadcb0d9704686c57728c2c51aa7fe11ca349ca6a9462b1a38d3e05b0343b11babd41288733f791da1428a269556d406a026c323499ed5b346ee303af3b
+  data.tar.gz: b3dea74e0219d55b51f133a1aab01aac0b88f85a0ebf77e6a9849140c0dcfe443d81d430ec0a83da4dc607a1ec596a16859da71a5d6820daac74c0f4ff564472

data/README.md

@@ -43,10 +43,15 @@ end
 
 class PublishedState < FlowMachine::WorkflowState
   on_enter :notify_email_author
+  on_exit :clear_published_at
 
   def notify_email_author
     # Send an email
   end
+
+  def clear_published_at
+    object.published_at = nil
+  end
 end
 ```
 
@@ -114,7 +119,8 @@ State and Workflow callbacks accept `if` and `unless` options. They may be a sym
 
 Declared in the `WorkflowState` class.
 
-* `on_enter` Called after the object has transitioned into the state
+* `on_exit` Called after the object has transitioned out of the state.
+* `on_enter` Called after the object has transitioned into the state. Triggered after the previous state's `on_exit`.
 
 The following are available when `Workflow#save` is used (`workflow.save` or `workflow.transition!`) *Not called if you call `save` directly on the decorated model*.
 
@@ -137,7 +143,7 @@ The following are available when `Workflow#save` is used:
 
 Declared as an option to the `transition` method inside an `event` block.
 
-* `after` Will be called after the transition has happened successfully. Useful when you only want something to trigger when moving from a specific state to another.
+* `after` Will be called after the transition has happened successfully including persistance (if applicable). Useful when you only want something to trigger when moving from a specific state to another.
 
 `transition to: :published, after: :send_mailing_list_email`
 

data/Rakefile

@@ -1,38 +1,34 @@
 begin
-  require 'bundler/setup'
+  require "bundler/setup"
 rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
 end
 
-require 'rdoc/task'
+require "rdoc/task"
 
 RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Workflow'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "Workflow"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.rdoc")
+  rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
-
-
-
 Bundler::GemHelper.install_tasks
 
-require 'rake/testtask'
+require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
   t.verbose = false
 end
 
-
 task default: :test
 
 begin
-  require 'rspec/core/rake_task'
+  require "rspec/core/rake_task"
   RSpec::Core::RakeTask.new(:spec)
 rescue LoadError
 end

data/lib/flow_machine.rb

@@ -1,4 +1,4 @@
-$:.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require "flow_machine/workflow"
 require "flow_machine/workflow/factory_methods"
@@ -9,4 +9,3 @@ require "flow_machine/change_callback"
 
 module FlowMachine
 end
-

data/lib/flow_machine/callback.rb

@@ -1,43 +1,46 @@
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/array/extract_options'
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/array/extract_options"
 
-class FlowMachine::Callback
-  attr_accessor :method, :options
-  def initialize(*args, &block)
-    @options = args.extract_options!
-    @method = args.shift unless block
-    @block = block
-  end
+module FlowMachine
+  class Callback
+    attr_accessor :method, :options
+    def initialize(*args, &block)
+      @options = args.extract_options!
+      @method = args.shift unless block
+      @block = block
+    end
 
-  def call(target, changes = {})
-    return unless will_run? target, changes
-    call!(target)
-  end
+    def call(target, changes = {})
+      return unless will_run? target, changes
 
-  # Runs the callback without any validations
-  def call!(target)
-    run_method_or_lambda(target, method.presence || @block)
-  end
+      call!(target)
+    end
 
-  def run_method_or_lambda(target, method)
-    if method.respond_to? :call # is it a lambda
-      target.instance_exec &method
-    else
-      run_method(target, method)
+    # Runs the callback without any validations
+    def call!(target)
+      run_method_or_lambda(target, method.presence || @block)
     end
-  end
 
-  def run_method(target, method)
-    target.send(method)
-  end
+    def run_method_or_lambda(target, method)
+      if method.respond_to? :call # is it a lambda
+        target.instance_exec(&method)
+      else
+        run_method(target, method)
+      end
+    end
+
+    def run_method(target, method)
+      target.send(method)
+    end
 
-  def will_run?(target, changes = {})
-    if options[:if]
-      [*options[:if]].all? { |m| run_method_or_lambda(target, m) }
-    elsif options[:unless]
-      [*options[:unless]].none? { |m| run_method_or_lambda(target, m) }
-    else
-      true
+    def will_run?(target, _changes = {})
+      if options[:if]
+        [*options[:if]].all? { |m| run_method_or_lambda(target, m) }
+      elsif options[:unless]
+        [*options[:unless]].none? { |m| run_method_or_lambda(target, m) }
+      else
+        true
+      end
     end
   end
 end

data/lib/flow_machine/change_callback.rb

@@ -1,11 +1,13 @@
-class FlowMachine::ChangeCallback < FlowMachine::StateCallback
-  attr_accessor :field
-  def initialize(field, *args, &block)
-    @field = field
-    super(*args, &block)
-  end
+module FlowMachine
+  class ChangeCallback < FlowMachine::StateCallback
+    attr_accessor :field
+    def initialize(field, *args, &block)
+      @field = field
+      super(*args, &block)
+    end
 
-  def will_run?(object, changes = {})
-    changes.keys.include?(field.to_s) && super
+    def will_run?(object, changes = {})
+      changes.key?(field.to_s) && super
+    end
   end
 end

data/lib/flow_machine/state_callback.rb

@@ -1,5 +1,7 @@
-class FlowMachine::StateCallback < FlowMachine::Callback
-  def run_method(target, method)
-    target.run_workflow_method(method)
+module FlowMachine
+  class StateCallback < FlowMachine::Callback
+    def run_method(target, method)
+      target.run_workflow_method(method)
+    end
   end
 end

data/lib/flow_machine/version.rb

@@ -1,3 +1,3 @@
 module FlowMachine
-  VERSION = "0.2.2"
+  VERSION = "0.2.3".freeze
 end

data/lib/flow_machine/workflow.rb

@@ -14,11 +14,10 @@ module FlowMachine
     end
 
     module ClassMethods
-
       attr_accessor :callbacks
 
       def state_names
-        states.keys.map &:to_s
+        states.keys.map(&:to_s)
       end
 
       def states
@@ -112,7 +111,7 @@ module FlowMachine
     def current_state_name
       object.send(self.class.state_method)
     end
-    alias_method :state, :current_state_name
+    alias state current_state_name
 
     def previous_state_name
       @previous_state.try(:name)
@@ -139,7 +138,7 @@ module FlowMachine
       self.changes = object.changes
       # If the model has a default state from the database, then it doesn't get
       # included in `changes` when you're first saving it.
-      self.changes[state_method.to_s] ||= [nil, current_state_name] if object.new_record?
+      changes[state_method.to_s] ||= [nil, current_state_name] if object.new_record?
 
       fire_callbacks(:before_save)
       current_state.fire_callbacks(:before_change, changes)
@@ -157,7 +156,7 @@ module FlowMachine
     # Useful for using in if/unless on state and after_save callbacks so you can
     # run the callback only on the initial persistence
     def create?
-      self.changes[state_method.to_s].try(:first).blank?
+      changes[state_method.to_s].try(:first).blank?
     end
 
     def persist_object
@@ -165,7 +164,8 @@ module FlowMachine
     end
 
     def current_state_name=(new_state)
-      raise ArgumentError.new("invalid state: #{new_state}") unless self.class.state_names.include?(new_state.to_s)
+      raise ArgumentError, "invalid state: #{new_state}" unless self.class.state_names.include?(new_state.to_s)
+
       object.send("#{self.class.state_method}=", new_state)
     end
 

data/lib/flow_machine/workflow/factory_methods.rb

@@ -8,6 +8,7 @@ module FlowMachine
 
       klazz = class_for(object)
       return nil unless klazz
+
       klazz.new(object, options)
     end
 
@@ -19,7 +20,7 @@ module FlowMachine
       if object_or_class.is_a? Class
         "#{object_or_class.name}Workflow".constantize
       else
-        self.class_for(object_or_class.class)
+        class_for(object_or_class.class)
       end
     rescue NameError # if the workflow class doesn't exist
       nil

data/lib/flow_machine/workflow_state.rb

@@ -1,162 +1,172 @@
 require "active_support/core_ext/module/delegation"
 require "active_support/inflector"
 
-class FlowMachine::WorkflowState
-  attr_reader :workflow
-  attr_accessor :guard_errors
+module FlowMachine
+  class WorkflowState
+    attr_reader :workflow
+    attr_accessor :guard_errors
 
-  delegate :object, :options, to: :workflow
+    delegate :object, :options, to: :workflow
 
-  module ClassMethods
-    attr_accessor :state_callbacks
-    attr_accessor :expose_to_workflow_methods
+    module ClassMethods
+      attr_accessor :state_callbacks
+      attr_accessor :expose_to_workflow_methods
 
-    def state_name
-      name.demodulize.sub(/State\z/, '').underscore.to_sym
-    end
+      def state_name
+        name.demodulize.sub(/State\z/, "").underscore.to_sym
+      end
 
-    # Maintains a list of methods that should be exposed to the workflow
-    # the workflow is responsible for reading this list
-    def expose_to_workflow(name)
-      self.expose_to_workflow_methods ||= []
-      self.expose_to_workflow_methods << name
-    end
+      # Maintains a list of methods that should be exposed to the workflow
+      # the workflow is responsible for reading this list
+      def expose_to_workflow(name)
+        self.expose_to_workflow_methods ||= []
+        self.expose_to_workflow_methods << name
+      end
 
-    def event(name, options = {}, &block)
-      define_may_event(name, options)
-      define_event(name, options, &block)
-      define_event_bang(name)
-    end
+      def event(name, options = {}, &block)
+        define_may_event(name, options)
+        define_event(name, options, &block)
+        define_event_bang(name)
+      end
 
-    private
+      private
+
+      def define_event(name, _options, &block)
+        define_method name do |*args|
+          return false unless send("may_#{name}?")
 
-    def define_event(name, options, &block)
-      define_method name do |*args|
-        return false unless self.send("may_#{name}?")
-        instance_exec *args, &block
+          instance_exec(*args, &block)
+        end
+        expose_to_workflow name
       end
-      expose_to_workflow name
-    end
 
-    def define_may_event(name, options)
-      define_method "may_#{name}?" do
-        run_guard_methods([*options[:guard]])
+      def define_may_event(name, options)
+        define_method "may_#{name}?" do
+          run_guard_methods([*options[:guard]])
+        end
+        expose_to_workflow "may_#{name}?"
       end
-      expose_to_workflow "may_#{name}?"
-    end
 
-    def define_event_bang(name)
-      define_method "#{name}!" do |*args|
-        workflow.persist if self.send(name, *args)
+      def define_event_bang(name)
+        define_method "#{name}!" do |*args|
+          workflow.persist if send(name, *args)
+        end
+        expose_to_workflow "#{name}!"
       end
-      expose_to_workflow "#{name}!"
-    end
-  end
-  extend ClassMethods
-
-  # Callbacks may be a symbol method name on the state, workflow, or underlying object,
-  # and will look for that method on those objects in that order. You may also
-  # use a block.
-  # Callbacks will accept :if and :unless options, which also may be method name
-  # symbols or blocks. The option accepts an array meaning all methods must return
-  # true (for if) and false (for unless)
-  #
-  # class ExampleState < Workflow::State
-  #   on_enter :some_method, if: :allowed?
-  #   after_enter :after_enter_method, if: [:this_is_true?, :and_this_is_true?]
-  #   before_change(:field_name) { do_something }
-  # end
-  #
-  module CallbackDsl
-    # Called when the workflow `transition`s to the state
-    def on_enter(*args, &block)
-      add_callback(:on_enter, FlowMachine::StateCallback.new(*args, &block))
     end
+    extend ClassMethods
+
+    # Callbacks may be a symbol method name on the state, workflow, or underlying object,
+    # and will look for that method on those objects in that order. You may also
+    # use a block.
+    # Callbacks will accept :if and :unless options, which also may be method name
+    # symbols or blocks. The option accepts an array meaning all methods must return
+    # true (for if) and false (for unless)
+    #
+    # class ExampleState < Workflow::State
+    #   on_enter :some_method, if: :allowed?
+    #   after_enter :after_enter_method, if: [:this_is_true?, :and_this_is_true?]
+    #   before_change(:field_name) { do_something }
+    # end
+    #
+    module CallbackDsl
+      # Called when the workflow `transition`s to the state
+      def on_enter(*args, &block)
+        add_callback(:on_enter, FlowMachine::StateCallback.new(*args, &block))
+      end
 
-    # Called after `persist` when the workflow transitioned into this state
-    def after_enter(*args, &block)
-      add_callback(:after_enter, FlowMachine::StateCallback.new(*args, &block))
-    end
+      # Called after `persist` when the workflow transitioned into this state
+      def after_enter(*args, &block)
+        add_callback(:after_enter, FlowMachine::StateCallback.new(*args, &block))
+      end
 
-    # Happens before persistence if the field on the object has changed
-    def before_change(field, *args, &block)
-      add_callback(:before_change, FlowMachine::ChangeCallback.new(field, *args, &block))
-    end
+      # Called when the worklow `transition`s out of the state
+      def on_exit(*args, &block)
+        add_callback(:on_exit, FlowMachine::StateCallback.new(*args, &block))
+      end
+
+      # Happens before persistence if the field on the object has changed
+      def before_change(field, *args, &block)
+        add_callback(:before_change, FlowMachine::ChangeCallback.new(field, *args, &block))
+      end
+
+      # Happens after persistence if the field on the object has changed
+      def after_change(field, *args, &block)
+        add_callback(:after_change, FlowMachine::ChangeCallback.new(field, *args, &block))
+      end
+
+      private
 
-    # Happens after persistence if the field on the object has changed
-    def after_change(field, *args, &block)
-      add_callback(:after_change, FlowMachine::ChangeCallback.new(field, *args, &block))
+      def add_callback(hook, callback)
+        self.state_callbacks ||= {}
+        state_callbacks[hook] ||= []
+        state_callbacks[hook] << callback
+      end
     end
+    extend CallbackDsl
 
-    private
+    def initialize(workflow)
+      @workflow = workflow
+      @guard_errors = []
+    end
 
-    def add_callback(hook, callback)
-      self.state_callbacks ||= {}
-      state_callbacks[hook] ||= []
-      state_callbacks[hook] << callback
+    def fire_callback_list(callbacks, changes = {})
+      callbacks.each do |callback|
+        callback.call(self, changes)
+      end
     end
-  end
-  extend CallbackDsl
 
-  def initialize(workflow)
-    @workflow = workflow
-    @guard_errors = []
-  end
+    def fire_callbacks(event, changes = {})
+      return unless self.class.state_callbacks.try(:[], event)
 
-  def fire_callback_list(callbacks, changes = {})
-    callbacks.each do |callback|
-      callback.call(self, changes)
+      fire_callback_list self.class.state_callbacks[event], changes
     end
-  end
 
-  def fire_callbacks(event, changes = {})
-    return unless self.class.state_callbacks.try(:[], event)
-    fire_callback_list self.class.state_callbacks[event], changes
-  end
+    # Allows method calls to fallback up the object chain so
+    # guards and other methods can be defined on the object or workflow
+    # as well as the state
+    def run_workflow_method(method_name, *args, &block)
+      target = object_chain(method_name)
+      raise NoMethodError.new("undefined method #{method_name}", method_name) unless target
 
-  # Allows method calls to fallback up the object chain so
-  # guards and other methods can be defined on the object or workflow
-  # as well as the state
-  def run_workflow_method(method_name, *args, &block)
-    if target = object_chain(method_name)
       target.send(method_name, *args, &block)
-    else
-      raise NoMethodError.new("undefined method #{method_name}", method_name)
     end
-  end
 
-  def transition(options = {})
-    workflow.transition(options).tap do |new_state|
-      new_state.fire_callbacks(:on_enter) if new_state
+    def transition(options = {})
+      workflow.transition(options).tap do |new_state|
+        if new_state != workflow.previous_state
+          workflow.previous_state.fire_callbacks(:on_exit)
+          new_state.fire_callbacks(:on_enter)
+        end
+      end
     end
-  end
 
-  def name
-    self.class.state_name
-  end
+    def name
+      self.class.state_name
+    end
 
-  def ==(other)
-    self.class == other.class
-  end
+    def ==(other)
+      self.class == other.class
+    end
 
-  private
-
-  def run_guard_methods(guard_methods)
-    self.guard_errors = []
-    # Use inject to ensure that all guard methods are run.
-    # all? short circuits on first false value
-    guard_methods.inject(true) do |valid, guard_method|
-      if self.run_workflow_method(guard_method)
-        valid
-      else
-        self.guard_errors << guard_method
-        false
+    private
+
+    def run_guard_methods(guard_methods)
+      self.guard_errors = []
+      # Use inject to ensure that all guard methods are run.
+      # all? short circuits on first false value
+      guard_methods.inject(true) do |valid, guard_method|
+        if run_workflow_method(guard_method)
+          valid
+        else
+          guard_errors << guard_method
+          false
+        end
       end
     end
-    #
-  end
 
-  def object_chain(method_name)
-    [self, workflow, object].find { |o| o.respond_to?(method_name, true) }
+    def object_chain(method_name)
+      [self, workflow, object].find { |o| o.respond_to?(method_name, true) }
+    end
   end
 end