simply_fsm 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aba0392debc9515f01b6b95bca88ed5c3a4aace120a3b725c4d1a840854a1725
-  data.tar.gz: 1d7883abe1ce6b0db890203293ea4f3ff2ab275fb876628daf07fb0f9ea087d6
+  metadata.gz: eb54d24c49d69bc4cb382e6c4181a586fe9eef471dd1e44bcef0d95555fb33ae
+  data.tar.gz: 2f336e971e10827c1b731948376b4f2a177e012093c3f66457380df21c0f110c
 SHA512:
-  metadata.gz: 9320692222abae9ec39bebf5b5594f023d97efecec721d400f6aacb5ed758cf0e02d23fc4e5845d604a0ec39682de16d7e919d8024ce69f762722cf134d1243b
-  data.tar.gz: c1552d33ce0b9e1d682e7e1d7cbbc7cd6ec59fbc4435d63582f67735f6a75cb0fe114910266624aee241f694aa77c2031634351466b798563981fc71f112ef71
+  metadata.gz: 9afdd28a4281a6d6c4d40abe7d52e5ab674e9bf1e626a9bc2bf47ee678e047f0fd3c4e5ab3f6857a01fc6fd6647a5eab416a6cc1c03f7ebbbdda1a72b6b1d71b
+  data.tar.gz: 21c938cbced1efb61d61c0cc62c4887d1f8084c4b42c6bc2effd0cda358a9cbade73a958250fdb9d81a17a183ed2b092e7d6896ae043fc1dfcc2afa7c9914134

data/.gitignore

@@ -3,6 +3,7 @@
 /_yardoc/
 /coverage/
 /doc/
+/rdoc/
 /pkg/
 /spec/reports/
 /tmp/

data/.rubocop.yml

@@ -1,6 +1,10 @@
 AllCops:
   TargetRubyVersion: 2.7
 
+Naming/FileName:
+  Exclude:
+    - Rakefile
+
 Style/StringLiterals:
   Enabled: true
   EnforcedStyle: double_quotes
@@ -11,3 +15,13 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+
+Metrics/MethodLength:
+  Max: 16
+
+Metrics/ClassLength:
+  Max: 256
+  
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+- None right now
+
+## [0.2.0] - 2022-03-01
+
+- *Breaks API* (sorry!)
+  - When declaring events in a state machine, use `transitions:` (as in "transitions from X to Y") instead of `transition:`
+- Added support for multiple transitions per event
+
+## [0.1.2] - 2022-02-28
+
+- Cleaned up source with smaller clearer methods
+- Added `rdoc` support, include `rake rdoc` task
+
+## [0.1.1] - 2022-02-21
+
+- Separated version file, fixed URLs in Gem spec, added badge to README
+
 ## [0.1.0] - 2022-02-21
 
 - Initial release supports finite state machine with event guards and failure handling 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simply_fsm (0.1.0)
+    simply_fsm (0.1.1)
 
 GEM
   remote: https://rubygems.org/
@@ -11,8 +11,12 @@ GEM
     parallel (1.21.0)
     parser (3.1.1.0)
       ast (~> 2.4.1)
+    psych (4.0.3)
+      stringio
     rainbow (3.1.1)
     rake (13.0.6)
+    rdoc (6.4.0)
+      psych (>= 4.0.0)
     regexp_parser (2.2.1)
     rexml (3.2.5)
     rspec (3.11.0)
@@ -40,6 +44,7 @@ GEM
     rubocop-ast (1.15.2)
       parser (>= 3.0.1.1)
     ruby-progressbar (1.11.0)
+    stringio (3.0.1)
     unicode-display_width (2.1.0)
 
 PLATFORMS
@@ -47,6 +52,7 @@ PLATFORMS
 
 DEPENDENCIES
   rake (~> 13.0)
+  rdoc
   rspec (~> 3.0)
   rubocop (~> 1.21)
   simply_fsm!

data/README.md

@@ -1,5 +1,7 @@
 # SimplyFSM
 
+[![Gem Version](https://badge.fury.io/rb/simply_fsm.svg)](https://badge.fury.io/rb/simply_fsm)
+
 `simply_fsm` is a bare-necessities finite state machine data-type for use with any Ruby class. I created `simply_fsm` because I wanted the minimal FSM data type that was easy to use and did everything I would expect from a core data type.
 
 If you need storage/persistence/Rails/etc support, I recommend [AASM](https://github.com/aasm/aasm) whose API was an inspiration for this gem.  
@@ -11,6 +13,7 @@ If you need storage/persistence/Rails/etc support, I recommend [AASM](https://gi
   - [Multiple state machines](#multiple-state-machines)
   - [Handle failed events](#handle-failed-events)
   - [Guarding events](#guarding-events)
+  - [Multiple transitions for an event](#multiple-transitions-for-an-event)
 - [Development](#development)
 - [Contributing](#contributing)
 - [License](#license)
@@ -47,15 +50,15 @@ class Job
     state :running
     state :cleaning
 
-    event :run, transition: { from: :sleeping, to: :running } do
+    event :run, transitions: { from: :sleeping, to: :running } do
       # executed when transition succeeds
     end
 
-    event :clean, transition: { from: :running, to: :cleaning } do
+    event :clean, transitions: { from: :running, to: :cleaning } do
       # do the cleaning since transition succeeded
     end
 
-    event :sleep, transition: { from: [:running, :cleaning], to: :sleeping }
+    event :sleep, transitions: { from: [:running, :cleaning], to: :sleeping }
   end
 end
 ```
@@ -86,16 +89,16 @@ class Player
     state :idling, initial: true
     state :walking
 
-    event :idle, transition: { from: :any, to: :idling }
-    event :walk, transition: { from: :idling, to: :walking }
+    event :idle, transitions: { from: :any, to: :idling }
+    event :walk, transitions: { from: :idling, to: :walking }
   end
 
   state_machine :action do
     state :ready, initial: true
     state :blocking
 
-    event :hold, transition: { from: :any, to: :ready }
-    event :block, transition: { from: :any, to: :blocking }
+    event :hold, transitions: { from: :any, to: :ready }
+    event :block, transitions: { from: :any, to: :blocking }
   end
 end
 ```
@@ -124,11 +127,11 @@ class JobWithErrors
     state :running
     state :cleaning
 
-    event :sleep, transition: { from: %i[running cleaning], to: :sleeping }
-    event :clean, transition: { from: :running, to: :cleaning }
+    event :sleep, transitions: { from: %i[running cleaning], to: :sleeping }
+    event :clean, transitions: { from: :running, to: :cleaning }
     event :run,
           fail: ->(_event) { raise RunError, "Cannot run" },
-          transition: { from: :sleeping, to: :running }
+          transitions: { from: :sleeping, to: :running }
   end
 
   def on_any_fail(event_name)
@@ -152,9 +155,9 @@ class AgilePlayer
     state :walking
     state :running
 
-    event :idle, transition: { from: :any, to: :idling }
-    event :walk, transition: { from: :any, to: :walking }
-    event :run, transition: { from: :any, to: :running }
+    event :idle, transitions: { from: :any, to: :idling }
+    event :walk, transitions: { from: :any, to: :walking }
+    event :run, transitions: { from: :any, to: :running }
   end
 
   state_machine :action do
@@ -162,14 +165,45 @@ class AgilePlayer
     state :jumping
     state :leaping
 
-    event :hold, transition: { from: :any, to: :ready }
+    event :hold, transitions: { from: :any, to: :ready }
     event :jump,
           guard: -> { !running? },
-          transition: { from: :ready, to: :jumping }
+          transitions: { from: :ready, to: :jumping }
     event :leap,
           guard: -> { running? },
           fail: ->(_event) { raise LeapError, "Cannot leap" },
-          transition: { from: :ready, to: :leaping }
+          transitions: { from: :ready, to: :leaping }
+  end
+end
+```
+### Multiple transitions for an event
+
+Sometimes a single event can transition to different end states based on different input states. In those situations you can specify an array of transitions. Consider the following example where the `hunt` event transitions to `walking` or `running` depending on some condition outside the state machine.
+
+```ruby
+class Critter
+  include SimplyFSM
+
+  def tired?
+    @ate_at <= 12.hours.ago || @slept_at <= 24.hours.ago
+  end
+
+  state_machine :activity do
+    state :sleeping, initial: true
+    state :running
+    state :walking
+    state :eating
+
+    event :eat, transitions: { to: :eating } do
+      @ate_at = DateTime.new
+    end
+    event :sleep, transitions: { from: :eating, to: :sleeping } do
+      @slept_at = DateTime.new
+    end
+    event :hunt, transitions: [
+      { when: -> { tired? }, to: :walking },
+      { to: :running }
+    ]
   end
 end
 ```

data/Rakefile

@@ -7,6 +7,16 @@ RSpec::Core::RakeTask.new(:spec)
 
 require "rubocop/rake_task"
 
+require "rdoc/task"
+# require "simply_fsm/version"
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "simply_fsm #{SimplyFSM::VERSION}"
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
 RuboCop::RakeTask.new
 
 task default: %i[spec rubocop]

data/lib/simply_fsm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SimplyFSM
+  VERSION = "0.2.0"
+end

data/lib/simply_fsm.rb

@@ -1,19 +1,40 @@
 # frozen_string_literal: true
 
-module SimplyFSM
-  VERSION = "0.1.0"
+require "simply_fsm/version"
 
+##
+# Defines the `SimplyFSM` module
+module SimplyFSM
   def self.included(base)
     base.extend(ClassMethods)
   end
 
+  def state_match?(from, current)
+    return true if from == :any
+    return from.include?(current) if from.is_a?(Array)
+
+    from == current
+  end
+
+  def cannot_transition?(from, cond, current)
+    (from && !state_match?(from, current)) || (cond && !instance_exec(&cond))
+  end
+
+  ##
+  # Defines the constructor for defining a state machine
   module ClassMethods
+    ##
+    # Declare a state machine called +name+ which can then be defined
+    # by a DSL defined by the methods of `StateMachine`, with the following +opts+:
+    # - an optional +fail+ lambda that is called when any event fails to transition)
     def state_machine(name, opts = {}, &block)
       fsm = StateMachine.new(name, self, fail: opts[:fail])
       fsm.instance_eval(&block)
     end
   end
 
+  ##
+  # The DSL for defining a state machine
   class StateMachine
     attr_reader :initial_state, :states, :events, :name, :full_name
 
@@ -29,93 +50,190 @@ module SimplyFSM
       setup_base_methods
     end
 
+    ##
+    # Declare a supported +state_name+, and optionally specify one as the +initial+ state.
     def state(state_name, initial: false)
-      unless state_name.nil? || @states.include?(state_name)
-        status = state_name.to_sym
-        state_machine_name = @name
-        @states << status
-        @initial_state = status if initial
-
-        make_owner_method "#{state_name}?", lambda {
-          send(state_machine_name) == status
-        }
+      return if state_name.nil? || @states.include?(state_name)
+
+      status = state_name.to_sym
+      state_machine_name = @name
+      @states << status
+      @initial_state = status if initial
+
+      make_owner_method "#{state_name}?", lambda {
+        send(state_machine_name) == status
+      }
+    end
+
+    ##
+    # Define an event by +event_name+
+    #
+    # - which +transitions+ as a hash with a +from+ state or array of states and the +to+ state,
+    # - an optional +guard+ lambda which must return true for the transition to occur,
+    # - an optional +fail+ lambda that is called when the transition fails (overrides top-level fail handler), and
+    # - an optional do block that is called +after+ the transition succeeds
+    def event(event_name, transitions:, guard: nil, fail: nil, &after)
+      return unless event_exists?(event_name) && transitions
+
+      @events << event_name
+      may_event_name = "may_#{event_name}?"
+
+      if transitions.is_a?(Array)
+        setup_multi_transition_may_event_method transitions: transitions, guard: guard,
+                                                may_event_name: may_event_name
+        setup_multi_transition_event_method event_name,
+                                            transitions: transitions, guard: guard,
+                                            var_name: "@#{@name}", fail: fail || @fail_handler
+        return
       end
+
+      to = transitions[:to]
+      setup_may_event_method may_event_name, transitions[:from] || :any, transitions[:when], guard
+      setup_event_method event_name, var_name: "@#{@name}",
+                                     may_event_name: may_event_name, to: to,
+                                     fail: fail || @fail_handler, &after
     end
 
-    def event(event_name, transition:, guard: nil, fail: nil, &after)
-      if event_name && transition
-        @events << event_name
-        from = transition[:from]
-        to = transition[:to]
-        state_machine_name = @name
-        var_name = "@#{state_machine_name}"
-        may_event_name = "may_#{event_name}?"
-        fail = @fail_handler if fail.nil?
-
-        setup_may_event_method may_event_name, from, to, guard
-
-        #
-        # Setup the event method to attempt to make the state
-        # transition or report failure
-        make_owner_method event_name, lambda {
-          if send(may_event_name)
-            instance_variable_set(var_name, to)
-            instance_exec(&after) if after
+    private
+
+    def setup_multi_transition_may_event_method(transitions:, guard:, may_event_name:)
+      state_machine_name = @name
+
+      make_owner_method may_event_name, lambda {
+        if !guard || instance_exec(&guard)
+          current = send(state_machine_name)
+          # Check each transition, and first one that succeeds ends the scan
+          transitions.each do |t|
+            next if cannot_transition?(t[:from], t[:when], current)
+
             return true
           end
-          # unable to satisfy pre-conditions for the event
-          if fail
-            if fail.is_a?(String) || fail.is_a?(Symbol)
-              send(fail, event_name)
-            else
-              instance_exec(event_name, &fail)
-            end
+        end
+        false
+      }
+    end
+
+    def setup_multi_transition_event_method(event_name, transitions:, guard:, var_name:, fail:)
+      state_machine_name = @name
+      make_owner_method event_name, lambda {
+        if !guard || instance_exec(&guard)
+          current = send(state_machine_name)
+          # Check each transition, and first one that succeeds ends the scan
+          transitions.each do |t|
+            next if cannot_transition?(t[:from], t[:when], current)
+
+            instance_variable_set(var_name, t[:to])
+            return true
           end
-          false
-        }
+        end
+        instance_exec(&fail) if fail
+        false
+      }
+    end
 
-      end
+    def event_exists?(event_name)
+      event_name && !@events.include?(event_name)
     end
 
-    private
+    def setup_event_method(event_name, var_name:, may_event_name:, to:, fail:, &after)
+      method_lambda = lambda {
+        if send(may_event_name)
+          instance_variable_set(var_name, to)
+          instance_exec(&after) if after
+          return true
+        end
+        # unable to satisfy pre-conditions for the event
+        if fail
+          if fail.is_a?(String) || fail.is_a?(Symbol)
+            send(fail, event_name)
+          else
+            instance_exec(event_name, &fail)
+          end
+        end
+        false
+      }
+      make_owner_method event_name, method_lambda
+    end
 
-    def setup_may_event_method(may_event_name, from, _to, guard)
+    def setup_may_event_method(may_event_name, from, cond, guard)
       state_machine_name = @name
       #
-      # Instead of one "may_event?" method that checks all variations
-      # every time it's called, here we check the event definition and
-      # define the most optimal lambda to ensure the check is as fast as
-      # possible
-      method_lambda = if from == :any && !guard
-                        -> { true } # unguarded transition from any state
-                      elsif from == :any
-                        guard         # guarded transition from any state
-                      elsif !guard
-                        if from.is_a?(Array)
-                          lambda {    # unguarded transition from choice of states
-                            current = send(state_machine_name)
-                            from.include?(current)
-                          }
-                        else
-                          lambda {    # unguarded transition from one state
-                            current = send(state_machine_name)
-                            from == current
-                          }
-                        end
-                      elsif from.is_a?(Array)
-                        lambda {    # guarded transition from choice of states
-                          current = send(state_machine_name)
-                          from.include?(current) && instance_exec(&guard)
-                        }
+      # Instead of one "may_event?" method that checks all variations every time it's called, here we check
+      # the event definition and define the most optimal lambda to ensure the check is as fast as possible
+      method_lambda = if from == :any
+                        from_any_may_event_lambda(guard, cond, state_machine_name)
                       else
-                        lambda {    # guarded transition from one state
-                          current = send(state_machine_name)
-                          from == current && instance_exec(&guard)
-                        }
+                        guarded_or_conditional_may_event_lambda(from, guard, cond, state_machine_name)
                       end
       make_owner_method may_event_name, method_lambda
     end
 
+    def from_any_may_event_lambda(guard, cond, _state_machine_name)
+      if !guard && !cond
+        -> { true } # unguarded transition from any state
+      elsif !cond
+        guard # guarded transition from any state
+      elsif !guard
+        cond # conditional unguarded transition from any state
+      else
+        -> { instance_exec(&guard) && instance_exec(&cond) }
+      end
+    end
+
+    def guarded_or_conditional_may_event_lambda(from, guard, cond, state_machine_name)
+      if !guard && !cond
+        guardless_may_event_lambda(from, state_machine_name)
+      elsif !cond
+        guarded_may_event_lambda(from, guard, state_machine_name)
+      elsif !guard
+        guarded_may_event_lambda(from, cond, state_machine_name)
+      else
+        guarded_and_conditional_may_event_lambda(from, guard, cond, state_machine_name)
+      end
+    end
+
+    def guarded_may_event_lambda(from, guard, state_machine_name)
+      if from.is_a?(Array)
+        lambda { # guarded transition from choice of states
+          current = send(state_machine_name)
+          from.include?(current) && instance_exec(&guard)
+        }
+      else
+        lambda { # guarded transition from one state
+          current = send(state_machine_name)
+          from == current && instance_exec(&guard)
+        }
+      end
+    end
+
+    def guarded_and_conditional_may_event_lambda(from, guard, cond, state_machine_name)
+      if from.is_a?(Array)
+        lambda { # guarded transition from choice of states
+          current = send(state_machine_name)
+          from.include?(current) && instance_exec(&guard) && instance_exec(&cond)
+        }
+      else
+        lambda { # guarded transition from one state
+          current = send(state_machine_name)
+          from == current && instance_exec(&guard) && instance_exec(&cond)
+        }
+      end
+    end
+
+    def guardless_may_event_lambda(from, state_machine_name)
+      if from.is_a?(Array)
+        lambda {    # unguarded transition from choice of states
+          current = send(state_machine_name)
+          from.include?(current)
+        }
+      else
+        lambda {    # unguarded transition from one state
+          current = send(state_machine_name)
+          from == current
+        }
+      end
+    end
+
     def setup_base_methods
       var_name = "@#{name}"
       fsm = self

data/simply_fsm.gemspec

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "lib/simply_fsm"
+require_relative "lib/simply_fsm/version"
 
 Gem::Specification.new do |spec|
   spec.name = "simply_fsm"
@@ -10,14 +10,14 @@ Gem::Specification.new do |spec|
 
   spec.summary = "Simple finite state mechine (FSM) data-type mixin for Ruby objects."
   spec.description = "Use it to setup one or more FSMs in any Ruby object."
-  spec.homepage = "https://github.com/nogginly/simply_fsm"
+  spec.homepage = "https://github.com/nogginly/simply_fsm#simplyfsm"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 2.7.0"
   spec.date = Time.now
 
   spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "https://github.com/nogginly/simply_fsm/CHANGELOG.md"
+  spec.metadata["source_code_uri"] = "https://github.com/nogginly/simply_fsm"
+  spec.metadata["changelog_uri"] = "https://github.com/nogginly/simply_fsm/blob/main/CHANGELOG.md"
 
   spec.files         = `git ls-files`.split("\n")
   spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
@@ -26,5 +26,6 @@ Gem::Specification.new do |spec|
   # no deployment dependencies
 
   # development
+  spec.add_development_dependency "rdoc"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/spec/unit/fail_events_spec.rb

@@ -11,11 +11,11 @@ class FailHandlingStateMachine
     state :running
     state :cleaning
 
-    event :sleep, transition: { from: %i[running cleaning], to: :sleeping }
-    event :clean, transition: { from: :running, to: :cleaning }
+    event :sleep, transitions: { from: %i[running cleaning], to: :sleeping }
+    event :clean, transitions: { from: :running, to: :cleaning }
     event :run,
           fail: ->(_event) { raise RunError, "Cannot run" },
-          transition: { from: :sleeping, to: :running }
+          transitions: { from: :sleeping, to: :running }
   end
 
   def on_any_fail(event_name)

data/spec/unit/guard_events_spec.rb

@@ -10,9 +10,9 @@ class GuardingEvents
     state :walking
     state :running
 
-    event :idle, transition: { from: :any, to: :idling }
-    event :walk, transition: { from: :any, to: :walking }
-    event :run, transition: { from: :any, to: :running }
+    event :idle, transitions: { to: :idling }
+    event :walk, transitions: { from: :any, to: :walking }
+    event :run, transitions: { from: :any, to: :running }
   end
 
   state_machine :action do
@@ -20,14 +20,14 @@ class GuardingEvents
     state :jumping
     state :leaping
 
-    event :hold, transition: { from: :any, to: :ready }
+    event :hold, transitions: { to: :ready }
     event :jump,
           guard: -> { !running? },
-          transition: { from: :ready, to: :jumping }
+          transitions: { from: :ready, to: :jumping }
     event :leap,
           guard: -> { running? },
           fail: ->(_event) { raise LeapError, "Cannot leap" },
-          transition: { from: :ready, to: :leaping }
+          transitions: { when: -> { ready? }, to: :leaping }
   end
 end
 

data/spec/unit/multi_transition_state_machine_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class MultiTransitionStateMachine
+  include SimplyFSM
+
+  state_machine :activity do
+    state :sleeping, initial: true
+    state :running
+    state :cleaning
+
+    event :run, transitions: { from: :sleeping, to: :running }
+
+    event :clean, transitions: [
+      { from: :running, to: :cleaning }
+    ]
+
+    event :sleep, transitions: [
+      { from: :running, to: :sleeping },
+      { when: -> { cleaning? }, to: :sleeping }
+    ]
+  end
+end
+
+RSpec.describe MultiTransitionStateMachine do
+  include_examples "state machine basics", :activity,
+                   initial_state: :sleeping,
+                   states: %i[sleeping running cleaning],
+                   events: %i[run clean sleep]
+
+  describe "#sleep" do
+    it "fails if already sleeping" do
+      expect(subject.may_sleep?).to be false
+      expect(subject.sleep).to be false
+    end
+    it "succeeds if running" do
+      subject.run
+      expect(subject.may_sleep?).to be true
+      expect(subject.sleep).to be true
+    end
+    it "succeeds if cleaning" do
+      subject.run
+      subject.clean
+      expect(subject.may_sleep?).to be true
+      expect(subject.sleep).to be true
+    end
+  end
+
+  describe "#run" do
+    it "succeeds if sleeping" do
+      expect(subject.may_run?).to be true
+      expect(subject.run).to be true
+    end
+
+    it "fails if already running" do
+      subject.run
+      expect(subject.may_run?).to be false
+      expect(subject.run).to be false
+    end
+
+    it "fails if cleaning" do
+      subject.run
+      subject.clean
+      expect(subject.may_run?).to be false
+      expect(subject.run).to be false
+    end
+  end
+
+  describe "#clean" do
+    it "succeeds if running" do
+      subject.run
+      expect(subject.may_clean?).to be true
+      expect(subject.clean).to be true
+    end
+
+    it "fails if sleeping" do
+      expect(subject.may_clean?).to be false
+      expect(subject.clean).to be false
+    end
+
+    it "fails if already cleaning" do
+      subject.run
+      subject.clean
+      expect(subject.may_clean?).to be false
+      expect(subject.clean).to be false
+    end
+  end
+end

data/spec/unit/one_state_machine_spec.rb

@@ -8,9 +8,9 @@ class OneStateMachine
     state :running
     state :cleaning
 
-    event :run, transition: { from: :sleeping, to: :running }
-    event :clean, transition: { from: :running, to: :cleaning }
-    event :sleep, transition: { from: %i[running cleaning], to: :sleeping }
+    event :run, transitions: { from: :sleeping, to: :running }
+    event :clean, transitions: { from: :running, to: :cleaning }
+    event :sleep, transitions: { from: %i[running cleaning], to: :sleeping }
   end
 end
 

data/spec/unit/two_state_machines_spec.rb

@@ -7,16 +7,16 @@ class TwoStateMachines
     state :idling, initial: true
     state :walking
 
-    event :idle, transition: { from: :any, to: :idling }
-    event :walk, transition: { from: :idling, to: :walking }
+    event :idle, transitions: { from: :any, to: :idling }
+    event :walk, transitions: { from: :idling, to: :walking }
   end
 
   state_machine :action do
     state :ready, initial: true
     state :blocking
 
-    event :hold, transition: { from: :any, to: :ready }
-    event :block, transition: { from: :any, to: :blocking }
+    event :hold, transitions: { from: :any, to: :ready }
+    event :block, transitions: { from: :any, to: :blocking }
   end
 end
 

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: simply_fsm
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - nogginly
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-21 00:00:00.000000000 Z
+date: 2022-03-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -45,21 +59,23 @@ files:
 - bin/console
 - bin/setup
 - lib/simply_fsm.rb
+- lib/simply_fsm/version.rb
 - simply_fsm.gemspec
 - spec/spec_helper.rb
 - spec/support/state_machine_examples.rb
 - spec/unit/fail_events_spec.rb
 - spec/unit/guard_events_spec.rb
+- spec/unit/multi_transition_state_machine_spec.rb
 - spec/unit/one_state_machine_spec.rb
 - spec/unit/simply_fsm_spec.rb
 - spec/unit/two_state_machines_spec.rb
-homepage: https://github.com/nogginly/simply_fsm
+homepage: https://github.com/nogginly/simply_fsm#simplyfsm
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/nogginly/simply_fsm
+  homepage_uri: https://github.com/nogginly/simply_fsm#simplyfsm
   source_code_uri: https://github.com/nogginly/simply_fsm
-  changelog_uri: https://github.com/nogginly/simply_fsm/CHANGELOG.md
+  changelog_uri: https://github.com/nogginly/simply_fsm/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -75,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Simple finite state mechine (FSM) data-type mixin for Ruby objects.
@@ -84,6 +100,7 @@ test_files:
 - spec/support/state_machine_examples.rb
 - spec/unit/fail_events_spec.rb
 - spec/unit/guard_events_spec.rb
+- spec/unit/multi_transition_state_machine_spec.rb
 - spec/unit/one_state_machine_spec.rb
 - spec/unit/simply_fsm_spec.rb
 - spec/unit/two_state_machines_spec.rb