composable_state_machine 1.0.2

data/lib/composable_state_machine/version.rb

@@ -0,0 +1,3 @@
+module ComposableStateMachine
+  VERSION = '1.0.2'
+end

data/spec/integration/auto_update_state_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe 'automatic state updates' do
+
+  class Room
+    MACHINE_MODEL = ComposableStateMachine.model(
+        transitions: {
+            heat: {cold: :warm, warm: :hot},
+            cool: {warm: :cold, hot: :warm},
+        }
+    )
+
+    attr_accessor :temp
+
+    def initialize(temp)
+      @machine = ComposableStateMachine::MachineWithExternalState.new(
+          MACHINE_MODEL, method(:temp), method(:temp=), state: temp)
+    end
+
+    def heat(periods = 1)
+      periods.times { @machine.trigger(:heat) }
+    end
+
+    def cool(periods = 1)
+      periods.times { @machine.trigger(:cool) }
+    end
+  end
+
+  it 'updates the room temperature automatically' do
+    Room.new(:cold).tap do |room|
+      room.heat(5)
+      room.temp.should eq :hot
+      room.cool
+      room.temp.should eq :warm
+    end
+  end
+
+end

data/spec/integration/instance_callbacks_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'callbacks binding to class instances' do
+
+  class Person1
+    include ComposableStateMachine::CallbackRunner
+
+    MACHINE_MODEL = ComposableStateMachine.model(
+        transitions: {
+            hire: {candidate: :hired, departed: :hired, fired: :hired},
+            leave: {hired: :departed},
+            fire: {hired: :fired},
+        },
+        behaviors: {
+            enter: {
+                hired: proc { puts "Welcome, #{@name}!" },
+                fired: proc { puts "Gee, #{@name}..." },
+            }
+        }
+    )
+
+    def initialize(name, state)
+      @name = name
+      @machine = ComposableStateMachine.machine(
+          MACHINE_MODEL,
+          state: state, callback_runner: self)
+    end
+
+    def hire!
+      @machine.trigger(:hire)
+      self
+    end
+
+    def fire!
+      @machine.trigger(:fire)
+      self
+    end
+  end
+
+  it 'runs callbacks in the context of the Person instance' do
+    STDOUT.should_receive(:puts).with('Welcome, Bob!')
+    STDOUT.should_receive(:puts).with('Gee, Bob...')
+
+    Person1.new('Bob', :candidate).hire!.fire!
+  end
+
+end

data/spec/integration/leave_callbacks_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe 'extending state machines with leave callbacks' do
+
+  class ModelWithLeaveCallbacks < ComposableStateMachine::Model
+    def run_callbacks(callback_runner, current_state, event, new_state, arguments)
+      run_callbacks_for(callback_runner, :leave, current_state,
+                        current_state, event, new_state, *arguments)
+      super
+    end
+  end
+
+  class Person2
+    include ComposableStateMachine::CallbackRunner
+
+    MACHINE_MODEL = ComposableStateMachine.model(
+        transitions: {
+            hire: {candidate: :hired, departed: :hired, fired: :hired},
+            leave: {hired: :departed},
+            fire: {hired: :fired},
+        },
+        behaviors: {
+            enter: {
+                hired: proc { puts "Welcome, #{@name}!" },
+                fired: proc { puts "Gee, #{@name}..." },
+            },
+            leave: {
+                fired: proc { puts 'Is this a good idea?' }
+            }
+        },
+        model_factory: ModelWithLeaveCallbacks
+    )
+
+    def initialize(name, state)
+      @name = name
+      @machine = ComposableStateMachine.machine(
+          MACHINE_MODEL,
+          state: state, callback_runner: self)
+    end
+
+    def hire!
+      @machine.trigger(:hire)
+      self
+    end
+
+    def fire!
+      @machine.trigger(:fire)
+      self
+    end
+  end
+
+  it 'runs callbacks in the context of the Person instance' do
+    STDOUT.should_receive(:puts).with('Welcome, Bob!').twice
+    STDOUT.should_receive(:puts).with('Gee, Bob...')
+    STDOUT.should_receive(:puts).with('Is this a good idea?')
+
+    Person2.new('Bob', :candidate).hire!.fire!.hire!
+  end
+
+end

data/spec/integration/leave_callbacks_with_composition_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe 'extending state machines with leave callbacks through composition' do
+
+  class ComposableModelWithLeaveCallbacks
+    delegate :initial_state, :callback_runner, to: :@model
+
+    def initialize(*args)
+      @model = ComposableStateMachine::Model.new(*args)
+    end
+
+    def transition(current_state, event, arguments = [], callback_runner = nil)
+      @model.transition(current_state, event, arguments, callback_runner) do |new_state|
+        @model.run_callbacks_for(callback_runner, :leave, current_state,
+                                 current_state, event, new_state, *arguments)
+        yield new_state if block_given?
+      end
+    end
+  end
+
+  class Person3
+    include ComposableStateMachine::CallbackRunner
+
+    MACHINE_MODEL = ComposableStateMachine.model(
+        transitions: {
+            hire: {candidate: :hired, departed: :hired, fired: :hired},
+            leave: {hired: :departed},
+            fire: {hired: :fired},
+        },
+        behaviors: {
+            enter: {
+                hired: proc { puts "Welcome, #{@name}!" },
+                fired: proc { puts "Gee, #{@name}..." },
+            },
+            leave: {
+                fired: proc { puts 'Is this a good idea?' }
+            }
+        },
+        model_factory: ComposableModelWithLeaveCallbacks
+    )
+
+    def initialize(name, state)
+      @name = name
+      @machine = ComposableStateMachine.machine(
+          MACHINE_MODEL,
+          state: state, callback_runner: self)
+    end
+
+    def hire!
+      @machine.trigger(:hire)
+      self
+    end
+
+    def fire!
+      @machine.trigger(:fire)
+      self
+    end
+  end
+
+  it 'runs callbacks in the context of the Person instance' do
+    STDOUT.should_receive(:puts).with('Welcome, Bob!').twice
+    STDOUT.should_receive(:puts).with('Gee, Bob...')
+    STDOUT.should_receive(:puts).with('Is this a good idea?')
+
+    Person3.new('Bob', :candidate).hire!.fire!.hire!
+  end
+
+end

data/spec/lib/composable_state_machine/behaviors_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe ComposableStateMachine::Behaviors do
+
+  describe 'initialization' do
+    it 'accepts callables for different behaviors' do
+      callable = proc {}
+      behaviors = described_class.new(enter: callable, leave: callable)
+
+      callable.should_receive(:call).twice
+
+      behaviors.call(nil, :enter)
+      behaviors.call(nil, :leave)
+    end
+
+    it 'creates callbacks from non-callables by default' do
+      func = proc{}
+
+      ComposableStateMachine::Callbacks.should_receive(:new).with({x: func})
+
+      described_class.new(enter: {x: func})
+    end
+
+    it 'accepts an alternative callbacks factory' do
+      func = proc{}
+      callbacks_factory = double(new: double)
+
+      callbacks_factory.should_receive(:new).with({x: func})
+
+      described_class.new({enter: {x: func}}, callbacks_factory)
+    end
+  end
+
+  describe '#on' do
+    it 'forwards to callbacks' do
+      func = proc{}
+      callbacks = ComposableStateMachine::Callbacks.new
+      behaviors = described_class.new(enter: callbacks)
+
+      callbacks.should_receive(:on).with(:a, func).once
+
+      behaviors.on(:enter, :a, func)
+      behaviors.on(:leave, :a, proc {})
+    end
+
+    it 'creates new callbacks for new behaviors' do
+      func = proc{}
+      ComposableStateMachine::Callbacks.tap do |callback_factory|
+        callback_factory.should_receive(:new).and_call_original
+        callback_factory.any_instance.should_receive(:on).with(:a, func)
+      end
+
+      behaviors = described_class.new
+      behaviors.on(:enter, :a, func)
+    end
+  end
+
+  describe '#call' do
+    it 'accepts unknown triggers' do
+      behaviors = described_class.new
+
+      expect do
+        behaviors.call(nil, :enter, :a)
+      end.not_to raise_error
+    end
+
+    it 'returns self' do
+      behaviors = described_class.new
+
+      behaviors.call(nil, :enter, :a).should eq behaviors
+    end
+
+    it 'passes any arguments to the callback' do
+      func = proc {}
+      behaviors = described_class.new(enter: func)
+
+      func.should_receive(:call).with(nil, :a, 1, 2, 3)
+
+      behaviors.call(nil, :enter, :a, 1, 2, 3)
+    end
+  end
+
+end

data/spec/lib/composable_state_machine/callback_runner_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe ComposableStateMachine::CallbackRunner do
+
+  context 'with callables' do
+    class TestClass
+      include ComposableStateMachine::CallbackRunner
+
+      def initialize(name)
+        @name = name
+        @callback = lambda { |greeting| "#{greeting}, #{@name}!" }
+      end
+
+      def test_callback(greeting)
+        run_state_machine_callback(@callback, greeting)
+      end
+    end
+
+    it 'runs callbacks in the context of the object' do
+      obj = TestClass.new('Bob')
+
+      obj.test_callback('Hello').should eq 'Hello, Bob!'
+    end
+  end
+
+  context 'with unbound methods' do
+    class TestClass
+      include ComposableStateMachine::CallbackRunner
+
+      def initialize(name)
+        @name = name
+      end
+
+      def test_callback(greeting)
+        run_state_machine_callback(CALLBACK_METHOD, greeting)
+      end
+
+      private
+
+      def greet(greeting)
+        "#{greeting}, #{@name}!"
+      end
+
+      CALLBACK_METHOD = instance_method(:greet)
+    end
+
+    it 'runs callbacks in the context of the object' do
+      obj = TestClass.new('Bob')
+
+      obj.test_callback('Hello').should eq 'Hello, Bob!'
+    end
+  end
+
+end

data/spec/lib/composable_state_machine/callbacks_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe ComposableStateMachine::Callbacks do
+
+  let(:runner) { ComposableStateMachine::DefaultCallbackRunner }
+
+  describe 'initialization' do
+    it 'accepts triggers and actions during initialization' do
+      func = proc {}
+      callbacks = described_class.new(a: func)
+
+      func.should_receive(:call)
+
+      callbacks.call(runner, :a)
+    end
+
+    it 'accepts more than one callback per trigger' do
+      func = proc {}
+      callbacks = described_class.new(a: [func, func, func])
+
+      func.should_receive(:call).exactly(3)
+
+      callbacks.call(runner, :a)
+    end
+  end
+
+  describe '#on' do
+    it 'accepts callables' do
+      func = proc {}
+      callbacks = described_class.new.
+          on(:a, func).
+          on(:b, func)
+
+      func.should_receive(:call).twice
+
+      callbacks.call(runner, :a)
+      callbacks.call(runner, :b)
+    end
+
+    it 'accepts blocks' do
+      func = proc {}
+      callbacks = described_class.new.
+          on(:a, &func)
+
+      func.should_receive(:call)
+
+      callbacks.call(runner, :a)
+    end
+  end
+
+  describe '#call' do
+    it 'accepts unknown triggers' do
+      callbacks = described_class.new
+
+      expect do
+        callbacks.call(runner, :unknown)
+      end.not_to raise_error
+    end
+
+    it 'returns self' do
+      callbacks = described_class.new
+
+      callbacks.call(runner, :unknown).should eq callbacks
+    end
+
+    it 'passes callbacks and their arguments to a runner' do
+      func = proc {}
+      callbacks = described_class.new.
+          on(:a, func)
+
+      runner.should_receive(:run_state_machine_callback).with(func, 1, 2, 3)
+
+      callbacks.call(runner, :a, 1, 2, 3)
+    end
+
+    it 'passes any arguments to the callback' do
+      func = proc {}
+      callbacks = described_class.new.
+          on(:a, func)
+
+      func.should_receive(:call).with(1, 2, 3)
+
+      callbacks.call(runner, :a, 1, 2, 3)
+    end
+
+    it 'calls the :any callbacks for every trigger' do
+      func = proc {}
+      callbacks = described_class.new.
+          on(:any, func).
+          on(:a, func)
+
+      func.should_receive(:call).with(1, 2, 3).twice
+
+      callbacks.call(runner, :a, 1, 2, 3)
+    end
+
+    it 'does not accept the :any trigger' do
+      callbacks = described_class.new
+
+      expect do
+        callbacks.call(runner, :any)
+      end.to raise_error ComposableStateMachine::InvalidTrigger
+    end
+  end
+
+end