Class Base has 27 methods (exceeds 20 allowed). Consider refactoring.

Open

  class Base

    attr_reader :klass, :state_machine

    def initialize(klass, name, state_machine, options={}, &block)

Method _fire has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

    def _fire(obj, options={}, to_state=::AASM::NO_VALUE, *args)
      result = options[:test_only] ? false : nil
      clear_failed_callbacks
      transitions = @transitions.select { |t| t.from == obj.aasm(state_machine.name).current_state || t.from == nil}
      return result if transitions.size == 0

• Read up
  Read up

Method aasm_fired has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

  def aasm_fired(state_machine_name, event, old_state, new_state_name, options, *args)
    persist = options[:persist]

    new_state = aasm(state_machine_name).state_object_for_name(new_state_name)
    callback_args = process_args(event, aasm(state_machine_name).current_state, *args)

• Read up
  Read up

Method aasm_fired has 40 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  def aasm_fired(state_machine_name, event, old_state, new_state_name, options, *args)
    persist = options[:persist]

    new_state = aasm(state_machine_name).state_object_for_name(new_state_name)
    callback_args = process_args(event, aasm(state_machine_name).current_state, *args)

Method states has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    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

• Read up
  Read up

Method aasm has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def aasm(*args, &block)
      if args[0].is_a?(Symbol) || args[0].is_a?(String)
        # using custom name
        state_machine_name = args[0].to_sym
        options = args[1] || {}

• Read up
  Read up

Method state has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def state(*args)
      names, options = interpret_state_args(args)
      names.each do |name|
        @state_machine.add_state(name, klass, options)

• Read up
  Read up

Method load_persistence has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      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")

• Read up
  Read up

Method aasm_ensure_initial_state has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

        def aasm_ensure_initial_state
          AASM::StateMachineStore.fetch(self.class, true).machine_names.each do |state_machine_name|
            attribute_name = self.class.aasm(state_machine_name).attribute_name.to_s
            # Do not load initial state when object attributes are not loaded,
            # mongoid has_many relationship does not load child object attributes when

• Read up
  Read up

Method register has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    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

• Read up
  Read up

Method aasm_fired has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

  def aasm_fired(state_machine_name, event, old_state, new_state_name, options, *args)

Method initialize has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def initialize(klass, name, state_machine, options={}, &block)

Method aasm_fire_event has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

  def aasm_fire_event(state_machine_name, event_name, options, *args, &block)

Method aasm_fire_event has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

      def aasm_fire_event(state_machine_name, name, options, *args, &block)

Method aasm_fire_event has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      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)

• Read up
  Read up

Method aasm_fire_event has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  def aasm_fire_event(state_machine_name, event_name, options, *args, &block)
    event = self.class.aasm(state_machine_name).state_machine.events[event_name]
    begin
      old_state = aasm(state_machine_name).state_object_for_name(aasm(state_machine_name).current_state)

• Read up
  Read up

Method aasm_transaction has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

        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!

• Read up
  Read up

Method aasm_read_state has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

      def aasm_read_state(name=:default)
        state = send(self.class.aasm(name).attribute_name)
        if !state || state.empty?
          aasm_new_record? ? aasm(name).determine_state_name(self.class.aasm(name).initial_state) : nil
        else

• Read up
  Read up

Method aasm_write_state has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

      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

• Read up
  Read up