end_state 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c199657701bb9dec215e09e17d5e3e27d1d95d3e
-  data.tar.gz: 240681ba88cc834317071327063867828e994af0
+  metadata.gz: 56937726694a33d9ac097f1f224d5602bb9600c3
+  data.tar.gz: 6f3e4fcf53831c33e11e4fdbac2485a1d6fecd3a
 SHA512:
-  metadata.gz: 0728b393e7550ad3aa5833854b36c0c84089556c9e798c3ef9c9ac627989d48f4064225c9eedf8770bbdcc818f5991f37646ba3eaa4e784378cb0acebe37dd27
-  data.tar.gz: 5b4b5f3fd214558f7a1529015f23cea0ca12de44dc5c4c23663013d6cce49582c86c907dd5afda5816251a03430fc6861d78be36daf117e72fa743cca6042dd5
+  metadata.gz: 0c2afcefdfaaf9de627121c7e0d13494f4ca632718d79f82c55ee847d935cda7a56ddbf0fefbb4591c88d823d0fee1ba813010ac7631e1fa8b47a48d765ce56c
+  data.tar.gz: 3503000ac420f5746ab0a3389966151d5a1d7a10aefb5e4a438180fd7ab6017cbe5362bc551ce56d6def5c5cd1dccf2cc554c74cfcba3b09c684d46cb315b1bd

data/README.md

@@ -62,6 +62,17 @@ machine.go!                 # => :true
 machine.state               # => :b
 ```
 
+## Initial State
+
+If you wrap an object that currently has `nil` as the state, the state will be set to `:__nil__`.
+You can change this using the `set_initial_state` method.
+
+```ruby
+class Machine < EndState::StateMachine
+  set_initial_state :first
+end
+```
+
 ## Guards
 
 Guards can be created by subclassing `EndState::Guard`. Your class will be provided access to:
@@ -223,7 +234,7 @@ machine.failure_messages    # => ['Cannot go!']
 
 You may want to use an attribute other than `state` to track the state of the machine.
 
-```
+```ruby
 class Machine < EndState::StateMachine
   state_attribute :status
 end
@@ -232,7 +243,7 @@ end
 Depending on how you persist the `state` (if at all) you may want what is stored in `state` to be a string instead
 of a symbol. You can tell the machine this preference.
 
-```
+```ruby
 class Machine < EndState::StateMachine
   store_states_as_strings!
 end
@@ -240,13 +251,21 @@ end
 
 ## Exceptions for failing Transitions
 
-By default `transition` will only raise an exception, `EndState::UnknownState`, if called with a state that doesn't exist.
+By default `transition` will only raise an error, `EndState::UnknownState`, if called with a state that doesn't exist.
 All other failures, such as missing transition, guard failure, or finalizer failure will silently just return `false` and not
 transition to the new state.
 
 You also have the option to use `transition!` which will instead raise an error for failures. If your guards and/or finalizers
 add to the `failure_messages` array then they will be included in the error message.
 
+Additionally, if you would like to treat all transitions as hard and raise an error you can set that in the machine definition.
+
+```ruby
+class Machine < EndState::StateMachine
+  treat_all_transitions_as_hard!
+end
+```
+
 ## Graphing
 
 If you install `GraphViz` and the gem `ruby-graphviz` you can create images representing your state machines.

data/lib/end_state/errors.rb

@@ -2,6 +2,7 @@ module EndState
   class Error < StandardError; end
   class UnknownState < Error; end
   class UnknownTransition < Error; end
+  class InvalidEvent < Error; end
   class GuardFailed < Error; end
   class FinalizerFailed < Error; end
 end

data/lib/end_state/state_machine.rb

@@ -2,6 +2,30 @@ module EndState
   class StateMachine < SimpleDelegator
     attr_accessor :failure_messages, :success_messages
 
+    def initialize(object)
+      super
+      Action.new(self, self.class.initial_state).call if self.state.nil?
+    end
+
+    @initial_state = :__nil__
+    @mode = :soft
+
+    def self.initial_state
+      @initial_state
+    end
+
+    def self.set_initial_state(state)
+      @initial_state = state.to_sym
+    end
+
+    def self.treat_all_transitions_as_hard!
+      @mode = :hard
+    end
+
+    def self.mode
+      @mode
+    end
+
     def self.store_states_as_strings!
       @store_states_as_strings = true
     end
@@ -61,7 +85,7 @@ module EndState
       transition.will_allow? state, params
     end
 
-    def transition(state, params = {}, mode = :soft)
+    def transition(state, params = {}, mode = self.class.mode)
       @failure_messages = []
       @success_messages = []
       previous_state = self.state ? self.state.to_sym : self.state
@@ -80,10 +104,10 @@ module EndState
 
     def method_missing(method, *args, &block)
       check_state = method.to_s[0..-2].to_sym
+      return super unless is_state_or_event?(check_state)
       return current_state?(check_state) if method.to_s.end_with?('?')
       check_state = state_for_event(check_state) || check_state
       return false if check_state == :__invalid_event__
-      return super unless self.class.states.include?(check_state)
       if method.to_s.end_with?('!')
         transition check_state, args[0]
       else
@@ -93,6 +117,10 @@ module EndState
 
     private
 
+    def is_state_or_event?(check_state)
+      self.class.states.include?(check_state) or self.class.events[check_state]
+    end
+
     def current_state?(check_state)
       state.to_sym == check_state
     end
@@ -105,6 +133,7 @@ module EndState
     end
 
     def invalid_event(event)
+      fail InvalidEvent, "Transition by event: #{event} is invalid." if self.class.mode == :hard
       message = self.class.transitions[self.class.events[event].first].blocked_event_message
       @failure_messages = [message] if message
       :__invalid_event__

data/lib/end_state/version.rb

@@ -1,3 +1,3 @@
 module EndState
-  VERSION = '0.3.2'
+  VERSION = '0.4.0'
 end

data/spec/end_state/state_machine_spec.rb

@@ -9,6 +9,8 @@ module EndState
       StateMachine.instance_variable_set '@transitions'.to_sym, nil
       StateMachine.instance_variable_set '@events'.to_sym, nil
       StateMachine.instance_variable_set '@store_states_as_strings'.to_sym, nil
+      StateMachine.instance_variable_set '@initial_state'.to_sym, :__nil__
+      StateMachine.instance_variable_set '@mode'.to_sym, :soft
     end
 
     describe '.transition' do
@@ -97,7 +99,21 @@ module EndState
       end
     end
 
+    describe '.initial_state' do
+      context 'when set to :first' do
+        before { StateMachine.set_initial_state :first }
+
+        it 'has that initial state' do
+          expect(machine.state).to eq :first
+        end
+      end
+    end
+
     describe '#state' do
+      context 'when there is no state set' do
+        specify { expect(machine.state).to eq :__nil__ }
+      end
+
       context 'when the object has state :a' do
         let(:object) { OpenStruct.new(state: :a) }
 
@@ -140,6 +156,18 @@ module EndState
           specify { expect(machine.stop?).to be_true }
         end
       end
+
+      context 'when the requested predicate is not a state or event' do
+        module Predicate
+          def foo? ; :foo ; end
+        end
+
+        before { object.extend(Predicate) }
+
+        it 'call super up to SimpleDelegator, which handles the method' do
+          expect(machine.foo?).to eq(:foo)
+        end
+      end
     end
 
     describe '#{state}!' do
@@ -178,6 +206,14 @@ module EndState
           machine.go!
           expect(machine.failure_messages).to eq ['Invalid event!']
         end
+
+        context 'and all transitions are forced to run in :hard mode' do
+          before { machine.class.treat_all_transitions_as_hard! }
+
+          it 'raises an InvalidEvent error' do
+            expect { machine.go! }.to raise_error(InvalidEvent)
+          end
+        end
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: end_state
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - alexpeachey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-03 00:00:00.000000000 Z
+date: 2014-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler