micromachine 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 707ffde016887ae675ddd25388e8ca9376cb1547
-  data.tar.gz: 301bcfd9f251f538dbc5b170660e022f1aa6089c
+  metadata.gz: 695548d56ffdf4666ad19b2fb55af4a647f2f364
+  data.tar.gz: 4331c9df0cd25f86ccdadbfe6070fcfbd31a2d21
 SHA512:
-  metadata.gz: 2f2c63e4af76fe25a6aa7ecf16d3731f9513745a8fe74fb626961340edb63be2f5ded471194d0334b0c2f0581e7151e961ef98ad858c9b9e43ad37c54e2fc549
-  data.tar.gz: 8acbe242c04c4f96b6e981a8ef15275dbf6fdb5297dbb6120d7d55d0432ebe9e2f1a91f2f4bb5b6485bd71bde66ccc2b85b5db03d301e8bab5bc3586e2ffa290
+  metadata.gz: b98dae4b90be60013ad87c90db67d6c232fcc5632d038d47e691c85efb6ac5f63296f06dd94725988c36adb1715470484b5c42d87ce54c4f5bebbc3755822015
+  data.tar.gz: b7ed4f8bf6f5a2d62589e4acb964f0f5fec4b4a773cda49cbcc367bfacb077656fa3ec4504919218a3a5df55c6ad24296503f26504609139b342f370c6ee33d0

data/.gems

@@ -0,0 +1 @@
+cutest -v 1.2.2

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Michel Martens
+Copyright (c) 2009-2015 Michel Martens
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -62,6 +62,14 @@ machine.trigger?(:reset)   #=> true
 machine.state              #=> :ignored
 ```
 
+If you want to force an Exception when trying to trigger a event from a
+non compatible state use the `trigger!` method:
+
+``` ruby
+machine.trigger?(:ignore)  #=> false
+machine.trigger!(:ignore)  #=> MicroMachine::InvalidState raised
+```
+
 It can also have callbacks when entering some state:
 
 ``` ruby

data/examples/advanced.rb

@@ -0,0 +1,23 @@
+require 'micromachine'
+
+# This example can be run with ruby -I lib/ example/advanced.rb
+
+fsm = MicroMachine.new(:pending)
+
+fsm.when(:confirm,  :pending => :confirmed)
+fsm.when(:ignore,   :pending => :ignored)
+fsm.when(:reset,    :confirmed => :pending, :ignored => :pending)
+
+puts "Should print Confirmed, Pending and Ignored:"
+
+fsm.on(:any) do
+  puts fsm.state.capitalize
+end
+
+fsm.trigger(:confirm)
+
+fsm.trigger(:ignore)
+
+fsm.trigger(:reset)
+
+fsm.trigger(:ignore)

data/examples/basic.rb

@@ -0,0 +1,27 @@
+require 'micromachine'
+
+# This example can be run with ruby -I lib/ example/basic.rb
+
+fsm = MicroMachine.new(:pending)
+
+fsm.when(:confirm,  :pending => :confirmed)
+fsm.when(:ignore,   :pending => :ignored)
+fsm.when(:reset,    :confirmed => :pending, :ignored => :pending)
+
+puts "Should print Confirmed, Reset and Ignored:"
+
+if fsm.trigger(:confirm)
+  puts "Confirmed"
+end
+
+if fsm.trigger(:ignore)
+  puts "Ignored"
+end
+
+if fsm.trigger(:reset)
+  puts "Reset"
+end
+
+if fsm.trigger(:ignore)
+  puts "Ignored"
+end

data/examples/callbacks.rb

@@ -0,0 +1,31 @@
+require 'micromachine'
+
+# This example can be run with ruby -I lib/ example/callbacks.rb
+
+fsm = MicroMachine.new(:pending)
+
+fsm.when(:confirm,  :pending => :confirmed)
+fsm.when(:ignore,   :pending => :ignored)
+fsm.when(:reset,    :confirmed => :pending, :ignored => :pending)
+
+puts "Should print Confirmed, Reset and Ignored:"
+
+fsm.on(:confirmed) do
+  puts "Confirmed"
+end
+
+fsm.on(:ignored) do
+  puts "Ignored"
+end
+
+fsm.on(:pending) do
+  puts "Reset"
+end
+
+fsm.trigger(:confirm)
+
+fsm.trigger(:ignore)
+
+fsm.trigger(:reset)
+
+fsm.trigger(:ignore)

data/lib/micromachine.rb

@@ -1,16 +1,17 @@
 class MicroMachine
   InvalidEvent = Class.new(NoMethodError)
+  InvalidState = Class.new(ArgumentError)
 
   attr :transitions_for
   attr :state
 
-  def initialize initial_state
+  def initialize(initial_state)
     @state = initial_state
     @transitions_for = Hash.new
     @callbacks = Hash.new { |hash, key| hash[key] = [] }
   end
 
-  def on key, &block
+  def on(key, &block)
     @callbacks[key] << block
   end
 
@@ -18,17 +19,25 @@ class MicroMachine
     transitions_for[event] = transitions
   end
 
-  def trigger event
+  def trigger(event)
     if trigger?(event)
       @state = transitions_for[event][@state]
       callbacks = @callbacks[@state] + @callbacks[:any]
-      callbacks.each { |callback| callback.call }
+      callbacks.each { |callback| callback.call(event) }
       true
     else
       false
     end
   end
 
+  def trigger!(event)
+    if trigger(event)
+      true
+    else
+      raise InvalidState.new("Event '#{event}' not valid from state '#{@state}'")
+    end
+  end
+
   def trigger?(event)
     raise InvalidEvent unless transitions_for.has_key?(event)
     transitions_for[event][state] ? true : false

data/makefile

@@ -0,0 +1,5 @@
+.DEFAULT_GOAL := test
+.PHONY: test
+
+test:
+	cutest ./test/*.rb

data/micromachine.gemspec

@@ -1,11 +1,14 @@
 Gem::Specification.new do |s|
-  s.name = 'micromachine'
-  s.version = '1.1.0'
+  s.name = "micromachine"
+  s.version = "1.2.0"
   s.summary = %{Minimal Finite State Machine.}
   s.description = %Q{There are many finite state machine implementations for Ruby, and they all provide a nice DSL for declaring events, exceptions, callbacks, and all kinds of niceties in general.\n\nBut if all you want is a finite state machine, look no further: this has less than 50 lines of code and provides everything a finite state machine must have, and nothing more.}
-  s.author = "Michel Martens"
-  s.email = "michel@soveran.com"
+  s.author = ["Michel Martens"]
+  s.email = ["michel@soveran.com"]
   s.homepage = "http://github.com/soveran/micromachine"
-  s.files = Dir["lib/**/*.rb", "README*", "LICENSE", "Rakefile", "*.gemspec", "example/**/*.*"]
-  s.add_development_dependency 'contest'
+  s.license = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+
+  s.add_development_dependency "cutest"
 end

data/test/callbacks.rb

@@ -0,0 +1,44 @@
+require_relative "helper"
+
+setup do
+  machine = MicroMachine.new(:pending)
+  machine.when(:confirm, pending: :confirmed)
+  machine.when(:reset, confirmed: :pending)
+
+  machine.on(:pending)   { @state = "Pending" }
+  machine.on(:confirmed) { @state = "Confirmed" }
+  machine.on(:any)       { @current = @state }
+
+  machine
+end
+
+test "executes callbacks when entering a state" do |machine|
+  machine.trigger(:confirm)
+  assert_equal "Confirmed", @state
+
+  machine.trigger(:reset)
+  assert_equal "Pending", @state
+end
+
+test "executes the callback on any transition" do |machine|
+  machine.trigger(:confirm)
+  assert_equal "Confirmed", @current
+
+  machine.trigger(:reset)
+  assert_equal "Pending", @current
+end
+
+test "passing the event name to the callbacks" do
+  event_name = nil
+
+  machine = MicroMachine.new(:pending)
+  machine.when(:confirm, pending: :confirmed)
+
+  machine.on(:confirmed) do |event|
+    event_name = event
+  end
+
+  machine.trigger(:confirm)
+
+  assert_equal(:confirm, event_name)
+end

data/test/helper.rb

@@ -0,0 +1,2 @@
+require "cutest"
+require_relative "../lib/micromachine"

data/test/introspection.rb

@@ -0,0 +1,27 @@
+require_relative "helper"
+
+setup do
+  machine = MicroMachine.new(:pending)
+
+  machine.when(:confirm, pending: :confirmed)
+  machine.when(:ignore, pending: :ignored)
+  machine.when(:reset, confirmed: :pending, ignored: :pending)
+
+  machine
+end
+
+test "returns an array with the defined events" do |machine|
+  assert_equal [:confirm, :ignore, :reset], machine.events
+end
+
+test "returns an array with the defined states" do |machine|
+  assert_equal [:pending, :confirmed, :ignored], machine.states
+end
+
+test "returns false if compared state is not equal to current" do |machine|
+  assert !(machine == :confirmed)
+end
+
+test "returns true if compared state is equal to current" do |machine|
+  assert machine == :pending
+end

data/test/transitions.rb

@@ -0,0 +1,53 @@
+require_relative "helper"
+
+setup do
+  machine = MicroMachine.new(:pending)
+
+  machine.when(:confirm, pending: :confirmed)
+  machine.when(:ignore, pending: :ignored)
+  machine.when(:reset, confirmed: :pending, ignored: :pending)
+
+  machine
+end
+
+test "defines initial state" do |machine|
+  assert_equal :pending, machine.state
+end
+
+test "raises an error if an invalid event is triggered" do |machine|
+  assert_raise(MicroMachine::InvalidEvent) do
+    machine.trigger(:random_event)
+  end
+end
+
+test "preserves the state if transition is not possible" do |machine|
+  assert !machine.trigger?(:reset)
+  assert !machine.trigger(:reset)
+  assert_equal :pending, machine.state
+end
+
+test "changes the state if transition is possible" do |machine|
+  assert machine.trigger?(:confirm)
+  assert machine.trigger(:confirm)
+  assert_equal :confirmed, machine.state
+end
+
+test "discerns multiple transitions" do |machine|
+  machine.trigger(:confirm)
+  assert_equal :confirmed, machine.state
+
+  machine.trigger(:reset)
+  assert_equal :pending, machine.state
+
+  machine.trigger(:ignore)
+  assert_equal :ignored, machine.state
+
+  machine.trigger(:reset)
+  assert_equal :pending, machine.state
+end
+
+test "raises an error if event is triggered from/to a non complatible state" do |machine|
+  assert_raise(MicroMachine::InvalidState) do
+    machine.trigger!(:reset)
+  end
+end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: micromachine
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Michel Martens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-08 00:00:00.000000000 Z
+date: 2015-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: contest
+  name: cutest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -28,18 +28,28 @@ description: |-
   There are many finite state machine implementations for Ruby, and they all provide a nice DSL for declaring events, exceptions, callbacks, and all kinds of niceties in general.
 
   But if all you want is a finite state machine, look no further: this has less than 50 lines of code and provides everything a finite state machine must have, and nothing more.
-email: michel@soveran.com
+email:
+- michel@soveran.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/micromachine.rb
-- README.md
+- .gems
 - LICENSE
-- Rakefile
+- README.md
+- examples/advanced.rb
+- examples/basic.rb
+- examples/callbacks.rb
+- lib/micromachine.rb
+- makefile
 - micromachine.gemspec
+- test/callbacks.rb
+- test/helper.rb
+- test/introspection.rb
+- test/transitions.rb
 homepage: http://github.com/soveran/micromachine
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -57,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Minimal Finite State Machine.

data/Rakefile

@@ -1,8 +0,0 @@
-require 'rake/testtask'
-
-task :default => :test
-
-Rake::TestTask.new(:test) do |t|
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end