micro-max-box 0.0.1

data/aasm-6.0.0/lib/aasm/persistence/orm.rb

@@ -0,0 +1,154 @@
+module AASM
+  module Persistence
+    # This module adds transactional support for any database that supports it.
+    # This includes rollback capability and rollback/commit callbacks.
+    module ORM
+
+      # 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)
+        attribute_name = self.class.aasm(name).attribute_name
+        old_value = aasm_read_attribute(attribute_name)
+        aasm_write_state_attribute state, name
+
+        success = if aasm_skipping_validations(name)
+          aasm_update_column(attribute_name, aasm_raw_attribute_value(state, name))
+        else
+          aasm_save
+        end
+
+        unless success
+          aasm_rollback(name, old_value)
+          aasm_raise_invalid_record if aasm_whiny_persistence(name)
+        end
+
+        success
+      end
+
+      # Writes <tt>state</tt> to the state field, 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_state_attribute(state, name)
+      end
+
+      private
+
+      # Save the record and return true if it succeeded/false otherwise.
+      def aasm_save
+        raise("Define #aasm_save_without_error in the AASM Persistence class.")
+      end
+
+      def aasm_raise_invalid_record
+        raise("Define #aasm_raise_invalid_record in the AASM Persistence class.")
+      end
+
+      # Update only the column without running validations.
+      def aasm_update_column(attribute_name, value)
+        raise("Define #aasm_update_column in the AASM Persistence class.")
+      end
+
+      def aasm_read_attribute(name)
+        raise("Define #aasm_read_attribute the AASM Persistence class.")
+      end
+
+      def aasm_write_attribute(name, value)
+        raise("Define #aasm_write_attribute in the AASM Persistence class.")
+      end
+
+      # Returns true or false if transaction completed successfully.
+      def aasm_transaction(requires_new, requires_lock)
+        raise("Define #aasm_transaction the AASM Persistence class.")
+      end
+
+      def aasm_supports_transactions?
+        true
+      end
+
+      def aasm_execute_after_commit
+        yield
+      end
+
+      def aasm_write_state_attribute(state, name=:default)
+        aasm_write_attribute(self.class.aasm(name).attribute_name, aasm_raw_attribute_value(state, name))
+      end
+
+      def aasm_raw_attribute_value(state, _name=:default)
+        state.to_s
+      end
+
+      def aasm_rollback(name, old_value)
+        aasm_write_attribute(self.class.aasm(name).attribute_name, old_value)
+        false
+      end
+
+      def aasm_whiny_persistence(state_machine_name)
+        AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.whiny_persistence
+      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 use_transactions?(state_machine_name)
+        AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.use_transactions
+      end
+
+      def requires_new?(state_machine_name)
+        AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.requires_new_transaction
+      end
+
+      def requires_lock?(state_machine_name)
+        AASM::StateMachineStore.fetch(self.class, true).machine(state_machine_name).config.requires_lock
+      end
+
+      # Returns true if event was fired successfully and transaction completed.
+      def aasm_fire_event(state_machine_name, name, options, *args, &block)
+        return super unless aasm_supports_transactions? && options[:persist]
+
+        event = self.class.aasm(state_machine_name).state_machine.events[name]
+        event.fire_callbacks(:before_transaction, self, *args)
+        event.fire_global_callbacks(:before_all_transactions, self, *args)
+
+        begin
+          success = if options[:persist] && use_transactions?(state_machine_name)
+            aasm_transaction(requires_new?(state_machine_name), requires_lock?(state_machine_name)) do
+              super
+            end
+          else
+            super
+          end
+
+          if success && !(event.options.keys & [:after_commit, :after_all_commits]).empty?
+            aasm_execute_after_commit do
+              event.fire_callbacks(:after_commit, self, *args)
+              event.fire_global_callbacks(:after_all_commits, self, *args)
+            end
+          end
+
+          success
+        ensure
+          event.fire_callbacks(:after_transaction, self, *args)
+          event.fire_global_callbacks(:after_all_transactions, self, *args)
+        end
+      end
+
+    end # Transactional
+  end # Persistence
+end # AASM

data/aasm-6.0.0/lib/aasm/persistence/plain_persistence.rb

@@ -0,0 +1,26 @@
+module AASM
+  module Persistence
+    module PlainPersistence
+
+      # may be overwritten by persistence mixins
+      def aasm_read_state(name=:default)
+        # all the following lines behave like @current_state ||= aasm(name).enter_initial_state
+        current = aasm(name).instance_variable_defined?("@current_state_#{name}") &&
+                  aasm(name).instance_variable_get("@current_state_#{name}")
+        return current if current
+        aasm(name).instance_variable_set("@current_state_#{name}", aasm(name).enter_initial_state)
+      end
+
+      # may be overwritten by persistence mixins
+      def aasm_write_state(new_state, name=:default)
+        true
+      end
+
+      # may be overwritten by persistence mixins
+      def aasm_write_state_without_persistence(new_state, name=:default)
+        aasm(name).instance_variable_set("@current_state_#{name}", new_state)
+      end
+
+    end
+  end
+end

data/aasm-6.0.0/lib/aasm/persistence/redis_persistence.rb

@@ -0,0 +1,112 @@
+module AASM
+  module Persistence
+    module RedisPersistence
+
+      def self.included(base)
+        base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::RedisPersistence::InstanceMethods)
+      end
+
+      module InstanceMethods
+        # Initialize with default values
+        #
+        # Redis::Objects removes the key from Redis when set to `nil`
+        def initialize(*args)
+          super
+          aasm_ensure_initial_state
+        end
+        # Returns the value of the aasm.attribute_name - called from <tt>aasm.current_state</tt>
+        #
+        # If it's a new record, and the aasm state column is blank it returns the initial state
+        #
+        #   class Foo
+        #     include Redis::Objects
+        #     include AASM
+        #     aasm :column => :status do
+        #       state :opened
+        #       state :closed
+        #     end
+        #   end
+        #
+        #   foo = Foo.new
+        #   foo.current_state # => :opened
+        #   foo.close
+        #   foo.current_state # => :closed
+        #
+        #   foo = Foo[1]
+        #   foo.current_state # => :opened
+        #   foo.aasm_state = nil
+        #   foo.current_state # => nil
+        #
+        # NOTE: intended to be called from an event
+        #
+        # This allows for nil aasm states - be sure to add validation to your model
+        def aasm_read_state(name=:default)
+          state = send(self.class.aasm(name).attribute_name)
+
+          if state.value.nil?
+            nil
+          else
+            state.value.to_sym
+          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 |name|
+            aasm_column = self.class.aasm(name).attribute_name
+            aasm(name).enter_initial_state if !send(aasm_column).value || send(aasm_column).value.empty?
+          end
+        end
+
+        # Writes <tt>state</tt> to the state column and persists it to the database
+        #
+        #   foo = Foo[1]
+        #   foo.aasm.current_state # => :opened
+        #   foo.close!
+        #   foo.aasm.current_state # => :closed
+        #   Foo[1].aasm.current_state # => :closed
+        #
+        # NOTE: intended to be called from an event
+        def aasm_write_state(state, name=:default)
+          aasm_column = self.class.aasm(name).attribute_name
+          send("#{aasm_column}").value = state
+        end
+
+        # Writes <tt>state</tt> to the state column, but does not persist it to the database
+        # (but actually it still does)
+        #
+        # With Redis::Objects it's not possible to skip persisting - it's not an ORM,
+        # it does not operate like an AR model and does not know how to postpone changes.
+        #
+        #   foo = Foo[1]
+        #   foo.aasm.current_state # => :opened
+        #   foo.close
+        #   foo.aasm.current_state # => :closed
+        #   Foo[1].aasm.current_state # => :opened
+        #   foo.save
+        #   foo.aasm.current_state # => :closed
+        #   Foo[1].aasm.current_state # => :closed
+        #
+        # NOTE: intended to be called from an event
+        def aasm_write_state_without_persistence(state, name=:default)
+          aasm_write_state(state, name)
+        end
+      end
+    end
+  end
+end

data/aasm-6.0.0/lib/aasm/persistence/sequel_persistence.rb

@@ -0,0 +1,83 @@
+require 'aasm/persistence/orm'
+module AASM
+  module Persistence
+    module SequelPersistence
+      def self.included(base)
+        base.send(:include, AASM::Persistence::Base)
+        base.send(:include, AASM::Persistence::ORM)
+        base.send(:include, AASM::Persistence::SequelPersistence::InstanceMethods)
+      end
+
+      module InstanceMethods
+        def before_validation
+          aasm_ensure_initial_state
+          super
+        end
+
+        def before_create
+          super
+        end
+
+        def aasm_raise_invalid_record
+          raise Sequel::ValidationFailed.new(self)
+        end
+
+        def aasm_new_record?
+          new?
+        end
+
+        # Returns nil if fails silently
+        # http://sequel.jeremyevans.net/rdoc/classes/Sequel/Model/InstanceMethods.html#method-i-save
+        def aasm_save
+          !save(raise_on_failure: false).nil?
+        end
+
+        def aasm_read_attribute(name)
+          send(name)
+        end
+
+        def aasm_write_attribute(name, value)
+          send("#{name}=", value)
+        end
+
+        def aasm_transaction(requires_new, requires_lock)
+          self.class.db.transaction(savepoint: requires_new) do
+            if requires_lock
+              # http://sequel.jeremyevans.net/rdoc/classes/Sequel/Model/InstanceMethods.html#method-i-lock-21
+              requires_lock.is_a?(String) ? lock!(requires_lock) : lock!
+            end
+            yield
+          end
+        end
+
+        def aasm_update_column(attribute_name, value)
+          this.update(attribute_name => value)
+        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|
+            aasm(state_machine_name).enter_initial_state if
+              (new? || values.key?(self.class.aasm(state_machine_name).attribute_name)) &&
+                send(self.class.aasm(state_machine_name).attribute_name).to_s.strip.empty?
+          end
+        end
+
+      end
+    end
+  end
+end

data/aasm-6.0.0/lib/aasm/persistence.rb

@@ -0,0 +1,54 @@
+module AASM
+  module Persistence
+    class << self
+
+      def load_persistence(base)
+        # Use a fancier auto-loading thingy, perhaps.  When there are more persistence engines.
+        hierarchy = base.ancestors.map {|klass| klass.to_s}
+
+        if hierarchy.include?("ActiveRecord::Base")
+          require_persistence :active_record
+          include_persistence base, :active_record
+        elsif hierarchy.include?("Mongoid::Document")
+          require_persistence :mongoid
+          include_persistence base, :mongoid
+        elsif hierarchy.include?("NoBrainer::Document")
+          require_persistence :no_brainer
+          include_persistence base, :no_brainer
+        elsif hierarchy.include?("Sequel::Model")
+          require_persistence :sequel
+          include_persistence base, :sequel
+        elsif hierarchy.include?("Dynamoid::Document")
+          require_persistence :dynamoid
+          include_persistence base, :dynamoid
+        elsif hierarchy.include?("Redis::Objects")
+          require_persistence :redis
+          include_persistence base, :redis
+        elsif hierarchy.include?("CDQManagedObject")
+          include_persistence base, :core_data_query
+        else
+          include_persistence base, :plain
+        end
+      end
+
+      private
+
+      def require_persistence(type)
+        require File.join(File.dirname(__FILE__), 'persistence', "#{type}_persistence")
+      end
+
+      def include_persistence(base, type)
+        base.send(:include, constantize("#{capitalize(type)}Persistence"))
+      end
+
+      def capitalize(string_or_symbol)
+        string_or_symbol.to_s.split('_').map {|segment| segment[0].upcase + segment[1..-1]}.join('')
+      end
+
+      def constantize(string)
+        AASM::Persistence.const_get(string)
+      end
+
+    end # class << self
+  end
+end # AASM

data/aasm-6.0.0/lib/aasm/rspec/allow_event.rb

@@ -0,0 +1,26 @@
+RSpec::Matchers.define :allow_event do |event|
+  match do |obj|
+    @state_machine_name ||= :default
+    obj.aasm(@state_machine_name).may_fire_event?(event, *@args)
+  end
+
+  chain :on do |state_machine_name|
+    @state_machine_name = state_machine_name
+  end
+
+  chain :with do |*args|
+    @args = args
+  end
+
+  description do
+    "allow event #{expected} (on :#{@state_machine_name})"
+  end
+
+  failure_message do |obj|
+    "expected that the event :#{expected} would be allowed (on :#{@state_machine_name})"
+  end
+
+  failure_message_when_negated do |obj|
+    "expected that the event :#{expected} would not be allowed (on :#{@state_machine_name})"
+  end
+end

data/aasm-6.0.0/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/aasm-6.0.0/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/aasm-6.0.0/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/aasm-6.0.0/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/aasm-6.0.0/lib/aasm/state_machine.rb

@@ -0,0 +1,53 @@
+module AASM
+  class StateMachine
+    # the following four methods provide the storage of all state machines
+
+    attr_accessor :states, :events, :initial_state, :config, :name, :global_callbacks
+
+    def initialize(name)
+      @initial_state = nil
+      @states = []
+      @events = {}
+      @global_callbacks = {}
+      @config = AASM::Configuration.new
+      @name = name
+    end
+
+    # 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 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
+
+    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/aasm-6.0.0/lib/aasm/state_machine_store.rb

@@ -0,0 +1,77 @@
+require 'concurrent/map'
+
+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/aasm-6.0.0/lib/aasm/version.rb

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