aasm 3.4.0 → 4.0.0

data/callbacks.txt

@@ -0,0 +1,51 @@
+callbacks
+
+AASM 3
+
+begin
+  old_state       exit                # old? should be deprecated -> use old_state.before_exit instead
+  event           before
+  old_state       before_exit
+  new_state       before_enter
+  new_state       enter               # old? should be deprecated -> use new_state.before_enter instead
+    ...update state...
+    transition    guard
+    event         guard
+    transition    on_transition
+    event         success             # if persist successful
+  old_state       after_exit
+  new_state       after_enter
+  event           after
+rescue
+  event           error
+end
+
+AASM 4
+
+todo
+
+done
+- move event.before before everything else
+- move old_state.before_exit before old_state.exit
+- move event.guard before transition.guard
+- fire guards before running state callbacks (test run)
+
+begin
+  event           before
+  event           guard               # test run
+  transition      guard               # test run
+  old_state       before_exit
+  old_state       exit
+  new_state       before_enter
+  new_state       enter
+    event         guard
+    transition    guard
+    transition    on_transition
+    ...update state...
+    event         success             # if persist successful
+  old_state       after_exit
+  new_state       after_enter
+  event           after
+rescue
+  event           error
+end

data/lib/aasm.rb

@@ -3,7 +3,9 @@ require 'ostruct'
 %w(
     version
     errors
+    configuration
     base
+    dsl_helper
     instance_base
     transition
     event

data/lib/aasm/aasm.rb

@@ -26,59 +26,6 @@ module AASM
       @aasm
     end
 
-    # TODO remove this method in v4.0.0
-    def aasm_initial_state(set_state=nil)
-      if set_state
-        warn ".aasm_initial_state(:name) is deprecated and will be removed in version 4.0.0; please use .aasm.initial_state = :name instead!"
-        AASM::StateMachine[self].initial_state = set_state
-      else
-        warn ".aasm_initial_state is deprecated and will be removed in version 4.0.0; please use .aasm.initial_state instead!"
-        AASM::StateMachine[self].initial_state
-      end
-    end
-
-    # TODO remove this method in v4.0.0
-    def aasm_from_states_for_state(state, options={})
-      warn ".aasm_from_states_for_state is deprecated and will be removed in version 4.0.0; please use .aasm.from_states_for_state instead!"
-      aasm.from_states_for_state(state, options)
-    end
-
-    # TODO remove this method in v4.0.0
-    def aasm_initial_state=(state)
-      warn ".aasm_initial_state= is deprecated and will be removed in version 4.0.0"
-      AASM::StateMachine[self].initial_state = state
-    end
-
-    # TODO remove this method in v4.0.0
-    def aasm_state(name, options={})
-      warn ".aasm_state is deprecated and will be removed in version 4.0.0; please use .aasm.state instead!"
-      aasm.state(name, options)
-    end
-
-    # TODO remove this method in v4.0.0
-    def aasm_event(name, options = {}, &block)
-      warn ".aasm_event is deprecated and will be removed in version 4.0.0; please use .aasm.event instead!"
-      aasm.event(name, options, &block)
-    end
-
-    # TODO remove this method in v4.0.0
-    def aasm_states
-      warn ".aasm_states is deprecated and will be removed in version 4.0.0; please use .aasm.states instead!"
-      aasm.states
-    end
-
-    # TODO remove this method in v4.0.0
-    def aasm_events
-      warn ".aasm_events is deprecated and will be removed in version 4.0.0; please use .aasm.events instead!"
-      aasm.events
-    end
-
-    # TODO remove this method in v4.0.0
-    def aasm_states_for_select
-      warn ".aasm_states_for_select is deprecated and will be removed in version 4.0.0; please use .aasm.states_for_select instead!"
-      aasm.states_for_select
-    end
-
     # aasm.event(:event_name).human?
     def aasm_human_event_name(event) # event_name?
       AASM::Localizer.new.human_event_name(self, event)
@@ -107,55 +54,43 @@ module AASM
     true
   end
 
-    # TODO remove this method in v4.0.0
-  def aasm_current_state
-    warn "#aasm_current_state is deprecated and will be removed in version 4.0.0; please use #aasm.current_state instead!"
-    aasm.current_state
-  end
-
-    # TODO remove this method in v4.0.0
-  def aasm_enter_initial_state
-    warn "#aasm_enter_initial_state is deprecated and will be removed in version 4.0.0; please use #aasm.enter_initial_state instead!"
-    aasm.enter_initial_state
-  end
-
-    # TODO remove this method in v4.0.0
-  def aasm_events_for_current_state
-    warn "#aasm_events_for_current_state is deprecated and will be removed in version 4.0.0; please use #aasm.events(aasm.current_state) instead!"
-    aasm.events(aasm.current_state)
-  end
-
-    # TODO remove this method in v4.0.0
-  def aasm_permissible_events_for_current_state
-    warn "#aasm_permissible_events_for_current_state is deprecated and will be removed in version 4.0.0; please use #aasm.permissible_events instead!"
-    aasm.permissible_events
-  end
-
-    # TODO remove this method in v4.0.0
-  def aasm_events_for_state(state_name)
-    warn "#aasm_events_for_state(state_name) is deprecated and will be removed in version 4.0.0; please use #aasm.events(state_name) instead!"
-    aasm.events(state_name)
-  end
+private
 
-    # TODO remove this method in v4.0.0
-  def aasm_human_state
-    warn "#aasm_human_state is deprecated and will be removed in version 4.0.0; please use #aasm.human_state instead!"
-    aasm.human_state
+  # Takes args and a from state and removes the first
+  # element from args if it is a valid to_state for
+  # the event given the from_state
+  def process_args(event, from_state, *args)
+    # If the first arg doesn't respond to to_sym then
+    # it isn't a symbol or string so it can't be a state
+    # name anyway
+    return args unless args.first.respond_to?(:to_sym)
+    if event.transitions_from_state(from_state).map(&:to).flatten.include?(args.first)
+      return args[1..-1]
+    end
+    return args
   end
 
-private
-
   def aasm_fire_event(event_name, options, *args, &block)
-    event = self.class.aasm.events[event_name]
+    event = self.class.aasm.state_machine.events[event_name]
     begin
       old_state = aasm.state_object_for_name(aasm.current_state)
-      old_state.fire_callbacks(:exit, self)
 
       # new event before callback
-      event.fire_callbacks(:before, self)
-
-      if new_state_name = event.fire(self, *args)
-        aasm_fired(event, old_state, new_state_name, options, &block)
+      event.fire_callbacks(
+        :before,
+        self,
+        *process_args(event, aasm.current_state, *args)
+      )
+
+      if event.may_fire?(self, *args)
+        old_state.fire_callbacks(:before_exit, self)
+        old_state.fire_callbacks(:exit, self) # TODO: remove for AASM 4?
+
+        if new_state_name = event.fire(self, *args)
+          aasm_fired(event, old_state, new_state_name, options, *args, &block)
+        else
+          aasm_failed(event_name, old_state)
+        end
       else
         aasm_failed(event_name, old_state)
       end
@@ -164,16 +99,14 @@ private
     end
   end
 
-  def aasm_fired(event, old_state, new_state_name, options)
+  def aasm_fired(event, old_state, new_state_name, options, *args)
     persist = options[:persist]
 
     new_state = aasm.state_object_for_name(new_state_name)
 
-    # new before_ callbacks
-    old_state.fire_callbacks(:before_exit, self)
     new_state.fire_callbacks(:before_enter, self)
 
-    new_state.fire_callbacks(:enter, self)
+    new_state.fire_callbacks(:enter, self) # TODO: remove for AASM 4?
 
     persist_successful = true
     if persist
@@ -190,7 +123,11 @@ private
     if persist_successful
       old_state.fire_callbacks(:after_exit, self)
       new_state.fire_callbacks(:after_enter, self)
-      event.fire_callbacks(:after, self)
+      event.fire_callbacks(
+        :after,
+        self,
+        *process_args(event, old_state.name, *args)
+      )
 
       self.aasm_event_fired(event.name, old_state.name, aasm.current_state) if self.respond_to?(:aasm_event_fired)
     else

data/lib/aasm/base.rb

@@ -1,10 +1,13 @@
 module AASM
   class Base
 
+    attr_reader :state_machine
+
     def initialize(klass, options={}, &block)
       @klass = klass
       @state_machine = AASM::StateMachine[@klass]
-      @state_machine.config.column = options[:column].to_sym if options[:column]
+      @state_machine.config.column ||= (options[:column] || :aasm_state).to_sym # aasm4
+      # @state_machine.config.column = options[:column].to_sym if options[:column] # master
       @options = options
 
       # let's cry if the transition is invalid
@@ -13,13 +16,22 @@ module AASM
       # create named scopes for each state
       configure :create_scopes, true
 
-      # don't store any new state if the model is invalid
+      # don't store any new state if the model is invalid (in ActiveRecord)
       configure :skip_validation_on_save, false
 
-      # use requires_new for nested transactions
+      # use requires_new for nested transactions (in ActiveRecord)
       configure :requires_new_transaction, true
 
+      # set to true to forbid direct assignment of aasm_state column (in ActiveRecord)
+      configure :no_direct_assignment, false
+
       configure :enum, nil
+
+      if @state_machine.config.no_direct_assignment
+        @klass.send(:define_method, "#{@state_machine.config.column}=") do |state_name|
+          raise AASM::NoDirectAssignmentError.new('direct assignment of AASM column has been disabled (see AASM configuration for this class)')
+        end
+      end
     end
 
     def initial_state(new_initial_state=nil)
@@ -70,7 +82,7 @@ module AASM
     end
 
     def events
-      @state_machine.events
+      @state_machine.events.values
     end
 
     def states_for_select
@@ -79,16 +91,15 @@ module AASM
 
     def from_states_for_state(state, options={})
       if options[:transition]
-        events[options[:transition]].transitions_to_state(state).flatten.map(&:from).flatten
+        @state_machine.events[options[:transition]].transitions_to_state(state).flatten.map(&:from).flatten
       else
-        events.map {|k,v| v.transitions_to_state(state)}.flatten.map(&:from).flatten
+        events.map {|e| e.transitions_to_state(state)}.flatten.map(&:from).flatten
       end
     end
 
     private
 
     def configure(key, default_value)
-      @state_machine.config.send(:new_ostruct_member, key)
       if @options.key?(key)
         @state_machine.config.send("#{key}=", @options[key])
       elsif @state_machine.config.send(key).nil?

data/lib/aasm/configuration.rb

@@ -0,0 +1,23 @@
+module AASM
+  class Configuration
+    # for all persistence layers: which database column to use?
+    attr_accessor :column
+
+    # let's cry if the transition is invalid
+    attr_accessor :whiny_transitions
+
+    # for all persistence layers: create named scopes for each state
+    attr_accessor :create_scopes
+
+    # for ActiveRecord: don't store any new state if the model is invalid
+    attr_accessor :skip_validation_on_save
+
+    # for ActiveRecord: use requires_new for nested transactions?
+    attr_accessor :requires_new_transaction
+
+    # forbid direct assignment in aasm_state column (in ActiveRecord)
+    attr_accessor :no_direct_assignment
+
+    attr_accessor :enum
+  end
+end

data/lib/aasm/dsl_helper.rb

@@ -0,0 +1,30 @@
+module DslHelper
+
+  class Proxy
+    attr_accessor :options
+
+    def initialize(options, valid_keys, source)
+      @valid_keys = valid_keys
+      @source = source
+
+      @options = options
+    end
+
+    def method_missing(name, *args, &block)
+      if @valid_keys.include?(name)
+        options[name] = Array(options[name])
+        options[name] << block if block
+        options[name] += Array(args)
+      else
+        @source.send name, *args, &block
+      end
+    end
+  end
+
+  def add_options_from_dsl(options, valid_keys, &block)
+    proxy = Proxy.new(options, valid_keys, self)
+    proxy.instance_eval(&block)
+    proxy.options
+  end
+
+end

data/lib/aasm/errors.rb

@@ -1,4 +1,5 @@
 module AASM
   class InvalidTransition < RuntimeError; end
   class UndefinedState < RuntimeError; end
+  class NoDirectAssignmentError < RuntimeError; end
 end

data/lib/aasm/event.rb

@@ -1,13 +1,18 @@
 module AASM
   class Event
+    include DslHelper
 
     attr_reader :name, :options
 
     def initialize(name, options = {}, &block)
       @name = name
       @transitions = []
-      @guards = Array(options[:guard] || options[:guards])
-      update(options, &block)
+      @guards = Array(options[:guard] || options[:guards] || options[:if])
+      @unless = Array(options[:unless]) #TODO: This could use a better name
+
+      # from aasm4
+      @options = options # QUESTION: .dup ?
+      add_options_from_dsl(@options, [:after, :before, :error, :success], &block) if block
     end
 
     # a neutered version of fire - it doesn't actually fire the event, it just
@@ -37,13 +42,9 @@ module AASM
       @transitions.select { |t| t.to == state }
     end
 
-    # TODO remove this method in v4.0.0
-    def all_transitions
-      warn "Event#all_transitions is deprecated and will be removed in version 4.0.0; please use Event#transitions instead!"
-      transitions
-    end
-
     def fire_callbacks(callback_name, record, *args)
+      # strip out the first element in args if it's a valid to_state
+      # #given where we're coming from, this condition implies args not empty
       invoke_callbacks(@options[callback_name], record, args)
     end
 
@@ -74,18 +75,14 @@ module AASM
 
     def attach_event_guards(definitions)
       unless @guards.empty?
-        given_guards = Array(definitions.delete(:guard) || definitions.delete(:guards))
-        definitions[:guards] = given_guards + @guards
+        given_guards = Array(definitions.delete(:guard) || definitions.delete(:guards) || definitions.delete(:if))
+        definitions[:guards] = @guards + given_guards # from aasm4
       end
-      definitions
-    end
-
-    def update(options = {}, &block)
-      @options = options
-      if block then
-        instance_eval(&block)
+      unless @unless.empty?
+        given_unless = Array(definitions.delete(:unless))
+        definitions[:unless] = given_unless + @unless
       end
-      self
+      definitions
     end
 
     # Execute if test == false, otherwise return true/false depending on whether it would fire
@@ -98,9 +95,18 @@ module AASM
         transitions = @transitions
       end
 
+      # If to_state is not nil it either contains a potential
+      # to_state or an arg
+      unless to_state == nil
+        if !to_state.respond_to?(:to_sym) || !transitions.map(&:to).flatten.include?(to_state.to_sym)
+          args.unshift(to_state)
+          to_state = nil
+        end
+      end
+
       transitions.each do |transition|
         next if to_state and !Array(transition.to).include?(to_state)
-        if transition.perform(obj, *args)
+        if transition.allowed?(obj, *args)
           if test
             result = true
           else
@@ -130,12 +136,5 @@ module AASM
       end
     end
 
-    [:after, :before, :error, :success].each do |callback_name|
-      define_method callback_name do |*args, &block|
-        options[callback_name] = Array(options[callback_name])
-        options[callback_name] << block if block
-        options[callback_name] += Array(args)
-      end
-    end
   end
 end # AASM