aasm 2.1.1 → 5.2.0

data/lib/aasm/rspec/allow_transition_to.rb

@@ -0,0 +1,26 @@
+RSpec::Matchers.define :allow_transition_to do |state|
+  match do |obj|
+    @state_machine_name ||= :default
+    obj.aasm(@state_machine_name).states({:permitted => true}, *@args).include?(state)
+  end
+
+  chain :on do |state_machine_name|
+    @state_machine_name = state_machine_name
+  end
+
+  chain :with do |*args|
+    @args = args
+  end
+
+  description do
+    "allow transition to #{expected} (on :#{@state_machine_name})"
+  end
+
+  failure_message do |obj|
+    "expected that the state :#{expected} would be reachable (on :#{@state_machine_name})"
+  end
+
+  failure_message_when_negated do |obj|
+    "expected that the state :#{expected} would not be reachable (on :#{@state_machine_name})"
+  end
+end

data/lib/aasm/rspec/have_state.rb

@@ -0,0 +1,22 @@
+RSpec::Matchers.define :have_state do |state|
+  match do |obj|
+    @state_machine_name ||= :default
+    obj.aasm(@state_machine_name).current_state == state.to_sym
+  end
+
+  chain :on do |state_machine_name|
+    @state_machine_name = state_machine_name
+  end
+
+  description do
+    "have state #{expected} (on :#{@state_machine_name})"
+  end
+
+  failure_message do |obj|
+    "expected that :#{obj.aasm(@state_machine_name).current_state} would be :#{expected} (on :#{@state_machine_name})"
+  end
+
+  failure_message_when_negated do |obj|
+    "expected that :#{obj.aasm(@state_machine_name).current_state} would not be :#{expected} (on :#{@state_machine_name})"
+  end
+end

data/lib/aasm/rspec/transition_from.rb

@@ -0,0 +1,36 @@
+RSpec::Matchers.define :transition_from do |from_state|
+  match do |obj|
+    @state_machine_name ||= :default
+    obj.aasm(@state_machine_name).current_state = from_state.to_sym
+    begin
+      obj.send(@event, *@args) && obj.aasm(@state_machine_name).current_state == @to_state.to_sym
+    rescue AASM::InvalidTransition
+      false
+    end
+  end
+
+  chain :on do |state_machine_name|
+    @state_machine_name = state_machine_name
+  end
+
+  chain :to do |state|
+    @to_state = state
+  end
+
+  chain :on_event do |event, *args|
+    @event = event
+    @args = args
+  end
+
+  description do
+    "transition state to :#{@to_state} from :#{expected} on event :#{@event}, with params: #{@args} (on :#{@state_machine_name})"
+  end
+
+  failure_message do |obj|
+    "expected that :#{obj.aasm(@state_machine_name).current_state} would be :#{@to_state} (on :#{@state_machine_name})"
+  end
+
+  failure_message_when_negated do |obj|
+    "expected that :#{obj.aasm(@state_machine_name).current_state} would not be :#{@to_state} (on :#{@state_machine_name})"
+  end
+end

data/lib/aasm/rspec.rb

@@ -0,0 +1,5 @@
+# relative-require all rspec files
+Dir[File.dirname(__FILE__) + '/rspec/*.rb'].each do |file|
+  require 'aasm/rspec/' + File.basename(file, File.extname(file))
+end
+

data/lib/aasm/state_machine.rb

@@ -1,35 +1,53 @@
-require 'ostruct'
-
 module AASM
   class StateMachine
-    def self.[](*args)
-      (@machines ||= {})[args]
-    end
-
-    def self.[]=(*args)
-      val = args.pop
-      (@machines ||= {})[args] = val
-    end
+    # the following four methods provide the storage of all state machines
 
-    attr_accessor :states, :events, :initial_state, :config
-    attr_reader :name
+    attr_accessor :states, :events, :initial_state, :config, :name, :global_callbacks
 
     def initialize(name)
-      @name   = name
       @initial_state = nil
       @states = []
       @events = {}
-      @config = OpenStruct.new
+      @global_callbacks = {}
+      @config = AASM::Configuration.new
+      @name = name
     end
 
-    def clone
-      klone = super
-      klone.states = states.clone
-      klone
+    # called internally by Ruby 1.9 after clone()
+    def initialize_copy(orig)
+      super
+      @states = orig.states.collect { |state| state.clone }
+      @events = {}
+      orig.events.each_pair { |name, event| @events[name] = event.clone }
+      @global_callbacks = @global_callbacks.dup
     end
 
-    def create_state(name, options)
-      @states << AASM::SupportingClasses::State.new(name, options) unless @states.include?(name)
+    def add_state(state_name, klass, options)
+      set_initial_state(state_name, options)
+
+      # allow reloading, extending or redefining a state
+      @states.delete(state_name) if @states.include?(state_name)
+
+      @states << AASM::Core::State.new(state_name, klass, self, options)
     end
-  end
-end
+
+    def add_event(name, options, &block)
+      @events[name] = AASM::Core::Event.new(name, self, options, &block)
+    end
+
+    def add_global_callbacks(name, *callbacks, &block)
+      @global_callbacks[name] ||= []
+      callbacks.each do |callback|
+        @global_callbacks[name] << callback unless @global_callbacks[name].include? callback
+      end
+      @global_callbacks[name] << block if block
+    end
+
+    private
+
+    def set_initial_state(name, options)
+      @initial_state = name if options[:initial] || !initial_state
+    end
+
+  end # StateMachine
+end # AASM

data/lib/aasm/state_machine_store.rb

@@ -0,0 +1,76 @@
+require 'concurrent'
+module AASM
+  class StateMachineStore
+    @stores = Concurrent::Map.new
+
+    class << self
+      def stores
+        @stores
+      end
+
+      # do not overwrite existing state machines, which could have been created by
+      # inheritance, see AASM::ClassMethods method inherited
+      def register(klass, overwrite = false, state_machine = nil)
+        raise "Cannot register #{klass}" unless klass.is_a?(Class)
+
+        case name = template = overwrite
+          when FalseClass then stores[klass.to_s] ||= new
+          when TrueClass then stores[klass.to_s] = new
+          when Class then stores[klass.to_s] = stores[template.to_s].clone
+          when Symbol then stores[klass.to_s].register(name, state_machine)
+          when String then stores[klass.to_s].register(name, state_machine)
+          else raise "Don't know what to do with #{overwrite}"
+        end
+      end
+      alias_method :[]=, :register
+
+      def fetch(klass, fallback = nil)
+        stores[klass.to_s] || fallback && begin
+          match = klass.ancestors.find do |ancestor|
+            ancestor.include? AASM and stores[ancestor.to_s]
+          end
+
+          stores[match.to_s]
+        end
+      end
+      alias_method :[], :fetch
+
+      def unregister(klass)
+        stores.delete(klass.to_s)
+      end
+    end
+
+    def initialize
+      @machines = Concurrent::Map.new
+    end
+
+    def clone
+      StateMachineStore.new.tap do |store|
+        @machines.each_pair do |name, machine|
+          store.register(name, machine.clone)
+        end
+      end
+    end
+
+    def machine(name)
+      @machines[name.to_s]
+    end
+    alias_method :[], :machine
+
+    def machine_names
+      @machines.keys
+    end
+    alias_method :keys, :machine_names
+
+    def register(name, machine, force = false)
+      raise "Cannot use #{name.inspect} for machine name" unless name.is_a?(Symbol) or name.is_a?(String)
+      raise "Cannot use #{machine.inspect} as a machine" unless machine.is_a?(AASM::StateMachine)
+
+      if force
+        @machines[name.to_s] = machine
+      else
+        @machines[name.to_s] ||= machine
+      end
+    end
+  end
+end

data/lib/aasm/version.rb

@@ -0,0 +1,3 @@
+module AASM
+  VERSION = "5.2.0"
+end

data/lib/aasm.rb

@@ -1 +1,21 @@
-require File.join(File.dirname(__FILE__), 'aasm', 'aasm')
+require 'aasm/version'
+require 'aasm/errors'
+require 'aasm/configuration'
+require 'aasm/base'
+require 'aasm/dsl_helper'
+require 'aasm/instance_base'
+require 'aasm/core/transition'
+require 'aasm/core/event'
+require 'aasm/core/state'
+require 'aasm/core/invoker'
+require 'aasm/core/invokers/base_invoker'
+require 'aasm/core/invokers/class_invoker'
+require 'aasm/core/invokers/literal_invoker'
+require 'aasm/core/invokers/proc_invoker'
+require 'aasm/localizer'
+require 'aasm/state_machine_store'
+require 'aasm/state_machine'
+require 'aasm/persistence'
+require 'aasm/persistence/base'
+require 'aasm/persistence/plain_persistence'
+require 'aasm/aasm'

data/lib/generators/aasm/aasm_generator.rb

@@ -0,0 +1,16 @@
+require 'rails/generators/named_base'
+
+module AASM
+  module Generators
+    class AASMGenerator < Rails::Generators::NamedBase
+      namespace "aasm"
+      argument :column_name, type: :string, default: 'aasm_state'
+
+      desc "Generates a model with the given NAME (if one does not exist) with aasm " <<
+      "block and migration to add aasm_state column."
+
+      hook_for :orm
+
+    end
+  end
+end

data/lib/generators/aasm/orm_helpers.rb

@@ -0,0 +1,41 @@
+module AASM
+  module Generators
+    module OrmHelpers
+
+      def model_contents
+        if column_name == 'aasm_state'
+<<RUBY
+  include AASM
+
+  aasm do
+  end
+RUBY
+        else
+<<RUBY
+  include AASM
+
+  aasm :column => '#{column_name}' do
+  end
+RUBY
+        end
+      end
+
+      private
+
+      def column_exists?
+        table_name.singularize.humanize.constantize.column_names.include?(column_name.to_s)
+      rescue NameError
+        false
+      end
+
+      def model_exists?
+        File.exists?(File.join(destination_root, model_path))
+      end
+
+      def model_path
+        @model_path ||= File.join("app", "models", "#{file_path}.rb")
+      end
+
+    end
+  end
+end

data/lib/generators/active_record/aasm_generator.rb

@@ -0,0 +1,40 @@
+require 'rails/generators/active_record'
+require 'generators/aasm/orm_helpers'
+
+module ActiveRecord
+  module Generators
+    class AASMGenerator < ActiveRecord::Generators::Base
+      include AASM::Generators::OrmHelpers
+      namespace "active_record:aasm"
+      argument :column_name, type: :string, default: 'aasm_state'
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def copy_aasm_migration
+        if column_exists?
+          puts "Both model and column exists"
+        elsif model_exists?
+          migration_template "migration_existing.rb", "db/migrate/add_#{column_name}_to_#{table_name}.rb"
+        else
+          migration_template "migration.rb", "db/migrate/aasm_create_#{table_name}.rb"
+        end
+      end
+
+      def generate_model
+        invoke "active_record:model", [name], migration: false unless model_exists?
+      end
+
+      def inject_aasm_content
+        content = model_contents
+
+        class_path = if namespaced?
+                       class_name.to_s.split("::")
+                     else
+                       [class_name]
+                     end
+        inject_into_class(model_path, class_path.last, content) if model_exists?
+      end
+
+    end
+  end
+end

data/lib/generators/active_record/templates/migration.rb

@@ -0,0 +1,8 @@
+class AASMCreate<%= table_name.camelize %> < ActiveRecord::Migration[<%=  ActiveRecord::VERSION::STRING.to_f %>]
+  def change
+    create_table(:<%= table_name %>) do |t|
+      t.string :<%= column_name %>
+      t.timestamps null: false 
+    end
+  end
+end

data/lib/generators/active_record/templates/migration_existing.rb

@@ -0,0 +1,5 @@
+class Add<%= column_name.camelize %>To<%= table_name.camelize %> < ActiveRecord::Migration[<%=  ActiveRecord::VERSION::STRING.to_f %>]
+  def change
+    add_column :<%= table_name %>, :<%= column_name %>, :string
+  end
+end

data/lib/generators/mongoid/aasm_generator.rb

@@ -0,0 +1,28 @@
+require 'rails/generators/named_base'
+require 'generators/aasm/orm_helpers'
+
+module Mongoid
+  module Generators
+    class AASMGenerator < Rails::Generators::NamedBase
+      include AASM::Generators::OrmHelpers
+      namespace "mongoid:aasm"
+      argument :column_name, type: :string, default: 'aasm_state'
+
+      def generate_model
+        invoke "mongoid:model", [name] unless model_exists?
+      end
+
+      def inject_aasm_content
+        inject_into_file model_path, model_contents, after: "include Mongoid::Document\n" if model_exists?
+      end
+
+      def inject_field_types
+        inject_into_file model_path, migration_data, after: "include Mongoid::Document\n" if model_exists?
+      end
+
+      def migration_data
+        "  field :#{column_name}"
+      end
+    end
+  end
+end

data/lib/generators/nobrainer/aasm_generator.rb

@@ -0,0 +1,28 @@
+require 'rails/generators/named_base'
+require 'generators/aasm/orm_helpers'
+
+module NoBrainer
+  module Generators
+    class AASMGenerator < Rails::Generators::NamedBase
+      include AASM::Generators::OrmHelpers
+      namespace 'nobrainer:aasm'
+      argument :column_name, type: :string, default: 'aasm_state'
+
+      def generate_model
+        invoke 'nobrainer:model', [name] unless model_exists?
+      end
+
+      def inject_aasm_content
+        inject_into_file model_path, model_contents, after: "include NoBrainer::Document::Timestamps\n" if model_exists?
+      end
+
+      def inject_field_types
+        inject_into_file model_path, migration_data, after: "include NoBrainer::Document::Timestamps\n" if model_exists?
+      end
+
+      def migration_data
+        "  field :#{column_name}"
+      end
+    end
+  end
+end

data/lib/motion-aasm.rb

@@ -0,0 +1,37 @@
+unless defined?(Motion::Project::App)
+  raise "This must be required from within a RubyMotion Rakefile"
+end
+
+file_dependencies = {
+  'aasm/aasm.rb' => ['aasm/persistence.rb'],
+  'aasm/persistence.rb' => ['aasm/persistence/plain_persistence.rb', 'aasm/persistence/core_data_query_persistence.rb'],
+  'aasm/persistence/base.rb' => ['aasm/base.rb'],
+  'aasm/persistence/core_data_query_persistence.rb' => ['aasm/persistence/base.rb']
+}
+
+exclude_files = [
+  'aasm/rspec.*',
+  'aasm/minitest.*',
+  'aasm/minitest_spec.*',
+  'aasm/persistence/active_record_persistence.rb',
+  'aasm/persistence/dynamoid_persistence.rb',
+  'aasm/persistence/mongoid_persistence.rb',
+  'aasm/persistence/no_brainer_persistence.rb',
+  'aasm/persistence/sequel_persistence.rb',
+  'aasm/persistence/redis_persistence.rb'
+]
+
+Motion::Project::App.setup do |app|
+  parent = File.expand_path File.dirname(__FILE__)
+
+  app.files.unshift Dir.glob(File.join(parent, "aasm/**/*.rb")).reject { |file| exclude_files.any? { |exclude| file.match(exclude) } }
+
+  app.files_dependencies file_dependencies.inject({}, &->(file_dependencies, (file, *dependencies)) do
+    file = File.join(parent, file)
+    dependencies = dependencies.flatten(1).map do |dependency|
+      File.join(parent, dependency)
+    end
+
+    file_dependencies.merge({ file => dependencies })
+  end)
+end

data/spec/database.rb

@@ -0,0 +1,57 @@
+ActiveRecord::Migration.suppress_messages do
+  %w{gates multiple_gates readers writers transients simples no_scopes multiple_no_scopes no_direct_assignments multiple_no_direct_assignments thieves multiple_thieves localizer_test_models persisted_states provided_and_persisted_states with_enums with_enum_without_columns multiple_with_enum_without_columns with_true_enums with_false_enums false_states multiple_with_enums multiple_with_true_enums multiple_with_false_enums multiple_false_states readme_jobs}.each do |table_name|
+    ActiveRecord::Migration.create_table table_name, :force => true do |t|
+      t.string "aasm_state"
+    end
+  end
+
+  %w(simple_new_dsls multiple_simple_new_dsls implemented_abstract_class_dsls users multiple_namespaceds).each do |table_name|
+    ActiveRecord::Migration.create_table table_name, :force => true do |t|
+      t.string "status"
+    end
+  end
+
+  ActiveRecord::Migration.create_table "complex_active_record_examples", :force => true do |t|
+    t.string "left"
+    t.string "right"
+  end
+
+  ActiveRecord::Migration.create_table "works", :force => true do |t|
+    t.string "status"
+  end
+
+  %w(validators multiple_validators workers invalid_persistors multiple_invalid_persistors silent_persistors multiple_silent_persistors active_record_callbacks).each do |table_name|
+    ActiveRecord::Migration.create_table table_name, :force => true do |t|
+      t.string "name"
+      t.string "status"
+    end
+  end
+
+  %w(transactors no_lock_transactors lock_transactors lock_no_wait_transactors no_transactors multiple_transactors).each do |table_name|
+    ActiveRecord::Migration.create_table table_name, :force => true do |t|
+      t.string "name"
+      t.string "status"
+      t.integer "worker_id"
+    end
+  end
+
+  ActiveRecord::Migration.create_table "fathers", :force => true do |t|
+    t.string "aasm_state"
+    t.string "type"
+  end
+
+  ActiveRecord::Migration.create_table "basic_active_record_two_state_machines_examples", :force => true do |t|
+    t.string "search"
+    t.string "sync"
+  end
+
+  ActiveRecord::Migration.create_table "instance_level_skip_validation_examples", :force => true do |t|
+    t.string "state"
+    t.string "some_string"
+  end
+
+  ActiveRecord::Migration.create_table "timestamp_examples", :force => true do |t|
+    t.string "aasm_state"
+    t.datetime "opened_at"
+  end
+end

data/spec/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: spec/aasm.sqlite3.db

data/spec/en.yml

@@ -0,0 +1,9 @@
+en:
+  activerecord:
+    events:
+      localizer_test_model:
+        close: "Let's close it!"
+
+    errors:
+      messages:
+        record_invalid: "Invalid record"

data/spec/generators/active_record_generator_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+if defined?(ActiveRecord)
+  require 'generator_spec'
+  require 'generators/active_record/aasm_generator'
+
+  describe ActiveRecord::Generators::AASMGenerator, type: :generator do
+    destination File.expand_path("../../../tmp", __FILE__)
+
+    before(:all) do
+      prepare_destination
+    end
+
+    it "creates model with aasm block for default column_name" do
+      run_generator %w(user)
+      assert_file "app/models/user.rb", /include AASM\n\n  aasm do\n  end\n/
+    end
+
+    it "creates model with aasm block for custom column_name" do
+      run_generator %w(user state)
+      assert_file "app/models/user.rb", /aasm :column => 'state' do\n  end\n/
+    end
+
+    it "creates model with aasm block for namespaced model" do
+      run_generator %w(Admin::User state)
+      assert_file "app/models/admin/user.rb", /aasm :column => 'state' do\n  end\n/
+    end
+
+    it "creates migration for model with aasm_column" do
+      run_generator %w(post)
+      assert_migration "db/migrate/aasm_create_posts.rb", /create_table(:posts) do |t|\n  t.string :aasm_state\n/
+    end
+
+    it "add aasm_column in existing model" do
+      run_generator %w(job)
+      assert_file "app/models/job.rb"
+      run_generator %w(job)
+      assert_migration "db/migrate/add_aasm_state_to_jobs.rb"
+    end
+
+    it "add custom aasm_column in existing model" do
+      run_generator %w(job state)
+      assert_migration "db/migrate/add_state_to_jobs.rb"
+    end
+
+    it "dont add column if column is already exists" do
+      require 'models/active_record/work.rb'
+      load_schema
+      run_generator %w(work status)
+      assert_no_migration "db/migrate/add_status_to_jobs.rb"
+    end
+  end
+end

data/spec/generators/mongoid_generator_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+if defined?(Mongoid::Document)
+  require 'generator_spec'
+  require 'generators/mongoid/aasm_generator'
+
+  describe Mongoid::Generators::AASMGenerator, type: :generator do
+    destination File.expand_path("../../../tmp", __FILE__)
+
+    before(:all) do
+      prepare_destination
+    end
+
+    it "creates model with aasm block for default column_name" do
+      run_generator %w(user)
+      assert_file "app/models/user.rb", /include AASM\n\n  aasm do\n  end\n/
+    end
+
+    it "creates model with aasm block for custom column_name" do
+      run_generator %w(user state)
+      assert_file "app/models/user.rb", /aasm :column => 'state' do\n  end\n/
+    end
+
+    it "creates model with aasm block for namespaced model" do
+      run_generator %w(Admin::User state)
+      assert_file "app/models/admin/user.rb", /aasm :column => 'state' do\n  end\n/
+    end
+
+  end
+
+end

data/spec/generators/no_brainer_generator_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+if defined?(NoBrainer::Document)
+  require 'generator_spec'
+  require 'generators/nobrainer/aasm_generator'
+
+  describe NoBrainer::Generators::AASMGenerator, type: :generator do
+    destination File.expand_path('../../../tmp', __FILE__)
+
+    before(:all) do
+      prepare_destination
+    end
+
+    it 'creates model with aasm block for default column_name' do
+      run_generator %w[user]
+      assert_file 'app/models/user.rb', /include AASM\n\n  aasm do\n  end\n/
+    end
+
+    it 'creates model with aasm block for custom column_name' do
+      run_generator %w[user state]
+      assert_file 'app/models/user.rb', /aasm :column => 'state' do\n  end\n/
+    end
+
+    it 'creates model with aasm block for namespaced model' do
+      run_generator %w[Admin::User state]
+      assert_file 'app/models/admin/user.rb', /aasm :column => 'state' do\n  end\n/
+    end
+  end
+end