aasm 4.11.1 → 5.2.0

data/lib/aasm/persistence/mongo_mapper_persistence.rb

@@ -1,163 +0,0 @@
-module AASM
-  module Persistence
-    module MongoMapperPersistence
-      # This method:
-      #
-      # * extends the model with ClassMethods
-      # * includes InstanceMethods
-      #
-      # Adds
-      #
-      #   before_validation :aasm_ensure_initial_state, :on => :create
-      #
-      # As a result, it doesn't matter when you define your methods - the following 2 are equivalent
-      #
-      #   class Foo
-      #     include MongoMapper::Document
-      #     def aasm_write_state(state)
-      #       "bar"
-      #     end
-      #     include AASM
-      #   end
-      #
-      #   class Foo < ActiveRecord::Base
-      #     include MongoMapper::Document
-      #     include AASM
-      #     def aasm_write_state(state)
-      #       "bar"
-      #     end
-      #   end
-      #
-      def self.included(base)
-        base.send(:include, AASM::Persistence::Base)
-        base.send(:include, AASM::Persistence::MongoMapperPersistence::InstanceMethods)
-        base.extend AASM::Persistence::MongoMapperPersistence::ClassMethods
-
-        base.before_create :aasm_ensure_initial_state
-
-        # ensure state is in the list of states
-        base.validate :aasm_validate_states
-      end
-
-      module ClassMethods
-        def aasm_create_scope(state_machine_name, scope_name)
-          conditions = { aasm(state_machine_name).attribute_name.to_sym => scope_name.to_s }
-          scope(scope_name, lambda { where(conditions) })
-        end
-      end
-
-      module InstanceMethods
-
-        # Writes <tt>state</tt> to the state column and persists it to the database
-        #
-        #   foo = Foo.find(1)
-        #   foo.aasm.current_state # => :opened
-        #   foo.close!
-        #   foo.aasm.current_state # => :closed
-        #   Foo.find(1).aasm.current_state # => :closed
-        #
-        # NOTE: intended to be called from an event
-        def aasm_write_state(state, name=:default)
-          old_value = read_attribute(self.class.aasm(name).attribute_name)
-          write_attribute(self.class.aasm(name).attribute_name, state)
-
-          success = if aasm_skipping_validations(name)
-            value = aasm_raw_attribute_value(state, name)
-            self.class.where(self.class.primary_key => self.id).update_all(self.class.aasm(name).attribute_name => value) == 1
-          else
-            self.save
-          end
-          unless success
-            write_attribute(self.class.aasm(name).attribute_name, old_value)
-            return false
-          end
-
-          true
-        end
-
-        # Writes <tt>state</tt> to the state column, but does not persist it to the database
-        #
-        #   foo = Foo.find(1)
-        #   foo.aasm.current_state # => :opened
-        #   foo.close
-        #   foo.aasm.current_state # => :closed
-        #   Foo.find(1).aasm.current_state # => :opened
-        #   foo.save
-        #   foo.aasm.current_state # => :closed
-        #   Foo.find(1).aasm.current_state # => :closed
-        #
-        # NOTE: intended to be called from an event
-        def aasm_write_state_without_persistence(state, name=:default)
-          aasm_write_attribute(state, name)
-        end
-
-        private
-        def aasm_enum(name=:default)
-          case AASM::StateMachineStore.fetch(self.class, true).machine(name).config.enum
-          when false then nil
-          when true then aasm_guess_enum_method(name)
-          when nil then aasm_guess_enum_method(name) if aasm_column_looks_like_enum(name)
-          else AASM::StateMachineStore.fetch(self.class, true).machine(name).config.enum
-          end
-        end
-
-        def aasm_column_looks_like_enum(name)
-          self.class.keys[self.class.aasm(name).attribute_name.to_s].type == Integer
-        end
-
-        def aasm_guess_enum_method(name)
-          self.class.aasm(name).attribute_name.to_s.pluralize.to_sym
-        end
-
-        def aasm_skipping_validations(state_machine_name)
-          AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.skip_validation_on_save
-        end
-
-        def aasm_write_attribute(state, name=:default)
-          write_attribute self.class.aasm(name).attribute_name, aasm_raw_attribute_value(state, name)
-        end
-
-        def aasm_raw_attribute_value(state, name=:default)
-          if aasm_enum(name)
-            self.class.send(aasm_enum(name))[state]
-          else
-            state.to_s
-          end
-        end
-
-        # Ensures that if the aasm_state column is nil and the record is new
-        # that the initial state gets populated before validation on create
-        #
-        #   foo = Foo.new
-        #   foo.aasm_state # => nil
-        #   foo.valid?
-        #   foo.aasm_state # => "open" (where :open is the initial state)
-        #
-        #
-        #   foo = Foo.find(:first)
-        #   foo.aasm_state # => 1
-        #   foo.aasm_state = nil
-        #   foo.valid?
-        #   foo.aasm_state # => nil
-        #
-        def aasm_ensure_initial_state
-          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
-            send("#{self.class.aasm(state_machine_name).attribute_name}=", aasm(state_machine_name).enter_initial_state.to_s) if send(self.class.aasm(state_machine_name).attribute_name).blank?
-          end
-        end
-
-        def aasm_validate_states
-          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
-            send("#{self.class.aasm(state_machine_name).attribute_name}=", aasm(state_machine_name).enter_initial_state.to_s) if send(self.class.aasm(state_machine_name).attribute_name).blank?
-            unless AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.skip_validation_on_save
-              if aasm(state_machine_name).current_state && !aasm(state_machine_name).states.include?(aasm(state_machine_name).current_state)
-                self.errors.add(AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.column , "is invalid")
-              end
-            end
-          end
-        end
-      end # InstanceMethods
-
-    end
-  end # Persistence
-end # AASM

data/spec/models/mongo_mapper/no_scope_mongo_mapper.rb

@@ -1,21 +0,0 @@
-class NoScopeMongoMapper
-  include MongoMapper::Document
-  include AASM
-
-  key :status, String
-
-  aasm :create_scopes => false, :column => :status do
-    state :ignored_scope
-  end
-end
-
-class NoScopeMongoMapperMultiple
-  include MongoMapper::Document
-  include AASM
-
-  key :status, String
-
-  aasm :left, :create_scopes => false, :column => :status do
-    state :ignored_scope
-  end
-end

data/spec/models/mongo_mapper/simple_new_dsl_mongo_mapper.rb

@@ -1,25 +0,0 @@
-class SimpleNewDslMongoMapper
-  include MongoMapper::Document
-  include AASM
-
-  key :status, String
-
-  aasm :column => :status
-  aasm do
-    state :unknown_scope
-    state :next
-  end
-end
-
-class SimpleNewDslMongoMapperMultiple
-  include MongoMapper::Document
-  include AASM
-
-  key :status, String
-
-  aasm :left, :column => :status
-  aasm :left do
-    state :unknown_scope
-    state :next
-  end
-end

data/spec/unit/persistence/mongo_mapper_persistence_multiple_spec.rb

@@ -1,149 +0,0 @@
-describe 'mongo_mapper' do
-  begin
-    require 'mongo_mapper'
-    require 'logger'
-    require 'spec_helper'
-
-    Dir[File.dirname(__FILE__) + "/../../models/mongo_mapper/*.rb"].sort.each do |f|
-      require File.expand_path(f)
-    end
-
-    before(:all) do
-      config = {
-        'test' => {
-          'database' => "mongo_mapper_#{Process.pid}"
-        }
-      }
-
-      MongoMapper.setup(config, 'test') #, :logger => Logger.new(STDERR))
-    end
-
-    after do
-      # Clear Out all non-system Mongo collections between tests
-      MongoMapper.database.collections.each do |collection|
-        collection.drop unless collection.capped? || (collection.name =~ /\Asystem/)
-      end
-    end
-
-    describe "named scopes with the old DSL" do
-
-      context "Does not already respond_to? the scope name" do
-        it "should add a scope for each state" do
-          expect(SimpleMongoMapperMultiple).to respond_to(:unknown_scope)
-          expect(SimpleMongoMapperMultiple).to respond_to(:another_unknown_scope)
-
-          expect(SimpleMongoMapperMultiple.unknown_scope.class).to eq(MongoMapper::Plugins::Querying::DecoratedPluckyQuery)
-          expect(SimpleMongoMapperMultiple.another_unknown_scope.class).to eq(MongoMapper::Plugins::Querying::DecoratedPluckyQuery)
-          #expect(SimpleMongoMapperMultiple.unknown_scope.is_a?(ActiveRecord::Relation)).to be_truthy
-        end
-      end
-
-      context "Already respond_to? the scope name" do
-        it "should not add a scope" do
-          expect(SimpleMongoMapperMultiple).to respond_to(:next)
-          expect(SimpleMongoMapperMultiple.new.class).to eq(SimpleMongoMapperMultiple)
-        end
-      end
-
-    end
-
-    describe "named scopes with the new DSL" do
-
-      context "Does not already respond_to? the scope name" do
-        it "should add a scope" do
-          expect(SimpleNewDslMongoMapperMultiple).to respond_to(:unknown_scope)
-          expect(SimpleNewDslMongoMapperMultiple.unknown_scope.class).to eq(MongoMapper::Plugins::Querying::DecoratedPluckyQuery)
-        end
-      end
-
-      context "Already respond_to? the scope name" do
-        it "should not add a scope" do
-          expect(SimpleNewDslMongoMapperMultiple).to respond_to(:next)
-          expect(SimpleNewDslMongoMapperMultiple.new.class).to eq(SimpleNewDslMongoMapperMultiple)
-        end
-      end
-
-      it "does not create scopes if requested" do
-        expect(NoScopeMongoMapperMultiple).not_to respond_to(:ignored_scope)
-      end
-
-    end
-
-    describe "instance methods" do
-
-      let(:simple) {SimpleNewDslMongoMapperMultiple.new}
-
-      it "should call aasm_ensure_initial_state on validation before create" do
-        expect(SimpleNewDslMongoMapperMultiple.aasm(:left).initial_state).to eq(:unknown_scope)
-        expect(SimpleNewDslMongoMapperMultiple.aasm(:left).attribute_name).to eq(:status)
-        expect(simple.status).to eq(nil)
-        simple.valid?
-        expect(simple.status).to eq('unknown_scope')
-      end
-
-      it "should call aasm_ensure_initial_state before create, even if skipping validations" do
-        expect(simple.status).to eq(nil)
-        simple.save(:validate => false)
-        expect(simple.status).to eq('unknown_scope')
-      end
-    end
-
-    describe "complex example" do
-      it "works" do
-        record = ComplexMongoMapperExample.new
-        expect(record.aasm(:left).current_state).to eql :one
-        expect(record.left).to be_nil
-        expect(record.aasm(:right).current_state).to eql :alpha
-        expect(record.right).to be_nil
-
-        record.save!
-        expect_aasm_states record, :one, :alpha
-        record.reload
-        expect_aasm_states record, :one, :alpha
-
-        record.increment!
-        expect_aasm_states record, :two, :alpha
-        record.reload
-        expect_aasm_states record, :two, :alpha
-
-        record.level_up!
-        expect_aasm_states record, :two, :beta
-        record.reload
-        expect_aasm_states record, :two, :beta
-
-        record.increment!
-        expect { record.increment! }.to raise_error(AASM::InvalidTransition)
-        expect_aasm_states record, :three, :beta
-        record.reload
-        expect_aasm_states record, :three, :beta
-
-        record.level_up!
-        expect_aasm_states record, :three, :gamma
-        record.reload
-        expect_aasm_states record, :three, :gamma
-
-        record.level_down # without saving
-        expect_aasm_states record, :three, :beta
-        record.reload
-        expect_aasm_states record, :three, :gamma
-
-        record.level_down # without saving
-        expect_aasm_states record, :three, :beta
-        record.reset!
-        expect_aasm_states record, :one, :beta
-      end
-
-      def expect_aasm_states(record, left_state, right_state)
-        expect(record.aasm(:left).current_state).to eql left_state.to_sym
-        expect(record.left).to eql left_state.to_s
-        expect(record.aasm(:right).current_state).to eql right_state.to_sym
-        expect(record.right).to eql right_state.to_s
-      end
-    end
-
-  rescue LoadError
-    puts "--------------------------------------------------------------------------"
-    puts "Not running MongoMapper specs because mongo_mapper gem is not installed!!!"
-    puts "--------------------------------------------------------------------------"
-  end
-end

data/spec/unit/persistence/mongo_mapper_persistence_spec.rb

@@ -1,96 +0,0 @@
-describe 'mongo_mapper' do
-  begin
-    require 'mongo_mapper'
-    require 'logger'
-    require 'spec_helper'
-
-    Dir[File.dirname(__FILE__) + "/../../models/mongo_mapper/*.rb"].sort.each do |f|
-      require File.expand_path(f)
-    end
-
-    before(:all) do
-      config = {
-        'test' => {
-          'database' => "mongo_mapper_#{Process.pid}"
-        }
-      }
-
-      MongoMapper.setup(config, 'test') #, :logger => Logger.new(STDERR))
-    end
-
-    after do
-      # Clear Out all non-system Mongo collections between tests
-      MongoMapper.database.collections.each do |collection|
-        collection.drop unless collection.capped? || (collection.name =~ /\Asystem/)
-      end
-    end
-
-    describe "named scopes with the old DSL" do
-
-      context "Does not already respond_to? the scope name" do
-        it "should add a scope for each state" do
-          expect(SimpleMongoMapper).to respond_to(:unknown_scope)
-          expect(SimpleMongoMapper).to respond_to(:another_unknown_scope)
-
-          expect(SimpleMongoMapper.unknown_scope.class).to eq(MongoMapper::Plugins::Querying::DecoratedPluckyQuery)
-          expect(SimpleMongoMapper.another_unknown_scope.class).to eq(MongoMapper::Plugins::Querying::DecoratedPluckyQuery)
-          #expect(SimpleMongoMapper.unknown_scope.is_a?(ActiveRecord::Relation)).to be_truthy
-        end
-      end
-
-      context "Already respond_to? the scope name" do
-        it "should not add a scope" do
-          expect(SimpleMongoMapper).to respond_to(:next)
-          expect(SimpleMongoMapper.new.class).to eq(SimpleMongoMapper)
-        end
-      end
-
-    end
-
-    describe "named scopes with the new DSL" do
-
-      context "Does not already respond_to? the scope name" do
-        it "should add a scope" do
-          expect(SimpleNewDslMongoMapper).to respond_to(:unknown_scope)
-          expect(SimpleNewDslMongoMapper.unknown_scope.class).to eq(MongoMapper::Plugins::Querying::DecoratedPluckyQuery)
-        end
-      end
-
-      context "Already respond_to? the scope name" do
-        it "should not add a scope" do
-          expect(SimpleNewDslMongoMapper).to respond_to(:next)
-          expect(SimpleNewDslMongoMapper.new.class).to eq(SimpleNewDslMongoMapper)
-        end
-      end
-
-      it "does not create scopes if requested" do
-        expect(NoScopeMongoMapper).not_to respond_to(:ignored_scope)
-      end
-
-    end
-
-    describe "instance methods" do
-
-      let(:simple) {SimpleNewDslMongoMapper.new}
-
-      it "should call aasm_ensure_initial_state on validation before create" do
-        expect(SimpleNewDslMongoMapper.aasm.initial_state).to eq(:unknown_scope)
-        expect(SimpleNewDslMongoMapper.aasm.attribute_name).to eq(:status)
-        expect(simple.status).to eq(nil)
-        simple.valid?
-        expect(simple.status).to eq('unknown_scope')
-      end
-
-      it "should call aasm_ensure_initial_state before create, even if skipping validations" do
-        expect(simple.status).to eq(nil)
-        simple.save(:validate => false)
-        expect(simple.status).to eq('unknown_scope')
-      end
-    end
-
-  rescue LoadError
-    puts "--------------------------------------------------------------------------"
-    puts "Not running MongoMapper multiple-specs because mongo_mapper gem is not installed!!!"
-    puts "--------------------------------------------------------------------------"
-  end
-end