finite_machine 0.0.1 → 0.1.0

data/spec/unit/initialize_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, 'initialize' do
+
+  it "defaults initial state to :none" do
+    fsm = FiniteMachine.define do
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+    end
+
+    expect(fsm.current).to eql(:none)
+  end
+
+  it "allows to specify inital state" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+  end
+
+  it "allows to specify deferred inital state" do
+    fsm = FiniteMachine.define do
+      initial state: :green, defer: true
+
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+    end
+
+    fsm.init
+    expect(fsm.current).to eql(:green)
+  end
+
+  it "allows to specify inital start event" do
+    fsm = FiniteMachine.define do
+      initial state: :green, event: :start
+
+      events {
+        event :slow, :green  => :yellow
+        event :stop, :yellow => :red
+      }
+    end
+
+    expect(fsm.current).to eql(:none)
+    fsm.start
+    expect(fsm.current).to eql(:green)
+  end
+end

data/spec/unit/is_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, 'is?' do
+
+  it "allows to check if state is reachable" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red
+        event :ready, :red    => :yellow
+        event :go,    :yellow => :green
+      }
+    end
+
+    expect(fsm.current).to eql(:green)
+
+    expect(fsm.is?(:green)).to be_true
+    expect(fsm.is?(:yellow)).to be_false
+    expect(fsm.is?([:green,  :red])).to be_true
+    expect(fsm.is?([:yellow, :red])).to be_false
+
+    fsm.slow
+
+    expect(fsm.is?(:green)).to be_false
+    expect(fsm.is?(:yellow)).to be_true
+    expect(fsm.is?([:green, :red])).to be_false
+    expect(fsm.is?([:yellow, :red])).to be_true
+  end
+end

data/spec/unit/states_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine, 'states' do
+
+  it "retrieves all available states" do
+    fsm = FiniteMachine.define do
+      initial :green
+
+      events {
+        event :slow,  :green  => :yellow
+        event :stop,  :yellow => :red
+        event :ready, :red    => :yellow
+        event :go,    :yellow => :green
+      }
+    end
+
+    expect(fsm.states).to eql([:none, :green, :yellow, :red])
+  end
+end

data/spec/unit/transition/parse_states_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe FiniteMachine::Transition, 'parse_states' do
+
+  let(:object) { described_class.new(attrs) }
+
+  subject(:transition) { object.parse_states(attrs) }
+
+  context 'with :from, :to keys' do
+    let(:attrs) { {from: [:green, :yellow], to: :red} }
+
+    it "groups states" do
+      expect(transition).to eql([[:green, :yellow], :red])
+    end
+  end
+
+  context 'when from array' do
+    let(:attrs) { {[:green, :yellow] => :red} }
+
+    it "groups states" do
+      expect(transition).to eql([[:green, :yellow], :red])
+    end
+  end
+
+  context 'when hash of states' do
+    let(:attrs) { { :green => :red, :yellow => :red} }
+
+    it "groups states" do
+      expect(transition).to eql([[:green, :yellow], :red])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: finite_machine
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-10 00:00:00.000000000 Z
+date: 2014-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -60,13 +60,34 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - finite_machine.gemspec
 - lib/finite_machine.rb
+- lib/finite_machine/callable.rb
+- lib/finite_machine/dsl.rb
+- lib/finite_machine/event.rb
+- lib/finite_machine/observer.rb
+- lib/finite_machine/state_machine.rb
+- lib/finite_machine/subscribers.rb
+- lib/finite_machine/threadable.rb
+- lib/finite_machine/transition.rb
 - lib/finite_machine/version.rb
+- spec/spec_helper.rb
+- spec/unit/callbacks_spec.rb
+- spec/unit/can_spec.rb
+- spec/unit/define_spec.rb
+- spec/unit/events_spec.rb
+- spec/unit/finished_spec.rb
+- spec/unit/if_unless_spec.rb
+- spec/unit/initialize_spec.rb
+- spec/unit/is_spec.rb
+- spec/unit/states_spec.rb
+- spec/unit/transition/parse_states_spec.rb
 homepage: ''
 licenses:
 - MIT
@@ -91,4 +112,15 @@ rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: A minimal finite state machine with a straightforward syntax.
-test_files: []
+test_files:
+- spec/spec_helper.rb
+- spec/unit/callbacks_spec.rb
+- spec/unit/can_spec.rb
+- spec/unit/define_spec.rb
+- spec/unit/events_spec.rb
+- spec/unit/finished_spec.rb
+- spec/unit/if_unless_spec.rb
+- spec/unit/initialize_spec.rb
+- spec/unit/is_spec.rb
+- spec/unit/states_spec.rb
+- spec/unit/transition/parse_states_spec.rb