finite_machine 0.11.3 → 0.12.0

data/.rspec

@@ -1,5 +0,0 @@
---color
---format progress
---order random
---warnings
---require spec_helper

data/.travis.yml

@@ -1,27 +0,0 @@
----
-language: ruby
-sudo: false
-cache: bundler
-bundler_args: --without yard benchmarks
-script: "bundle exec rake ci"
-rvm:
-  - 1.9.3
-  - 2.0
-  - 2.1
-  - 2.2
-  - 2.3.0
-  - ruby-head
-  - rbx-2
-matrix:
-  include:
-    - rvm: jruby-19mode
-    - rvm: jruby-20mode
-    - rvm: jruby-21mode
-    - rvm: jruby-head
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head
-    - rvm: rbx-2
-  fast_finish: true
-branches:
-  only: master

data/Gemfile

@@ -1,16 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-group :development do
-  gem 'pry',   '~> 0.10.1'
-  gem 'rspec', '~> 3.4.0'
-  gem 'rspec-benchmark', '~> 0.1.0'
-  gem 'yard',  '~> 0.8.7'
-end
-
-group :metrics do
-  gem 'coveralls', '~> 0.8.1'
-  gem 'simplecov', '~> 0.10.0'
-  gem 'yardstick', '~> 0.9.9'
-end

data/lib/finite_machine/async_proxy.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-module FiniteMachine
-  # An asynchronous messages proxy
-  #
-  # @api private
-  class AsyncProxy
-    include Threadable
-
-    attr_threadsafe :context
-
-    # The queue for asynchronoous events
-    #
-    # @return [EventQueue]
-    #
-    # @api private
-    attr_threadsafe :event_queue
-
-    # Initialize an AsynxProxy
-    #
-    # @param [Object] context
-    #   the context this proxy is associated with
-    #
-    # @api private
-    def initialize(context)
-      self.context     = context
-      self.event_queue = MessageQueue.new
-
-      ObjectSpace.define_finalizer(self, self.class.cleanup(event_queue))
-    end
-
-    # Delegate asynchronous event to event queue
-    #
-    # @api private
-    def method_missing(method_name, *args, &block)
-      callable   = Callable.new(method_name)
-      async_call = AsyncCall.new(context, callable, *args, &block)
-
-      event_queue.start unless event_queue.running?
-      context.event_queue << async_call
-    end
-
-    # Clean up event queue
-    #
-    # @api private
-    def self.cleanup(queue)
-      proc do
-        begin
-          queue && queue.shutdown
-        rescue MessageQueueDeadError
-        end
-      end
-    end
-  end # AsyncProxy
-end # FiniteMachine

data/spec/unit/async_events_spec.rb

@@ -1,107 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe FiniteMachine, 'async events' do
-
-  it 'runs events asynchronously' do
-    called = []
-    fsm = FiniteMachine.define do
-      initial :green
-
-      events {
-        event :slow,  :green  => :yellow
-        event :stop,  :yellow => :red
-        event :ready, :red    => :yellow
-        event :go,    :yellow => :green
-      }
-
-      callbacks {
-        on_enter :yellow do |event, a| called << "on_enter_yellow_#{a}" end
-        on_enter :red    do |event, a| called << "on_enter_red_#{a}" end
-      }
-    end
-
-    expect(fsm.current).to eql(:green)
-    fsm.async.slow(:foo)
-    fsm.event_queue.join 0.01
-    expect(fsm.current).to eql(:yellow)
-    expect(called).to eql([
-      'on_enter_yellow_foo'
-    ])
-    fsm.async(:stop, :bar) # execute directly
-    fsm.event_queue.join 0.01
-    expect(fsm.current).to eql(:red)
-    expect(called).to match_array([
-      'on_enter_yellow_foo',
-      'on_enter_red_bar'
-    ])
-  end
-
-  it 'correctly passes parameters to conditionals' do
-    called = []
-    fsm = FiniteMachine.define do
-      events {
-        event :go, :none => :green,
-              if: proc { |context, arg|
-                called << "cond_none_green(#{context},#{arg})"; true
-              }
-
-        event :stop, from: :any do
-          choice :red, if: proc { |context, arg|
-                         called << "cond_any_red(#{context},#{arg})"; true
-                       }
-        end
-      }
-    end
-    expect(fsm.current).to eql(:none)
-    fsm.async.go(:foo)
-    fsm.event_queue.join 0.02
-    expect(fsm.current).to eql(:green)
-    expect(called).to eql(["cond_none_green(#{fsm},foo)"])
-
-    expect(fsm.current).to eql(:green)
-    fsm.async.stop(:bar)
-    fsm.event_queue.join 0.02
-    expect(fsm.current).to eql(:red)
-    expect(called).to match_array([
-      "cond_none_green(#{fsm},foo)",
-      "cond_any_red(#{fsm},bar)"
-    ])
-  end
-
-  it "ensure queue per thread" do
-    called = []
-    fsmFoo = nil
-    fsmBar = nil
-    foo_thread = Thread.new {
-      fsmFoo = FiniteMachine.define do
-        initial :green
-        events { event :slow, :green => :yellow }
-
-        callbacks {
-          on_enter :yellow do |event, a| called << "(foo)on_enter_yellow_#{a}" end
-        }
-      end
-      fsmFoo.async.slow(:foo)
-    }
-    bar_thread = Thread.new {
-      fsmBar = FiniteMachine.define do
-        initial :green
-        events { event :slow, :green => :yellow }
-
-        callbacks {
-          on_enter :yellow do |event, a| called << "(bar)on_enter_yellow_#{a}" end
-        }
-      end
-      fsmBar.async.slow(:bar)
-    }
-    ThreadsWait.all_waits(foo_thread, bar_thread)
-    fsmFoo.event_queue.join(0.01)
-    fsmBar.event_queue.join(0.01)
-    expect(called).to match_array([
-      '(foo)on_enter_yellow_foo',
-      '(bar)on_enter_yellow_bar'
-    ])
-    expect(fsmFoo.current).to eql(:yellow)
-    expect(fsmBar.current).to eql(:yellow)
-  end
-end

data/spec/unit/events_chain/add_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain, '.add' do
-  it "adds transitions" do
-    transition = double(:transition)
-    events_chain = described_class.new
-
-    events_chain.add(:validated, transition)
-    expect(events_chain[:validated]).to eq([transition])
-
-    events_chain.add(:validated, transition)
-    expect(events_chain[:validated]).to eq([transition, transition])
-  end
-
-  it "allows to chain add operations" do
-    events_chain = described_class.new
-    transition = double(:transition)
-
-    events_chain.add(:go, transition).add(:start, transition)
-
-    expect(events_chain.size).to eq(2)
-  end
-end

data/spec/unit/events_chain/cancel_transitions_spec.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain, '.cancel_transitions' do
-  it "sets cancel status for chosen transitions" do
-    events_chain = described_class.new
-    transition_a = spy(:transition_a, cancelled: false)
-    transition_b = spy(:transition_b, cancelled: false)
-    transition_c = spy(:transition_c, cancelled: false)
-
-    events_chain.add(:start, transition_a)
-    events_chain.add(:start, transition_b)
-    events_chain.add(:finish, transition_c)
-
-    events_chain.cancel_transitions(:start)
-
-    expect(transition_a).to have_received(:cancelled=).with(true)
-    expect(transition_b).to have_received(:cancelled=).with(true)
-    expect(transition_c).not_to have_received(:cancelled=)
-  end
-end

data/spec/unit/events_chain/choice_transition_spec.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain, '.choice_transition?' do
-
-  it "checks if transition has many branches" do
-    transition_a = double(:transition_a, matches?: true)
-    transition_b = double(:transition_b, matches?: true)
-
-    events_chain = described_class.new
-    events_chain.add(:go, transition_a)
-    events_chain.add(:go, transition_b)
-
-    expect(events_chain.choice_transition?(:go, :green)).to eq(true)
-  end
-
-  it "checks that transition has no branches" do
-    transition_a = double(:transition_a, matches?: false)
-    transition_b = double(:transition_b, matches?: true)
-
-    events_chain = described_class.new
-    events_chain.add(:go, transition_a)
-    events_chain.add(:go, transition_b)
-
-    expect(events_chain.choice_transition?(:go, :green)).to eq(false)
-  end
-end

data/spec/unit/events_chain/clear_spec.rb

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

data/spec/unit/events_chain/events_spec.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain, '.events' do
-  it "has no event names" do
-    events_chain = described_class.new
-    expect(events_chain.events).to eq([])
-  end
-
-  it "returns all event names" do
-    events_chain = described_class.new
-    transition = double(:transition)
-    events_chain.add(:ready, transition)
-    events_chain.add(:go, transition)
-    expect(events_chain.events).to match_array([:ready, :go])
-  end
-end

data/spec/unit/events_chain/inspect_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain, '#inspect' do
-  it "inspects empty events chain" do
-    events_chain = described_class.new
-    expect(events_chain.inspect).to eq("<#FiniteMachine::EventsChain @chain={}>")
-  end
-
-  it "inspect events chain" do
-    transition = double(:transition)
-    events_chain = described_class.new
-    events_chain.add(:validated, transition)
-    expect(events_chain.inspect).to eq("<#FiniteMachine::EventsChain @chain=#{{validated: [transition]}}>")
-  end
-
-  it "prints events chain" do
-    transition = double(:transition)
-    events_chain = described_class.new
-    events_chain.add(:validated, transition)
-    expect(events_chain.to_s).to eq("#{{validated: [transition]}}")
-  end
-end

data/spec/unit/events_chain/states_for_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::EventsChain do
-  it "finds current states for event name" do
-    transition = spy(:transition, states: {:red => :yellow, :yellow => :green})
-    events_chain = described_class.new
-    events_chain.add(:start, transition)
-
-    expect(events_chain.states_for(:start)).to eq([:red, :yellow])
-  end
-
-  it "fails to find any states for event name" do
-    events_chain = described_class.new
-
-    expect(events_chain.states_for(:start)).to eq([])
-  end
-end

data/spec/unit/hook_event/infer_default_name_spec.rb

@@ -1,13 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe FiniteMachine::HookEvent, '#infer_default_name' do
-  it "infers default name for state" do
-    hook_event = described_class::Enter
-    expect(described_class.infer_default_name(hook_event)).to eq(:any)
-  end
-
-  it "infers default name for event" do
-    hook_event = described_class::Before
-    expect(described_class.infer_default_name(hook_event)).to eq(:any_event)
-  end
-end

data/spec/unit/state_parser/inspect_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe FiniteMachine::StateParser, "#inspect" do
-  let(:object) { described_class }
-
-  subject(:parser) { object.new(attrs) }
-
-  describe '#inspect' do
-    let(:attrs) { { green: :yellow } }
-
-    it "inspects parser" do
-      expect(parser.inspect).to eq("<#FiniteMachine::StateParser @attrs=green:yellow>")
-    end
-  end
-
-  describe '#to_s' do
-    let(:attrs) { { green: :yellow } }
-
-    it "prints parser attributes" do
-      expect(parser.to_s).to eq(attrs.to_s)
-    end
-  end
-end