aasm 4.9.0 → 4.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4a393ed849111b8beee789a849433679c36f940
-  data.tar.gz: 905f16c76e62d5481bcfe55f4bb935039b0c7726
+  metadata.gz: 0a36f037200d0d9577fe0164fdd7a66e23db9156
+  data.tar.gz: 253250812a0f774df4e1d0c5111bf6c273ccd76d
 SHA512:
-  metadata.gz: 1e64e9fffd9c560a166ab728105d3891ca9a6a8784c27b70f83d9fd91ed7ccde1c839662f8e7e099ef4128db6bc91a690a30c8fbb3c0f83e4bfeba7d2c0ad67f
-  data.tar.gz: 574cafabbe8b20e1bf9db7ef87ff10c358dd814fd3bc86fc2f843824c9be8deb4ad645c9a0273a7ecf861bfb6136b519476f1b749a0d3706e798b24a3dd92da8
+  metadata.gz: b41ce1fa467ee74ec16d1e3260506adfbda581d13078f2548120e4322c6a1582fb93aae9c84b451e834cd621ce115a3bb6f75c57a7b09be598fc93d2a348f919
+  data.tar.gz: c43910a1666f9011dfe6b604f6626931c821f5a2e5d9f641194e1837a5eb0b3a000f5d85cfca24af60635dec36074f3df9c83bbcd552b4e7da0da6b00d323e9d

data/.travis.yml

@@ -3,18 +3,18 @@ language: ruby
 cache: bundler
 
 rvm:
-  # - 1.8.7
-  # - 1.9.2
   - 1.9.3
   - 2.0.0
   - 2.1
   - 2.2
-  # - jruby-18mode # JRuby in 1.8 mode
+  - 2.3
   - jruby-1.7 # JRuby in 1.9 mode
   - jruby-9.0.4.0
   - rbx-2.5.8
 
-services: mongodb
+services:
+  - mongodb
+  - redis-server
 
 gemfile:
   - gemfiles/rails_3.2_stable.gemfile
@@ -35,8 +35,13 @@ matrix:
   allow_failures:
     - rvm: rbx-2.2.1
     - rvm: jruby-1.7
+    - rvm: 2.3
   exclude:
     - rvm: 1.9.3
       gemfile: gemfiles/rails_4.1.gemfile
+    - rvm: 2.2
+      gemfile: gemfiles/rails_3.2_stable.gemfile
+    - rvm: 2.3
+      gemfile: gemfiles/rails_3.2_stable.gemfile
     - rvm: jruby-19mode
       gemfile: gemfiles/rails_4.1.gemfile

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # CHANGELOG
 
+## 4.10.0
+
+ * fix: some issues with RubyMotion (see [issue #320](https://github.com/aasm/aasm/pull/320) and [issue #343](https://github.com/aasm/aasm/pull/343) for details, thanks to [@Infotaku](https://github.com/Infotaku))
+ * fix: transitions now work in dup'ed copies (see [issue #325](https://github.com/aasm/aasm/pull/325) which fixes [issue #273](https://github.com/aasm/aasm/pull/273) for details, thanks to [@lingceng](https://github.com/lingceng))
+ * fix: allow skipping the `aasm_ensure_initial_state` callback (see [issue #326](https://github.com/aasm/aasm/pull/326) for details, thanks to [@sineed](https://github.com/sineed))
+ * fix: has_many association helper works again for Mongoid (see [issue #333](https://github.com/aasm/aasm/pull/333) which fixes [issue #332](https://github.com/aasm/aasm/pull/332) for details, thanks to [@anilmaurya](https://github.com/anilmaurya))
+ * improve performance / refactor: load and run only code which is needed (see [issue #336](https://github.com/aasm/aasm/pull/336) for details, thanks to [@csmuc](https://github.com/csmuc))
+ * improve: warn when overriding an existing method (see [issue #340](https://github.com/aasm/aasm/pull/340) which fixes [issue #335](https://github.com/aasm/aasm/pull/335) for details, thanks to [@pirj](https://github.com/pirj))
+ * fix: correct error message (by not evaluating the current state lazily) (see [issue #341](https://github.com/aasm/aasm/pull/341) which fixes [issue #312](https://github.com/aasm/aasm/pull/312) for details, thanks to [@pirj](https://github.com/pirj))
+ * addition: support for Redis as persistence layer (see [issue #190](https://github.com/aasm/aasm/pull/190) for details, thanks to [@javajax](https://github.com/javajax))
+ * addition: support transition `:success` callbacks (see [issue #239](https://github.com/aasm/aasm/pull/239) which fixes [issue #236](https://github.com/aasm/aasm/pull/236) for details, thanks to [@brega](https://github.com/brega))
+ * addition: support for namespacing methods and state names (see [issue #259](https://github.com/aasm/aasm/pull/259) for details, thanks to [@allspiritseve](https://github.com/allspiritseve))
+ * addition: support for defining multiple states in one line (see [issue #288](https://github.com/aasm/aasm/pull/288) which fixes [issue #146](https://github.com/aasm/aasm/pull/146) for details, thanks to [@HParker](https://github.com/HParker))
+ * fix: uninitialised constant when running Rails generator (see [issue #339](https://github.com/aasm/aasm/pull/339) for details, thanks to [@long-long-float](https://github.com/long-long-float))
+
 ## 4.9.0
 
  * add support for callback classes (`after` only) (see [issue #316](https://github.com/aasm/aasm/pull/316) for details, thanks to [@mlr](https://github.com/mlr))

data/Gemfile

@@ -17,4 +17,7 @@ gem 'sequel'
 # gem 'mongo_mapper', '~> 0.13'
 # gem 'bson_ext',                          :platforms => :ruby
 
+# uncomment if you want to run specs for Redis persistence
+# gem "redis-objects"
+
 gemspec

data/README.md

@@ -28,8 +28,7 @@ class Job
 
   aasm do
     state :sleeping, :initial => true
-    state :running
-    state :cleaning
+    state :running, :cleaning
 
     event :run do
       transitions :from => :sleeping, :to => :running
@@ -97,6 +96,7 @@ class Job
   aasm do
     state :sleeping, :initial => true, :before_enter => :do_something
     state :running
+    state :finished
 
     after_all_transitions :log_status_change
 
@@ -149,7 +149,7 @@ In this case `do_something` is called before actually entering the state `sleepi
 while `notify_somebody` is called after the transition `run` (from `sleeping` to `running`)
 is finished.
 
-AASM will also initialize `LogRunTime` and run the `call` method for you after the transition from `runnung` to `finished` in the example above. You can pass arguments to the class by defining an initialize method on it, like this:
+AASM will also initialize `LogRunTime` and run the `call` method for you after the transition from `running` to `finished` in the example above. You can pass arguments to the class by defining an initialize method on it, like this:
 
 ```
 class LogRunTime
@@ -158,7 +158,7 @@ class LogRunTime
   def initialize(job, args = {})
     @job = job
   end
-  
+
   def call
     log "Job was running for #{@job.run_time} seconds"
   end
@@ -180,7 +180,8 @@ begin
   new_state       before_enter
   new_state       enter
   ...update state...
-  event         success             # if persist successful
+  transition      success             # if persist successful
+  event           success             # if persist successful
   old_state       after_exit
   new_state       after_enter
   event           after
@@ -404,7 +405,7 @@ simple.aasm(:work).current
 
 _AASM_ doesn't prohibit to define the same event in more than one state machine. The
 latest definition "wins" and overrides previous definitions. Nonetheless, a warning is issued:
-`SimpleMultipleExample: The aasm event name run is already used!`.
+`SimpleMultipleExample: overriding method 'run'!`.
 
 All _AASM_ class- and instance-level `aasm` methods accept a state machine selector.
 So, for example, to use inspection on a class level, you have to use
@@ -423,7 +424,7 @@ AASM allows you to easily extend `AASM::Base` for your own application purposes.
 
 Let's suppose we have common logic across many AASM models. We can embody this logic in a sub-class of `AASM::Base`.
 
-```
+```ruby
 class CustomAASMBase < AASM::Base
   # A custom transiton that we want available across many AASM models.
   def count_transitions!
@@ -460,7 +461,7 @@ end
 
 When we declare our model that has an AASM state machine, we simply declare the AASM block with a `:with` key to our own class.
 
-```
+```ruby
 class SimpleCustomExample
   include AASM
 
@@ -662,6 +663,21 @@ class Job
 end
 ```
 
+### Redis
+
+AASM also supports persistence in Redis.
+Make sure to include Redis::Objects before you include AASM.
+
+```ruby
+class User
+  include Redis::Objects
+  include AASM
+
+  aasm do
+  end
+end
+```
+
 ### Automatic Scopes
 
 AASM will automatically create scope methods for each state in the model.
@@ -882,11 +898,11 @@ Job.aasm.states_for_select
 
 ### RubyMotion support
 
-To use AASM with a RubyMotion project, use it with the [motion-bundler](https://github.com/archan937/motion-bundler) gem.
+Now supports [CodeDataQuery](https://github.com/infinitered/cdq.git) !
+However I'm still in the process of submitting my compatibility updates to their repository.
+In the meantime you can use [my fork](https://github.com/Infotaku/cdq.git), there may still be some minor issues but I intend to extensively use it myself, so fixes should come fast.
 
 Warnings:
-- Due to the way key-value observation (KVO) works in iOS,
-you currently CANNOT use AASM with an object you are observing. (Yes.. that's pretty sad).
 - Due to RubyMotion Proc's lack of 'source_location' method, it may be harder
 to find out the origin of a "cannot transition from" error. I would recommend using
 the 'instance method symbol / string' way whenever possible when defining guardians and callbacks.

data/gemfiles/rails_4.0.gemfile

@@ -10,5 +10,6 @@ gem 'mongoid', '~>4.0' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.
 gem 'sequel'
 gem 'dynamoid', '~> 1',                 :platforms => :ruby
 gem 'aws-sdk', '~>2',                   :platforms => :ruby
+gem "redis-objects"
 
 gemspec :path => "../"

data/gemfiles/rails_4.1.gemfile

@@ -10,5 +10,6 @@ gem 'mongoid', '~>4.0' if Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version.
 gem 'sequel'
 gem 'dynamoid', '~> 1',                 :platforms => :ruby
 gem 'aws-sdk', '~>2',                   :platforms => :ruby
+gem "redis-objects"
 
 gemspec :path => "../"

data/gemfiles/rails_4.2_mongo_mapper.gemfile

@@ -12,5 +12,6 @@ gem 'mongo_mapper'
 gem 'bson_ext',                          :platforms => :ruby
 gem 'dynamoid', '~> 1',                  :platforms => :ruby
 gem 'aws-sdk', '~>2',                    :platforms => :ruby
+gem "redis-objects"
 
 gemspec :path => "../"

data/lib/aasm.rb

@@ -10,7 +10,9 @@ require 'aasm/core/transition'
 require 'aasm/core/event'
 require 'aasm/core/state'
 require 'aasm/localizer'
+require 'aasm/state_machine_store'
 require 'aasm/state_machine'
 require 'aasm/persistence'
-require 'aasm/persistence/plain_persistence' # RubyMotion support
+require 'aasm/persistence/base'
+require 'aasm/persistence/plain_persistence'
 require 'aasm/aasm'

data/lib/aasm/aasm.rb

@@ -8,7 +8,7 @@ module AASM
 
     # do not overwrite existing state machines, which could have been created by
     # inheritance, see class method inherited
-    AASM::StateMachine[base] ||= {}
+    AASM::StateMachineStore.register(base)
 
     AASM::Persistence.load_persistence(base)
     super
@@ -17,10 +17,8 @@ module AASM
   module ClassMethods
     # make sure inheritance (aka subclassing) works with AASM
     def inherited(base)
-      AASM::StateMachine[base] = {}
-      AASM::StateMachine[self].keys.each do |state_machine_name|
-        AASM::StateMachine[base][state_machine_name] = AASM::StateMachine[self][state_machine_name].clone
-      end
+      AASM::StateMachineStore.register(base, self)
+
       super
     end
 
@@ -36,7 +34,7 @@ module AASM
         options = args[0] || {}
       end
 
-      AASM::StateMachine[self][state_machine_name] ||= AASM::StateMachine.new(state_machine_name)
+      AASM::StateMachineStore.fetch(self, true).register(state_machine_name, AASM::StateMachine.new(state_machine_name))
 
       # use a default despite the DSL configuration default.
       # this is because configuration hasn't been setup for the AASM class but we are accessing a DSL option already for the class.
@@ -55,7 +53,7 @@ module AASM
         @aasm[state_machine_name] = aasm_klass.new(
           self,
           state_machine_name,
-          AASM::StateMachine[self][state_machine_name],
+          AASM::StateMachineStore.fetch(self, true).machine(state_machine_name),
           options
         )
       end
@@ -66,13 +64,18 @@ module AASM
 
   # this is the entry point for all instance-level access to AASM
   def aasm(name=:default)
-    unless AASM::StateMachine[self.class][name.to_sym]
+    unless AASM::StateMachineStore.fetch(self.class, true).machine(name)
       raise AASM::UnknownStateMachineError.new("There is no state machine with the name '#{name}' defined in #{self.class.name}!")
     end
     @aasm ||= {}
     @aasm[name.to_sym] ||= AASM::InstanceBase.new(self, name.to_sym)
   end
 
+  def initialize_dup(other)
+    @aasm = {}
+    super
+  end
+
 private
 
   # Takes args and a from state and removes the first
@@ -147,6 +150,7 @@ private
       persist_successful = aasm(state_machine_name).set_current_state_with_persistence(new_state_name)
       if persist_successful
         yield if block_given?
+        event.fire_transition_callbacks(self, *process_args(event, old_state.name, *args))
         event.fire_callbacks(:success, self)
       end
     else
@@ -183,7 +187,7 @@ private
       self.aasm_event_failed(event_name, old_state.name)
     end
 
-    if AASM::StateMachine[self.class][state_machine_name].config.whiny_transitions
+    if AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.whiny_transitions
       raise AASM::InvalidTransition.new(self, event_name, state_machine_name, failures)
     else
       false

data/lib/aasm/base.rb

@@ -1,8 +1,7 @@
 module AASM
   class Base
 
-    attr_reader :klass,
-      :state_machine
+    attr_reader :klass, :state_machine
 
     def initialize(klass, name, state_machine, options={}, &block)
       @klass = klass
@@ -38,6 +37,9 @@ module AASM
 
       configure :enum, nil
 
+      # Set to true to namespace reader methods and constants
+      configure :namespace, false
+
       # make sure to raise an error if no_direct_assignment is enabled
       # and attribute is directly assigned though
       aasm_name = @name
@@ -71,20 +73,29 @@ module AASM
     end
 
     # define a state
-    def state(name, options={})
-      @state_machine.add_state(name, klass, options)
-
-      if klass.instance_methods.include?("#{name}?")
-        warn "#{klass.name}: The aasm state name #{name} is already used!"
-      end
-
-      aasm_name = @name
-      klass.send :define_method, "#{name}?", ->() do
-        aasm(:"#{aasm_name}").current_state == :"#{name}"
-      end
+    # args
+    # [0] state
+    # [1] options (or nil)
+    # or
+    # [0] state
+    # [1..] state
+    def state(*args)
+      names, options = interpret_state_args(args)
+      names.each do |name|
+        @state_machine.add_state(name, klass, options)
+
+        aasm_name = @name.to_sym
+        state = name.to_sym
+
+        method_name = namespace? ? "#{namespace}_#{name}" : name
+        safely_define_method klass, "#{method_name}?", -> do
+          aasm(aasm_name).current_state == state
+        end
 
-      unless klass.const_defined?("STATE_#{name.upcase}")
-        klass.const_set("STATE_#{name.upcase}", name)
+        const_name = namespace? ? "STATE_#{namespace.upcase}_#{name.upcase}" : "STATE_#{name.upcase}"
+        unless klass.const_defined?(const_name)
+          klass.const_set(const_name, name)
+        end
       end
     end
 
@@ -92,27 +103,24 @@ module AASM
     def event(name, options={}, &block)
       @state_machine.add_event(name, options, &block)
 
-      if klass.instance_methods.include?("may_#{name}?".to_sym)
-        warn "#{klass.name}: The aasm event name #{name} is already used!"
-      end
+      aasm_name = @name.to_sym
+      event = name.to_sym
 
       # an addition over standard aasm so that, before firing an event, you can ask
       # may_event? and get back a boolean that tells you whether the guard method
       # on the transition will let this happen.
-      aasm_name = @name
-
-      klass.send :define_method, "may_#{name}?", ->(*args) do
-        aasm(:"#{aasm_name}").may_fire_event?(:"#{name}", *args)
+      safely_define_method klass, "may_#{name}?", ->(*args) do
+        aasm(aasm_name).may_fire_event?(event, *args)
       end
 
-      klass.send :define_method, "#{name}!", ->(*args, &block) do
-        aasm(:"#{aasm_name}").current_event = :"#{name}!"
-        aasm_fire_event(:"#{aasm_name}", :"#{name}", {:persist => true}, *args, &block)
+      safely_define_method klass, "#{name}!", ->(*args, &block) do
+        aasm(aasm_name).current_event = :"#{name}!"
+        aasm_fire_event(aasm_name, event, {:persist => true}, *args, &block)
       end
 
-      klass.send :define_method, "#{name}", ->(*args, &block) do
-        aasm(:"#{aasm_name}").current_event = :"#{name}"
-        aasm_fire_event(:"#{aasm_name}", :"#{name}", {:persist => false}, *args, &block)
+      safely_define_method klass, name, ->(*args, &block) do
+        aasm(aasm_name).current_event = event
+        aasm_fire_event(aasm_name, event, {:persist => false}, *args, &block)
       end
     end
 
@@ -165,6 +173,7 @@ module AASM
       if options[:transition]
         @state_machine.events[options[:transition]].transitions_to_state(state).flatten.map(&:from).flatten
       else
+
         events.map {|e| e.transitions_to_state(state)}.flatten.map(&:from).flatten
       end
     end
@@ -183,5 +192,35 @@ module AASM
       end
     end
 
+    def safely_define_method(klass, method_name, method_definition)
+      if klass.instance_methods.include?(method_name.to_sym)
+        warn "#{klass.name}: overriding method '#{method_name}'!"
+      end
+
+      klass.send(:define_method, method_name, method_definition)
+    end
+
+    def namespace?
+      !!@state_machine.config.namespace
+    end
+
+    def namespace
+      if @state_machine.config.namespace == true
+        @name
+      else
+        @state_machine.config.namespace
+      end
+    end
+
+    def interpret_state_args(args)
+      if args.last.is_a?(Hash) && args.size == 2
+        [[args.first], args.last]
+      elsif args.size > 0
+        [args, {}]
+      else
+        raise "count not parse states: #{args}"
+      end
+    end
+
   end
 end

data/lib/aasm/configuration.rb

@@ -25,5 +25,8 @@ module AASM
     attr_accessor :with_klass
 
     attr_accessor :enum
+
+    # namespace reader methods and constants
+    attr_accessor :namespace
   end
 end