micro-max-box 0.0.1

data/aasm-6.0.0/lib/aasm/core/state.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module AASM::Core
+  class State
+    attr_reader :name, :state_machine, :options, :default_display_name
+
+    def initialize(name, klass, state_machine, options={})
+      @name = name
+      @klass = klass
+      @state_machine = state_machine
+      @default_display_name = name.to_s.gsub(/_/, ' ').capitalize
+      update(options)
+    end
+
+    # called internally by Ruby 1.9 after clone()
+    def initialize_copy(orig)
+      super
+      @options = {}
+      orig.options.each_pair do |name, setting|
+        @options[name] = if setting.is_a?(Hash) || setting.is_a?(Array)
+                           setting.dup
+                         else
+                           setting
+                         end
+      end
+    end
+
+    def ==(state)
+      if state.is_a? Symbol
+        name == state
+      else
+        name == state.name
+      end
+    end
+
+    def <=>(state)
+      if state.is_a? Symbol
+        name <=> state
+      else
+        name <=> state.name
+      end
+    end
+
+    def to_s
+      name.to_s
+    end
+
+    def fire_callbacks(action, record, *args)
+      action = @options[action]
+      catch :halt_aasm_chain do
+        action.is_a?(Array) ?
+                action.each {|a| _fire_callbacks(a, record, args)} :
+                _fire_callbacks(action, record, args)
+      end
+    end
+
+    def display_name
+      @display_name = begin
+        if Module.const_defined?(:I18n)
+          localized_name
+        else
+          @default_display_name
+        end
+      end
+    end
+
+    def localized_name
+      AASM::Localizer.new.human_state_name(@klass, self)
+    end
+    alias human_name localized_name
+
+    def for_select
+      [display_name, name.to_s]
+    end
+
+  private
+
+    def update(options = {})
+      if options.key?(:display)
+        @default_display_name = options.delete(:display)
+      end
+      @options = options
+      self
+    end
+
+    def _fire_callbacks(action, record, args)
+      Invoker.new(action, record, args).invoke
+    end
+
+  end
+end # AASM

data/aasm-6.0.0/lib/aasm/core/transition.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module AASM::Core
+  class Transition
+    include AASM::DslHelper
+
+    attr_reader :from, :to, :event, :opts, :failures
+    alias_method :options, :opts
+
+    def initialize(event, opts, &block)
+      add_options_from_dsl(opts, [:on_transition, :guard, :after, :success], &block) if block
+
+      @event = event
+      @from = opts[:from]
+      @to = opts[:to]
+      @guards = Array(opts[:guards]) + Array(opts[:guard]) + Array(opts[:if])
+      @unless = Array(opts[:unless]) #TODO: This could use a better name
+      @failures = []
+
+      if opts[:on_transition]
+        warn '[DEPRECATION] :on_transition is deprecated, use :after instead'
+        opts[:after] = Array(opts[:after]) + Array(opts[:on_transition])
+      end
+      @after = Array(opts[:after])
+      @after = @after[0] if @after.size == 1
+
+      @success = Array(opts[:success])
+      @success = @success[0] if @success.size == 1
+
+      @opts = opts
+    end
+
+    # called internally by Ruby 1.9 after clone()
+    def initialize_copy(orig)
+      super
+      @guards = @guards.dup
+      @unless = @unless.dup
+      @opts   = {}
+      orig.opts.each_pair { |name, setting| @opts[name] = setting.is_a?(Hash) || setting.is_a?(Array) ? setting.dup : setting }
+    end
+
+    def allowed?(obj, *args)
+      invoke_callbacks_compatible_with_guard(@guards, obj, args, :guard => true) &&
+      invoke_callbacks_compatible_with_guard(@unless, obj, args, :unless => true)
+    end
+
+    def execute(obj, *args)
+      invoke_callbacks_compatible_with_guard(event.state_machine.global_callbacks[:after_all_transitions], obj, args)
+      invoke_callbacks_compatible_with_guard(@after, obj, args)
+    end
+
+    def ==(obj)
+      @from == obj.from && @to == obj.to
+    end
+
+    def from?(value)
+      @from == value
+    end
+
+    def invoke_success_callbacks(obj, *args)
+      _fire_callbacks(@success, obj, args)
+    end
+
+    private
+
+    def invoke_callbacks_compatible_with_guard(code, record, args, options={})
+      if record.respond_to?(:aasm)
+        record.aasm(event.state_machine.name).from_state = @from if record.aasm(event.state_machine.name).respond_to?(:from_state=)
+        record.aasm(event.state_machine.name).to_state = @to if record.aasm(event.state_machine.name).respond_to?(:to_state=)
+      end
+
+      Invoker.new(code, record, args)
+             .with_options(options)
+             .with_failures(failures)
+             .invoke
+    end
+
+    def _fire_callbacks(code, record, args)
+      Invoker.new(code, record, args).invoke
+    end
+
+  end
+end # AASM

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

@@ -0,0 +1,32 @@
+module AASM
+  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
+end

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

@@ -0,0 +1,22 @@
+module AASM
+
+  class UnknownStateMachineError < RuntimeError; end
+
+  class InvalidTransition < RuntimeError
+    attr_reader :object, :event_name, :originating_state, :failures, :state_machine_name
+
+    def initialize(object, event_name, state_machine_name, failures = [])
+      @object, @event_name, @originating_state, @failures = object, event_name, object.aasm(state_machine_name).current_state, failures
+      @state_machine_name = state_machine_name
+      super("Event '#{event_name}' cannot transition from '#{originating_state}'.#{reasoning}")
+    end
+
+    def reasoning
+      " Failed callback(s): #{failures}." unless failures.empty?
+    end
+  end
+
+  class UndefinedState < RuntimeError; end
+  class UndefinedEvent < UndefinedState; end
+  class NoDirectAssignmentError < RuntimeError; end
+end

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

@@ -0,0 +1,153 @@
+module AASM
+  class InstanceBase
+    attr_accessor :from_state, :to_state, :current_event
+
+    def initialize(instance, name=:default) # instance of the class including AASM, name of the state machine
+      @instance = instance
+      @name = name
+    end
+
+    def current_state
+      @instance.aasm_read_state(@name)
+    end
+
+    def current_state=(state)
+      @instance.aasm_write_state_without_persistence(state, @name)
+    end
+
+    def enter_initial_state
+      state_name = determine_state_name(@instance.class.aasm(@name).initial_state)
+      state_object = state_object_for_name(state_name)
+
+      state_object.fire_callbacks(:before_enter, @instance)
+      self.current_state = state_name
+      state_object.fire_callbacks(:after_enter, @instance)
+
+      state_name
+    end
+
+    def human_state
+      state_object_for_name(current_state).display_name
+    end
+
+    def states(options={}, *args)
+      if options.has_key?(:permitted)
+        selected_events = events({:permitted => options[:permitted]}, *args)
+        # An array of arrays. Each inner array represents the transitions that
+        # transition from the current state for an event
+        event_transitions = selected_events.map {|e| e.transitions_from_state(current_state) }
+
+        # An array of :to transition states
+        to_state_names = event_transitions.map do |transitions|
+          return nil if transitions.empty?
+
+          # Return the :to state of the first transition that is allowed (or not) or nil
+          if options[:permitted]
+            transition = transitions.find { |t| t.allowed?(@instance, *args) }
+          else
+            transition = transitions.find { |t| !t.allowed?(@instance, *args) }
+          end
+          transition ? transition.to : nil
+        end.flatten.compact.uniq
+
+        # Select states that are in to_state_names
+        @instance.class.aasm(@name).states.select {|s| to_state_names.include?(s.name)}
+      else
+        @instance.class.aasm(@name).states
+      end
+    end
+
+    def events(options={}, *args)
+      state = options[:state] || current_state
+      events = @instance.class.aasm(@name).events.select {|e| e.transitions_from_state?(state) }
+
+      options[:reject] = Array(options[:reject])
+      events.reject! { |e| options[:reject].include?(e.name) }
+
+      if options.has_key?(:permitted)
+        # filters the results of events_for_current_state so that only those that
+        # are really currently possible (given transition guards) are shown.
+        if options[:permitted]
+          events.select! { |e| @instance.send("may_#{event_method_name(e.name)}?", *args) }
+        else
+          events.select! { |e| !@instance.send("may_#{event_method_name(e.name)}?", *args) }
+        end
+      end
+
+      events
+    end
+
+    def permitted_transitions
+      events(permitted: true).flat_map do |event|
+        available_transitions = event.transitions_from_state(current_state)
+        allowed_transitions = available_transitions.select { |t| t.allowed?(@instance) }
+
+        allowed_transitions.map do |transition|
+          { event: event.name, state: transition.to }
+        end
+      end
+    end
+
+    def state_object_for_name(name)
+      obj = @instance.class.aasm(@name).states.find {|s| s.name == name}
+      raise AASM::UndefinedState, "State :#{name} doesn't exist" if obj.nil?
+      obj
+    end
+
+    def determine_state_name(state)
+      case state
+        when Symbol, String
+          state
+        when Proc
+          state.call(@instance)
+        else
+          raise NotImplementedError, "Unrecognized state-type given. Expected Symbol, String, or Proc."
+      end
+    end
+
+    def may_fire_event?(name, *args)
+      if event = @instance.class.aasm(@name).state_machine.events[name]
+        !!event.may_fire?(@instance, *args)
+      else
+        false # unknown event
+      end
+    end
+
+    def fire(event_name, *args, &block)
+      event_exists?(event_name)
+      @instance.send(event_method_name(event_name), *args, &block)
+    end
+
+    def fire!(event_name, *args, &block)
+      event_exists?(event_name, true)
+      bang_event_name = "#{event_method_name(event_name)}!".to_sym
+      @instance.send(bang_event_name, *args, &block)
+    end
+
+    def set_current_state_with_persistence(state)
+      save_success = @instance.aasm_write_state(state, @name)
+      self.current_state = state if save_success
+      save_success
+    end
+
+    private
+
+    def event_method_name(event_name)
+      config = @instance.class.aasm(@name).state_machine.config
+      if config.namespace
+        ns = (config.namespace == true) ? @name : config.namespace
+        "#{event_name}_#{ns}"
+      else
+        event_name.to_s
+      end
+    end
+
+    def event_exists?(event_name, bang = false)
+      event = @instance.class.aasm(@name).state_machine.events[event_name.to_sym]
+      return true if event
+
+      event_error = bang ? "#{event_name}!" : event_name
+      raise AASM::UndefinedEvent, "Event :#{event_error} doesn't exist" if event.nil?
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module AASM
+  class Localizer
+    def human_event_name(klass, event)
+      checklist = ancestors_list(klass).inject([]) do |list, ancestor|
+        list << :"#{i18n_scope(klass)}.events.#{i18n_klass(ancestor)}.#{event}"
+        list
+      end
+      translate_queue(checklist) || I18n.translate(checklist.shift, :default => default_display_name(event))
+    end
+
+    def human_state_name(klass, state)
+      checklist = ancestors_list(klass).inject([]) do |list, ancestor|
+        list << item_for(klass, state, ancestor)
+        list << item_for(klass, state, ancestor, :old_style => true)
+        list
+      end
+      translate_queue(checklist) || I18n.translate(checklist.shift, :default => default_display_name(state))
+    end
+
+  private
+
+    def item_for(klass, state, ancestor, options={})
+      separator = options[:old_style] ? '.' : '/'
+      :"#{i18n_scope(klass)}.attributes.#{i18n_klass(ancestor)}.#{klass.aasm(state.state_machine.name).attribute_name}#{separator}#{state}"
+    end
+
+    def translate_queue(checklist)
+      (0...(checklist.size-1)).each do |i|
+        begin
+          return I18n.translate(checklist.shift, :raise => true)
+        rescue I18n::MissingTranslationData
+          # that's okay
+        end
+      end
+      nil
+    end
+
+    # added for rails 2.x compatibility
+    def i18n_scope(klass)
+      klass.respond_to?(:i18n_scope) ? klass.i18n_scope : :activerecord
+    end
+
+    # added for rails < 3.0.3 compatibility
+    def i18n_klass(klass)
+      klass.model_name.respond_to?(:i18n_key) ? klass.model_name.i18n_key : klass.name.underscore
+    end
+
+    def ancestors_list(klass)
+      has_active_record_base = defined?(::ActiveRecord::Base)
+      klass.ancestors.select do |ancestor|
+        not_active_record_base = has_active_record_base ? (ancestor != ::ActiveRecord::Base) : true
+        ancestor.respond_to?(:model_name) && not_active_record_base
+      end
+    end
+
+    def default_display_name(object) # Can use better argument name
+      if object.respond_to?(:default_display_name)
+        object.default_display_name
+      else
+        object.to_s.gsub(/_/, ' ').capitalize
+      end
+    end
+  end
+end # AASM

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

@@ -0,0 +1,13 @@
+module Minitest::Assertions
+  def assert_event_allowed(object, event, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    assert object.aasm(state_machine_name).may_fire_event?(event),
+          "Expected that the event :#{event} would be allowed (on :#{state_machine_name})"
+  end
+
+  def refute_event_allowed(object, event, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    refute object.aasm(state_machine_name).may_fire_event?(event),
+          "Expected that the event :#{event} would not be allowed (on :#{state_machine_name})"
+  end
+end

data/aasm-6.0.0/lib/aasm/minitest/allow_transition_to.rb

@@ -0,0 +1,13 @@
+module Minitest::Assertions
+  def assert_transition_to_allowed(object, to_state, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    assert object.aasm(state_machine_name).states(permitted: true).include?(to_state),
+           "Expected that the state :#{to_state} would be reachable (on :#{state_machine_name})"
+  end
+
+  def refute_transition_to_allowed(object, to_state, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    refute object.aasm(state_machine_name).states(permitted: true).include?(to_state),
+           "Expected that the state :#{to_state} would be reachable (on :#{state_machine_name})"
+  end
+end

data/aasm-6.0.0/lib/aasm/minitest/have_state.rb

@@ -0,0 +1,13 @@
+module Minitest::Assertions
+  def assert_have_state(object, state, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    assert object.aasm(state_machine_name).current_state == state,
+         "Expected that :#{object.aasm(state_machine_name).current_state} would be :#{state} (on :#{state_machine_name})"
+  end
+
+  def refute_have_state(object, state, options = {})
+    state_machine_name = options.fetch(:on, :default)
+    refute object.aasm(state_machine_name).current_state == state,
+         "Expected that :#{object.aasm(state_machine_name).current_state} would be :#{state} (on :#{state_machine_name})"
+  end
+end

data/aasm-6.0.0/lib/aasm/minitest/transition_from.rb

@@ -0,0 +1,21 @@
+module Minitest::Assertions
+  def assert_transitions_from(object, from_state, *args)
+    options = args.first
+    options[:on] ||= :default
+    assert _transitions_from?(object, from_state, args, options),
+          "Expected transition state to :#{options[:to]} from :#{from_state} on event :#{options[:on_event]}, (on :#{options[:on]})"
+  end
+
+  def refute_transitions_from(object, from_state, *args)
+    options = args.first
+    options[:on] ||= :default
+    refute _transitions_from?(object, from_state, args, options),
+          "Expected transition state to :#{options[:to]} from :#{from_state} on event :#{options[:on_event]}, (on :#{options[:on]})"
+  end
+
+  def _transitions_from?(object, from_state, args, options)
+    state_machine_name = options[:on]
+    object.aasm(state_machine_name).current_state = from_state.to_sym
+    object.send(options[:on_event], *args) && options[:to].to_sym == object.aasm(state_machine_name).current_state
+  end
+end

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

@@ -0,0 +1,5 @@
+Minitest = MiniTest unless defined? Minitest
+# relative-require all minitest_spec files
+Dir[File.dirname(__FILE__) + '/minitest/*.rb'].each do |file|
+  require 'aasm/minitest/' + File.basename(file, File.extname(file))
+end

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

@@ -0,0 +1,15 @@
+require 'aasm/minitest'
+
+module Minitest::Expectations
+  AASM.infect_an_assertion :assert_transitions_from, :must_transition_from, :do_not_flip
+  AASM.infect_an_assertion :refute_transitions_from, :wont_transition_from, :do_not_flip
+
+  AASM.infect_an_assertion :assert_transition_to_allowed, :must_allow_transition_to, :do_not_flip
+  AASM.infect_an_assertion :refute_transition_to_allowed, :wont_allow_transition_to, :do_not_flip
+
+  AASM.infect_an_assertion :assert_have_state, :must_have_state, :do_not_flip
+  AASM.infect_an_assertion :refute_have_state, :wont_have_state, :do_not_flip
+
+  AASM.infect_an_assertion :assert_event_allowed, :must_allow_event, :do_not_flip
+  AASM.infect_an_assertion :refute_event_allowed, :wont_allow_event, :do_not_flip
+end