finite_machine 0.10.2 → 0.11.0

data/lib/finite_machine/event.rb

@@ -1,146 +0,0 @@
-# encoding: utf-8
-
-module FiniteMachine
-  # A class representing event with transitions
-  #
-  # Used by {EventDefinition} to create events.
-  #
-  # @api private
-  class Event
-    include Comparable
-    include Threadable
-
-    # The name of this event
-    #
-    # @return [Symbol]
-    attr_threadsafe :name
-
-    # The state transitions for this event
-    #
-    # @return [Array[Transition]]
-    attr_threadsafe :state_transitions
-
-    # The reference to the state machine for this event
-    #
-    # @return [StateMachine]
-    attr_threadsafe :machine
-
-    # The silent option for this transition
-    #
-    # @return [Boolean]
-    attr_threadsafe :silent
-
-    # Initialize an Event
-    #
-    # @api private
-    def initialize(machine, attrs = {})
-      @machine = machine
-      @name    = attrs.fetch(:name, DEFAULT_STATE)
-      @silent  = attrs.fetch(:silent, false)
-      @state_transitions = []
-      # TODO: add event conditions
-      freeze
-    end
-
-    protected :machine
-
-    # Add transition for this event
-    #
-    # @param [FiniteMachine::Transition] transition
-    #
-    # @example
-    #   event << FiniteMachine::Transition.new machine, :a => :b
-    #
-    # @return [Event]
-    #
-    # @api public
-    def <<(transition)
-      sync_exclusive do
-        Array(transition).flatten.each { |trans| state_transitions << trans }
-      end
-      self
-    end
-    alias_method :add, :<<
-
-    # Find next transition
-    #
-    # @return [Transition]
-    #   the next available transition
-    #
-    # @api private
-    def next_transition
-      sync_shared do
-        state_transitions.find { |transition| transition.current? } ||
-        state_transitions.first
-      end
-    end
-
-    # Find transition matching conditions
-    #
-    # @param [Array[Object]] args
-    #
-    # return [Transition]
-    #
-    # @api private
-    def find_transition(*args)
-      sync_shared do
-        state_transitions.find do |trans|
-          trans.current? && trans.check_conditions(*args)
-        end
-      end
-    end
-
-    # Trigger this event
-    #
-    # If silent option is passed the event will not fire any callbacks
-    #
-    # @example
-    #   transition = Event.new(machine, {})
-    #   transition.trigger
-    #
-    # @return [Boolean]
-    #   true is transition succeeded, false otherwise
-    #
-    # @api public
-    def trigger(*args, &block)
-      sync_exclusive do
-        event_transition = next_transition
-        if silent
-          event_transition.execute(*args, &block)
-        else
-          machine.send(:transition, event_transition, *args, &block)
-        end
-      end
-    end
-
-    # Return event name
-    #
-    # @return [String]
-    #
-    # @api public
-    def to_s
-      name.to_s
-    end
-
-    # Return string representation
-    #
-    # @return [String]
-    #
-    # @api public
-    def inspect
-      "<##{self.class} @name=#{name}, @silent=#{silent}, " \
-      "@transitions=#{state_transitions.inspect}>"
-    end
-
-    # Compare whether the instance is greater, less then or equal to other
-    #
-    # @return [-1 0 1]
-    #
-    # @api public
-    def <=>(other)
-      other.is_a?(self.class) && [name, silent, state_transitions] <=>
-        [other.name, other.silent, other.state_transitions]
-    end
-    alias_method :eql?, :==
-  end # Event
-end # FiniteMachine

data/spec/unit/event/add_spec.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Event, '#<<' do
-  let(:machine) { double(:machine) }
-
-  let(:object) { described_class }
-
-  it "adds multiple transitions" do
-    transition = double(:transition)
-    event = object.new(machine)
-    event << transition << transition
-    expect(event.state_transitions).to match_array([transition, transition])
-  end
-end

data/spec/unit/event/eql_spec.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Event, 'eql?' do
-  let(:machine) { double(:machine) }
-  let(:name)    { :green }
-  let(:options) { {} }
-  let(:object)  { described_class }
-
-  subject(:event) { object.new(machine, options) }
-
-  context 'with the same object' do
-   let(:other) { event }
-
-    it "equals" do
-      expect(event).to eql(other)
-    end
-  end
-
-  context 'with an equivalent object' do
-    let(:other) { event.dup }
-
-    it "equals" do
-      expect(event).to eql(other)
-    end
-  end
-
-  context "with an object having different name" do
-    let(:other_name) { :red }
-    let(:other) { object.new(machine, {name: other_name}) }
-
-    it "doesn't equal" do
-      expect(event).to_not eql(other)
-    end
-  end
-end

data/spec/unit/event/initialize_spec.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Event, 'new' do
-  let(:machine) { double(:machine) }
-  let(:name)    { :green }
-  let(:options) { {} }
-  let(:object)  { described_class }
-
-  subject(:event) { object.new(machine, options) }
-
-  context "by default" do
-    it "sets name to :none" do
-      expect(event.name).to eql(:none)
-    end
-
-    it "sets silent to false"do
-      expect(event.silent).to eql(false)
-    end
-  end
-
-  context "with custom data" do
-    let(:options) { {silent: true, name: name} }
-
-    it "sets name to :green" do
-      expect(event.name).to eql(name)
-    end
-
-    it "sets silent to true"do
-      expect(event.silent).to eql(true)
-    end
-  end
-
-  it "freezes object" do
-    expect { event.name = :red }.to raise_error(RuntimeError)
-  end
-end

data/spec/unit/event/inspect_spec.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Event, '#inspect' do
-  let(:machine) { double(:machine) }
-
-  let(:object) { described_class }
-
-  subject(:event) { object.new(machine, name: :test) }
-
-  it "adds multiple transitions" do
-    transition = double(:transition)
-    event << transition
-    expect(event.inspect).to eq("<#FiniteMachine::Event @name=test, @silent=false, @transitions=[#{transition.inspect}]>")
-  end
-
-  it "prints event name" do
-    expect(event.to_s).to eq('test')
-  end
-end

data/spec/unit/event/next_transition_spec.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Event, '#next_transition' do
-  let(:object) { described_class }
-
-  subject(:event) { object.new(machine, name: :test) }
-
-  describe "matches transition by name" do
-    let(:machine) { double(:machine) }
-
-    it "finds matching transition" do
-      transition_a = double(:transition_a, current?: false)
-      transition_b = double(:transition_b, current?: true)
-      event << transition_a
-      event << transition_b
-
-      expect(event.next_transition).to eq(transition_b)
-    end
-  end
-
-  describe "fails to find" do
-    let(:machine) { double(:machine) }
-
-    it "choses first available transition" do
-      transition_a = double(:transition_a, current?: false)
-      transition_b = double(:transition_b, current?: false)
-      event << transition_a
-      event << transition_b
-
-      expect(event.next_transition).to eq(transition_a)
-    end
-  end
-end

data/spec/unit/events_chain/check_choice_conditions_spec.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain, '#clear' do
-  let(:object)  { described_class }
-
-  let(:machine) { double(:machine) }
-
-  subject(:chain) { object.new(machine) }
-
-  it "clears chain events" do
-    event = double(:event)
-    chain.add(:validated, event)
-    expect(chain.empty?).to be(false)
-
-    chain.clear
-    expect(chain.empty?).to be(true)
-  end
-end

data/spec/unit/events_chain/insert_spec.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain, '#insert' do
-  let(:object)  { described_class }
-
-  let(:machine) { double(:machine) }
-
-  let(:transition) { double(:transition) }
-
-  subject(:chain) { object.new(machine) }
-
-  it "inserts transition" do
-    event = double(:event)
-    chain.add(:validated, event)
-    expect(chain[:validated]).to eq(event)
-
-    expect(event).to receive(:<<).with(transition)
-    chain.insert(:validated, transition)
-  end
-
-  it "fails to insert transition" do
-    expect(chain.insert(:validated, transition)).to be false
-  end
-end

data/spec/unit/events_chain/select_transition_spec.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain, '#select_transition' do
-  let(:object)  { described_class }
-
-  let(:machine) { double(:machine) }
-
-  let(:transition) { double(:transition) }
-
-  subject(:chain) { object.new(machine) }
-
-  it "selects transition" do
-    event = double(:event)
-    args = double(:args)
-    chain.add(:validated, event)
-    expect(chain[:validated]).to eq(event)
-
-    expect(event).to receive(:find_transition).with(args)
-    chain.select_transition(:validated, args)
-  end
-end

data/spec/unit/transition/parse_states_spec.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::Transition, 'parsed_states' do
-  let(:machine) { double(:machine) }
-
-  subject(:transition) { described_class.new(machine, attrs) }
-
-  context 'with :to key only' do
-    let(:attrs) { { parsed_states: { any: :red } } }
-
-    it "groups states" do
-      expect(transition.from_states).to eq([:any])
-      expect(transition.to_states).to eq([:red])
-      expect(transition.states).to eql({any: :red})
-    end
-  end
-
-  context 'when from array' do
-    let(:attrs) { {parsed_states: { :green => :red, :yellow => :red} } }
-
-    it "groups states" do
-      expect(transition.from_states).to match_array([:green, :yellow])
-      expect(transition.to_states).to eql([:red, :red])
-    end
-  end
-
-  context 'when hash of states' do
-    let(:attrs) {
-      { parsed_states:
-        { :initial => :low,
-          :low     => :medium,
-          :medium  => :high } }
-     }
-
-    it "groups states" do
-      expect(transition.from_states).to match_array([:initial, :low, :medium])
-      expect(transition.to_states).to eql([:low, :medium, :high])
-    end
-  end
-end