finite_machine 0.6.1 → 0.7.0

data/spec/unit/define_spec.rb

@@ -46,7 +46,9 @@ describe FiniteMachine, 'define' do
 
       expect(fsm.current).to eql(:green)
       fsm.slow
+      expect(fsm.current).to eql(:yellow)
       fsm.ready
+      expect(fsm.current).to eql(:yellow)
       expect(called).to match_array(['on_enter_yellow', 'error_handler'])
     end
   end

data/spec/unit/event/add_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Event, '#<<' 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
+    event << transition
+    expect(event.state_transitions).to match_array([transition, transition])
+  end
+end

data/spec/unit/event/inspect_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+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, @transitions=[#{transition.inspect}]>")
+  end
+end

data/spec/unit/event/next_transition_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+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, current: :b) }
+
+    it "finds matching transition" do
+      transition_a = double(:transition_a, from_state: :a)
+      transition_b = double(:transition_b, from_state: :b)
+      event << transition_a
+      event << transition_b
+
+      expect(event.next_transition).to eq(transition_b)
+    end
+  end
+
+  describe "matches :any transition" do
+    let(:machine) { double(:machine, current: :any) }
+
+    it "finds matching transition" do
+      transition_a   = double(:transition_a, from_state: :a)
+      transition_any = double(:transition_any, from_state: :any)
+      event << transition_a
+      event << transition_any
+
+      expect(event.next_transition).to eq(transition_any)
+    end
+  end
+
+  describe "fails to find" do
+    let(:machine) { double(:machine, current: :c) }
+
+    it "choses first available transition" do
+      transition_a = double(:transition_a, from_state: :a)
+      transition_b = double(:transition_b, from_state: :b)
+      event << transition_a
+      event << transition_b
+
+      expect(event.next_transition).to eq(transition_a)
+    end
+  end
+end

data/spec/unit/events_spec.rb

@@ -291,8 +291,8 @@ describe FiniteMachine, 'events' do
       }
 
       callbacks {
-        on_enter(:drive) { }
-        on_exit(:stop)   { }
+        on_before(:drive) { }
+        on_after(:stop)   { }
       }
     end
 
@@ -302,4 +302,43 @@ describe FiniteMachine, 'events' do
     expect(fsm.stop).to eql(FiniteMachine::SUCCEEDED)
     expect(fsm.stop).to eql(FiniteMachine::NOTRANSITION)
   end
+
+  it "allows for self transition events" do
+    digits = []
+    callbacks = []
+    phone = FiniteMachine.define do
+      initial :on_hook
+
+      events {
+        event :digit,    :on_hook => :dialing
+        event :digit,    :dialing => :dialing
+        event :off_hook, :dialing => :alerting
+      }
+
+      callbacks {
+        on_before_digit { |event, digit| digits << digit}
+        on_before_off_hook { |event| callbacks << "dialing #{digits.join}" }
+      }
+    end
+
+    expect(phone.current).to eq(:on_hook)
+    phone.digit(9)
+    expect(phone.current).to eq(:dialing)
+    phone.digit(1)
+    expect(phone.current).to eq(:dialing)
+    phone.digit(1)
+    expect(phone.current).to eq(:dialing)
+    phone.off_hook
+    expect(phone.current).to eq(:alerting)
+    expect(digits).to match_array(digits)
+    expect(callbacks).to match_array(["dialing 911"])
+  end
+
+  it "detects dangerous event names" do
+    expect { FiniteMachine.define do
+      events {
+        event :transition, :a => :b
+      }
+    end }.to raise_error(FiniteMachine::AlreadyDefinedError)
+  end
 end

data/spec/unit/hooks/call_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Hooks, '#call' do
+  let(:object) { described_class }
+
+  subject(:hooks) { object.new }
+
+  it "adds and removes a single hook" do
+    expect(hooks).to be_empty
+
+    yielded = []
+    event_type = FiniteMachine::HookEvent::Before
+    hook = -> { }
+    hooks.register(event_type, :foo, hook)
+
+    hooks.call(event_type, :foo) do |callback|
+      yielded << callback
+    end
+
+    expect(yielded).to eq([hook])
+  end
+end

data/spec/unit/hooks/inspect_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Hooks, '#inspect' do
+  subject(:hooks) { described_class.new }
+
+  it "displays name and transitions" do
+    hook = -> { }
+    event = FiniteMachine::HookEvent::Enter
+    collection = {event => {yellow: [hook]}}
+    hooks.register(event, :yellow, hook)
+
+    expect(hooks.inspect).to eql("<#FiniteMachine::Hooks:0x#{hooks.object_id.to_s(16)} @collection=#{collection}>")
+    expect(hooks.to_s).to eql(hooks.inspect)
+  end
+end

data/spec/unit/hooks/register_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Hooks, '#register' do
+  let(:object) { described_class }
+
+  subject(:hooks) { object.new }
+
+  it "adds and removes a single hook" do
+    expect(hooks).to be_empty
+
+    event_type = FiniteMachine::HookEvent::Before
+    hook = -> { }
+
+    hooks.register(event_type, :foo, hook)
+    expect(hooks.collection).to eq({event_type => {foo: [hook]}})
+
+    hooks.unregister(event_type, :foo, hook)
+    expect(hooks.collection).to eq({event_type => {foo: []}})
+  end
+end

data/spec/unit/if_unless_spec.rb

@@ -223,4 +223,32 @@ describe FiniteMachine, ':if, :unless' do
       expect(fsm.current).to eql(:one)
     end
   end
+
+  context 'when same event name' do
+    class Bug
+      def pending?
+        false
+      end
+    end
+
+    it "preservers conditions for the same named event" do
+      bug = Bug.new
+      fsm = FiniteMachine.define do
+        initial :initial
+
+        target bug
+
+        events {
+          event :bump, :initial => :low
+          event :bump, :low     => :medium, if: :pending?
+          event :bump, :medium  => :high
+        }
+      end
+      expect(fsm.current).to eq(:initial)
+      fsm.bump
+      expect(fsm.current).to eq(:low)
+      fsm.bump
+      expect(fsm.current).to eq(:low)
+    end
+  end
 end

data/spec/unit/inspect_spec.rb

@@ -2,24 +2,17 @@
 
 require 'spec_helper'
 
-describe FiniteMachine::Transition, 'inspect' do
-  let(:machine) { double }
+describe FiniteMachine, '#inspect' do
 
-  subject(:transition) { described_class.new(machine, attrs) }
+  it "print useful information about state machine" do
+    fsm = FiniteMachine.define do
+      initial :green
 
-  context 'when inspecting' do
-    let(:attrs) { {name: :start, :foo => :bar, :baz => :daz} }
-
-    it "displays name and transitions" do
-      expect(transition.inspect).to eql("<#FiniteMachine::Transition @name=start, @transitions=foo -> bar, baz -> daz, @when=[]>")
-    end
-  end
-
-  context 'when converting to string' do
-    let(:attrs) { {name: :start, :foo => :bar } }
-
-    it "displays name and transitions" do
-      expect(transition.to_s).to eql("start")
+      events {
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red
+      }
     end
+    expect(fsm.inspect).to match(/^<#FiniteMachine::StateMachine:0x#{fsm.object_id.to_s(16)} @states=\[:none, :green, :yellow, :red\], @events=\[:init, :slow, :stop\], @transitions=.*$/)
   end
 end

data/spec/unit/respond_to_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, '#respond_to' do
+
+  subject(:fsm) {
+    Car = Class.new do
+      def engine_on?
+        true
+      end
+    end
+    FiniteMachine.new target: Car.new do
+      initial :green
+
+      events {
+        event :slow,  :green  => :yellow
+      }
+    end
+  }
+
+  it "knows about event name" do
+    expect(fsm).to respond_to(:slow)
+  end
+
+  it "doesn't know about not implemented call" do
+    expect(fsm).not_to respond_to(:not_implemented)
+  end
+
+  it "knows about event callback" do
+    expect(fsm).to respond_to(:on_enter_slow)
+  end
+
+  it "knows about target class methods" do
+    expect(fsm).to respond_to(:engine_on?)
+  end
+end

data/spec/unit/target_spec.rb

@@ -133,7 +133,7 @@ describe FiniteMachine, '#target' do
               turn_reverse_lights_on
               forward('Piotr!')
             end
-            on_enter :forward do |event, name|
+            on_before :forward do |event, name|
               called << "on_enter_forward with #{name}"
             end
           }

data/spec/unit/transition/inspect_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Transition, '#inspect' do
+  let(:machine) { double(:machine) }
+
+  subject(:transition) { described_class.new(machine, attrs) }
+
+  context 'when inspecting' do
+    let(:attrs) { {name: :start, parsed_states: { :foo => :bar, :baz => :daz } } }
+
+    it "displays name and transitions" do
+      expect(transition.inspect).to eql("<#FiniteMachine::Transition @name=start, @transitions=foo -> bar, baz -> daz, @when=[]>")
+    end
+  end
+
+  context 'when converting to string' do
+    let(:attrs) { {name: :start, parsed_states: { :foo => :bar } } }
+
+    it "displays name and transitions" do
+      expect(transition.to_s).to eql("start")
+    end
+  end
+end

data/spec/unit/transition/parse_states_spec.rb

@@ -2,22 +2,13 @@
 
 require 'spec_helper'
 
-describe FiniteMachine::Transition, 'parse_states' do
-
-  let(:machine) { double }
+describe FiniteMachine::Transition, 'parsed_states' do
+  let(:machine) { double(:machine) }
 
   subject(:transition) { described_class.new(machine, attrs) }
 
-  context 'without transitions' do
-    let(:attrs) { { } }
-
-    it "raises exception" do
-      expect { transition }.to raise_error(FiniteMachine::NotEnoughTransitionsError)
-    end
-  end
-
   context 'with :to key only' do
-    let(:attrs) { { to: :red } }
+    let(:attrs) { { parsed_states: { any: :red } } }
 
     it "groups states" do
       expect(transition.from_states).to eq([:any])
@@ -26,17 +17,8 @@ describe FiniteMachine::Transition, 'parse_states' do
     end
   end
 
-  context 'with :from, :to keys' do
-    let(:attrs) { {from: [:green, :yellow], to: :red} }
-
-    it "groups states" do
-      expect(transition.from_states).to match_array(attrs[:from])
-      expect(transition.to_states).to match_array([:red, :red])
-    end
-  end
-
   context 'when from array' do
-    let(:attrs) { {[:green, :yellow] => :red} }
+    let(:attrs) { {parsed_states: { :green => :red, :yellow => :red} } }
 
     it "groups states" do
       expect(transition.from_states).to match_array([:green, :yellow])
@@ -46,9 +28,10 @@ describe FiniteMachine::Transition, 'parse_states' do
 
   context 'when hash of states' do
     let(:attrs) {
-      { :initial => :low,
-        :low     => :medium,
-        :medium  => :high }
+      { parsed_states:
+        { :initial => :low,
+          :low     => :medium,
+          :medium  => :high } }
      }
 
     it "groups states" do

metadata

@@ -1,27 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: finite_machine
 version: !ruby/object:Gem::Version
-  version: 0.6.1
-  prerelease: 
+  version: 0.7.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-10 00:00:00.000000000 Z
+date: 2014-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2157086980 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
-  version_requirements: *2157086980
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
 description: A minimal finite state machine with a straightforward syntax. You can
   quickly model states, add callbacks and use object-oriented techniques to integrate
   with ORMs.
@@ -52,10 +54,12 @@ files:
 - lib/finite_machine/dsl.rb
 - lib/finite_machine/event.rb
 - lib/finite_machine/event_queue.rb
+- lib/finite_machine/hook_event.rb
 - lib/finite_machine/hooks.rb
 - lib/finite_machine/listener.rb
 - lib/finite_machine/logger.rb
 - lib/finite_machine/observer.rb
+- lib/finite_machine/safety.rb
 - lib/finite_machine/state_machine.rb
 - lib/finite_machine/state_parser.rb
 - lib/finite_machine/subscribers.rb
@@ -70,20 +74,28 @@ files:
 - spec/unit/callbacks_spec.rb
 - spec/unit/can_spec.rb
 - spec/unit/define_spec.rb
+- spec/unit/event/add_spec.rb
+- spec/unit/event/inspect_spec.rb
+- spec/unit/event/next_transition_spec.rb
 - spec/unit/event_queue_spec.rb
 - spec/unit/events_spec.rb
 - spec/unit/finished_spec.rb
 - spec/unit/handlers_spec.rb
+- spec/unit/hooks/call_spec.rb
+- spec/unit/hooks/inspect_spec.rb
+- spec/unit/hooks/register_spec.rb
 - spec/unit/if_unless_spec.rb
 - spec/unit/initialize_spec.rb
 - spec/unit/inspect_spec.rb
 - spec/unit/is_spec.rb
 - spec/unit/logger_spec.rb
+- spec/unit/respond_to_spec.rb
 - spec/unit/state_parser/inspect_spec.rb
 - spec/unit/state_parser/parse_states_spec.rb
 - spec/unit/states_spec.rb
 - spec/unit/subscribers_spec.rb
 - spec/unit/target_spec.rb
+- spec/unit/transition/inspect_spec.rb
 - spec/unit/transition/parse_states_spec.rb
 - tasks/console.rake
 - tasks/coverage.rake
@@ -91,33 +103,26 @@ files:
 homepage: https://github.com/peter-murach/finite_machine
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2682862058566322230
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2682862058566322230
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A minimal finite state machine with a straightforward syntax.
 test_files:
 - spec/spec_helper.rb
@@ -126,19 +131,27 @@ test_files:
 - spec/unit/callbacks_spec.rb
 - spec/unit/can_spec.rb
 - spec/unit/define_spec.rb
+- spec/unit/event/add_spec.rb
+- spec/unit/event/inspect_spec.rb
+- spec/unit/event/next_transition_spec.rb
 - spec/unit/event_queue_spec.rb
 - spec/unit/events_spec.rb
 - spec/unit/finished_spec.rb
 - spec/unit/handlers_spec.rb
+- spec/unit/hooks/call_spec.rb
+- spec/unit/hooks/inspect_spec.rb
+- spec/unit/hooks/register_spec.rb
 - spec/unit/if_unless_spec.rb
 - spec/unit/initialize_spec.rb
 - spec/unit/inspect_spec.rb
 - spec/unit/is_spec.rb
 - spec/unit/logger_spec.rb
+- spec/unit/respond_to_spec.rb
 - spec/unit/state_parser/inspect_spec.rb
 - spec/unit/state_parser/parse_states_spec.rb
 - spec/unit/states_spec.rb
 - spec/unit/subscribers_spec.rb
 - spec/unit/target_spec.rb
+- spec/unit/transition/inspect_spec.rb
 - spec/unit/transition/parse_states_spec.rb
 has_rdoc: