very_tiny_state_machine 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 94a25d93f5afee99439408cf0a390a8538508077
-  data.tar.gz: 4c1724c530df3c19cd534635ac5ec8a729045387
+SHA256:
+  metadata.gz: 47c8e65c48168e9aba7851fb1b26946a3e518c607f3df930bed9e0128d0b6c7e
+  data.tar.gz: 7d42d1daf4ac34a2c699df150b9a845321d3e853cf9e998183f75e3551077e2e
 SHA512:
-  metadata.gz: 55fd29f305d0c1fb00493718eb99b4e452754827701ffbeebfffdeef9c9f761bbb55f68a8462d603c0fd2ad4cabc20586d1f2c15c857b78adbf26762575149d7
-  data.tar.gz: 7aebb517f575428b6ac920db643dd16742a707723ba860aa242fdc55a748fca895f04aecbbfae49bccaf96e41b39b0437dfe90e31d79fe01f9ce62187bdee273
+  metadata.gz: e9370fa9aa20c27e9469b84e9960a5f2a9f6c35973dbc8dd51b38020fee1a0c8fd729b6fa3b8c70b4b066304451849c92ed9cb9e795bc8dea653b1950fcd775b
+  data.tar.gz: bd669ece20c891094f82eed1fcf511897809ed0b7dc94de36108482f15e08e042e1374e99e29d81d32e3489163ac83e61cb86ecf4f20693b3ddbbac631cd3a9d

data/.gitignore

@@ -0,0 +1,50 @@
+# rcov generated
+coverage
+coverage.data
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+Gemfile.lock
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For emacs:
+#*~
+#\#*
+#.\#*
+
+# For vim:
+#*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc

data/.rubocop.yml

@@ -0,0 +1,10 @@
+inherit_gem:
+  wetransfer_style: ruby/default.yml
+AllCops:
+  TargetRubyVersion: 2.1
+Style/GuardClause:
+  Enabled: false
+Style/GuardClause:
+  Enabled: false
+Metrics/LineLength:
+  Enabled: false

data/.travis.yml

@@ -1,6 +1,5 @@
 rvm:
-  - 2.0.0
-  - 2.1.5
-  - 2.2.0
+  - 2.1.0
+  - 2.6.5
 cache: bundler
-sudo: false 
+sudo: false

data/Gemfile

@@ -1,9 +1,5 @@
-source "http://rubygems.org"
+# frozen_string_literal: true
 
-group :development do
-  gem "rspec", "~> 3.2.0"
-  gem "rdoc", "~> 3.12"
-  gem "bundler", "~> 1.0"
-  gem "jeweler", "~> 2.0.1"
-  gem 'simplecov', '~> 0.10'
-end
+source 'http://rubygems.org'
+
+gemspec

data/README.md

@@ -9,9 +9,9 @@ The state machine has the ability to dispatch callbacks when states are switched
 are dispatched to the given object as messages.
 
     @automaton = VeryTinyStateMachine.new(:initialized, self)
-    @automaton.permit_state :processing, :closing, :closed
-    @automaton.permit_transition :initialized => :processing, :processing => :closing
-    @automaton.permit_transition :closing => :closed
+    @automaton.permit_states_and_transitions(:initialized => :processing, :processing => :closing, :closing => [:closed])
+    @automaton.permit_state :failed
+    @automaton.permit_transition :closing => :failed
     
     # Then, lower down the code
     @automaton.transition! :processing 

data/Rakefile

@@ -1,51 +1,18 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
-require_relative 'lib/very_tiny_state_machine'
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
-  gem.version = VeryTinyStateMachine::VERSION
-  gem.name = "very_tiny_state_machine"
-  gem.homepage = "http://github.com/WeTransfer/very_tiny_state_machine"
-  gem.license = "MIT"
-  gem.description = %Q{You wouldn't beleive how tiny it is}
-  gem.summary = %Q{A minuscule state machine for storing state of interesting objects}
-  gem.email = "me@julik.nl"
-  gem.authors = ["Julik Tarkhanov"]
-  # dependencies defined in Gemfile
-end
-Jeweler::RubygemsDotOrgTasks.new
-
-require 'rspec/core'
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
-end
+require 'yard'
+require 'rubocop/rake_task'
 
-desc "Code coverage detail"
-task :simplecov do
-  ENV['COVERAGE'] = "true"
-  Rake::Task['spec'].execute
+YARD::Rake::YardocTask.new(:doc) do |t|
+  # The dash has to be between the two to "divide" the source files and
+  # miscellaneous documentation files that contain no code
+  t.files = ['lib/**/*.rb', '-', 'LICENSE.txt']
 end
 
-task :default => :spec
+RSpec::Core::RakeTask.new(:spec)
 
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+RuboCop::RakeTask.new(:rubocop)
 
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "very_tiny_state_machine #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+task default: %i[spec rubocop]

data/lib/very_tiny_state_machine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 
 # A mini state machine object that can be used to track a state flow.
@@ -11,13 +13,13 @@ require 'set'
 #     @automaton.permit_state :processing, :closing, :closed
 #     @automaton.permit_transition :initialized => :processing, :processing => :closing
 #     @automaton.permit_transition :closing => :closed
-#    
+#
 #     # Then, lower down the code
 #     @automaton.transition! :processing
-#     
+#
 #     # This switches the internal state of the machine, and dispatches the following method
 #     # calls on the object given as the second argument to the constructor, in the following order:
-#    
+#
 #     # self.leaving_initialized_state
 #     # self.entering_processing_state
 #     # self.transitioning_from_initialized_to_processing_state
@@ -28,15 +30,15 @@ require 'set'
 #
 #     @automaton.transition :initialized # Will raise TinyStateMachine::InvalidFlow
 #     @automaton.transition :something_odd # Will raise TinyStateMachine::UnknownState
-#     
+#
 #     @automaton.in_state?(:processing) #=> true
 #     @automaton.in_state?(:initialized) #=> false
 class VeryTinyStateMachine
-  VERSION = '2.1.0'
-  
+  VERSION = '2.2.0'
+  INCLUDE_PRIVATES = true
   InvalidFlow = Class.new(StandardError) # Gets raised when an impossible transition gets requested
   UnknownState = Class.new(StandardError) # Gets raised when an unknown state gets requested
-  
+
   # Initialize a new TinyStateMachine, with the initial state and the object that will receive callbacks.
   #
   # @param initial_state[#to_sym] the initial state of the state machine
@@ -48,7 +50,7 @@ class VeryTinyStateMachine
     @permitted_transitions = Set.new
     @callbacks_via = object_handling_callbacks
   end
-  
+
   # Permit a single state or multiple states
   #
   # @param states [Array] states to permit
@@ -59,7 +61,25 @@ class VeryTinyStateMachine
     @permitted_states += states_to_permit
     will_be_added
   end
-  
+
+  # Permit states and transitions between them, all in one call
+  #
+  # @param **states_to_states [Hash] a mapping from one state the machine may go into and one or multiple states that can be reached from that state
+  # @return self
+  def permit_states_and_transitions(**initial_states_to_destination_states)
+    initial_states_to_destination_states.each_pair do |one_or_more_source_states, one_or_more_destination_states|
+      sources = Array(one_or_more_source_states)
+      destinations = Array(one_or_more_destination_states)
+      sources.each do |src|
+        destinations.each do |dest|
+          permit_state(src, dest)
+          permit_transition(src => dest)
+        end
+      end
+    end
+    self
+  end
+
   # Permit a transition from one state to another. If you need to add multiple transitions
   # from the same state, just call the method multiple times:
   #
@@ -70,16 +90,17 @@ class VeryTinyStateMachine
   # @return [Array] the list of states added to permitted states
   def permit_transition(from_to_hash)
     transitions_to_permit = Set.new
-    from_to_hash.each_pair do | from_state, to_state |
+    from_to_hash.each_pair do |from_state, to_state|
       raise UnknownState, from_state unless @permitted_states.include?(from_state.to_sym)
       raise UnknownState, to_state unless @permitted_states.include?(to_state.to_sym)
-      transitions_to_permit << {from_state.to_sym => to_state.to_sym}
+
+      transitions_to_permit << { from_state.to_sym => to_state.to_sym }
     end
     additions = transitions_to_permit - @permitted_transitions
     @permitted_transitions += transitions_to_permit
     additions
   end
-  
+
   # Tells whether the state is known to this state machine
   #
   # @param state[Symbol,String] the state to check for
@@ -87,17 +108,17 @@ class VeryTinyStateMachine
   def known?(state)
     @permitted_states.include?(state.to_sym)
   end
-  
+
   # Tells whether a transition is permitted to the given state.
   #
   # @param to_state[Symbol,String] state to transition to
   # @return [Boolean] whether the state can be transitioned to
   def may_transition_to?(to_state)
     to_state = to_state.to_sym
-    transition = {@state => to_state.to_sym}
+    transition = { @state => to_state.to_sym }
     @permitted_states.include?(to_state) && @permitted_transitions.include?(transition)
   end
-  
+
   # Tells whether the state machine is in a given state at the moment
   #
   # @param requisite_state [Symbol,String] name of the state to check for
@@ -105,7 +126,7 @@ class VeryTinyStateMachine
   def in_state?(requisite_state)
     @state == requisite_state.to_sym
   end
-  
+
   # Ensure the machine is in a given state, and if it isn't raise an InvalidFlow
   #
   # @param requisite_state[#to_sym] the state to verify
@@ -115,6 +136,7 @@ class VeryTinyStateMachine
     unless requisite_state.to_sym == @state
       raise InvalidFlow, "Must be in #{requisite_state.inspect} state, but was in #{@state.inspect}"
     end
+
     true
   end
 
@@ -123,7 +145,7 @@ class VeryTinyStateMachine
   # be raised if you did not permit this transition explicitly. If you want to transition to a state OR
   # stay in it if it is already active use {TinyStateMachine#transition_or_maintain!}
   #
-  # 
+  #
   # During transitions the before callbacks will be called on the @callbacks_via instance variable. If you are
   # transitioning from "initialized" to "processing" for instance, the following callbacks will be dispatched:
   #
@@ -142,23 +164,24 @@ class VeryTinyStateMachine
   # @raise InvalidFlow
   def transition!(new_state)
     new_state = new_state.to_sym
-    
+
     raise UnknownState, new_state.inspect unless known?(new_state)
+
     if may_transition_to?(new_state)
       dispatch_callbacks_before_transition(new_state) if @callbacks_via
-      
+
       previous = @state
       @state = new_state.to_sym
       @flow << new_state.to_sym
-      
+
       dispatch_callbacks_after_transition(previous) if @callbacks_via
       previous
     else
-      raise InvalidFlow, 
-        "Cannot change states from #{@state} to #{new_state} (flow so far: #{@flow.join(' > ')})"
+      raise InvalidFlow,
+            "Cannot change states from #{@state} to #{new_state} (flow so far: #{@flow.join(' > ')})"
     end
   end
-  
+
   # Transition to a given state. If the machine already is in that state, do nothing.
   # If the transition has to happen (the requested state is different than the current)
   # transition! will be called instead.
@@ -169,54 +192,55 @@ class VeryTinyStateMachine
   # @return [void]
   def transition_or_maintain!(new_state)
     return if in_state?(new_state)
+
     transition! new_state
   end
-  
+
   # Returns the flow of the transitions the machine went through so far
   #
   # @return [Array] the array of states
   def flow_so_far
     @flow.dup
   end
-  
+
   private
-  
+
   def dispatch_callbacks_after_transition(from)
     to = @state
-    if @callbacks_via.respond_to?("after_transitioning_from_#{from}_to_#{to}_state", also_protected_and_private=true)
+    if @callbacks_via.respond_to?("after_transitioning_from_#{from}_to_#{to}_state", INCLUDE_PRIVATES)
       @callbacks_via.send("after_transitioning_from_#{from}_to_#{to}_state")
     end
-    
-    if @callbacks_via.respond_to?("after_leaving_#{from}_state", also_protected_and_private=true)
+
+    if @callbacks_via.respond_to?("after_leaving_#{from}_state", INCLUDE_PRIVATES)
       @callbacks_via.send("after_leaving_#{from}_state")
     end
-    
-    if @callbacks_via.respond_to?("after_entering_#{to}_state", also_protected_and_private=true)
+
+    if @callbacks_via.respond_to?("after_entering_#{to}_state", INCLUDE_PRIVATES)
       @callbacks_via.send("after_entering_#{to}_state")
     end
-    
-    if @callbacks_via.respond_to?(:after_every_transition, also_protected_and_private=true)
+
+    if @callbacks_via.respond_to?(:after_every_transition, INCLUDE_PRIVATES)
       @callbacks_via.send(:after_every_transition, from, to)
     end
   end
-  
+
   def dispatch_callbacks_before_transition(to)
     from = @state
-    
-    if @callbacks_via.respond_to?(:before_every_transition, also_protected_and_private=true)
+
+    if @callbacks_via.respond_to?(:before_every_transition, INCLUDE_PRIVATES)
       @callbacks_via.send(:before_every_transition, from, to)
     end
-    
-    if @callbacks_via.respond_to?("leaving_#{from}_state", also_protected_and_private=true)
+
+    if @callbacks_via.respond_to?("leaving_#{from}_state", INCLUDE_PRIVATES)
       @callbacks_via.send("leaving_#{from}_state")
     end
-    
-    if @callbacks_via.respond_to?("entering_#{to}_state", also_protected_and_private=true)
+
+    if @callbacks_via.respond_to?("entering_#{to}_state", INCLUDE_PRIVATES)
       @callbacks_via.send("entering_#{to}_state")
     end
-    
-    if @callbacks_via.respond_to?("transitioning_from_#{from}_to_#{to}", also_protected_and_private=true)
+
+    if @callbacks_via.respond_to?("transitioning_from_#{from}_to_#{to}", INCLUDE_PRIVATES)
       @callbacks_via.send("transitioning_from_#{from}_to_#{to}")
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 

data/spec/very_tiny_state_machine_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe VeryTinyStateMachine do
@@ -7,126 +9,151 @@ describe VeryTinyStateMachine do
       expect(machine).to be_known(:started)
       expect(machine).to be_in_state(:started)
     end
-    
+
     it 'accepts a second argument' do
       acceptor = double('Callbacks')
-      machine = described_class.new(:started, acceptor)
+      described_class.new(:started, acceptor)
     end
   end
-  
+
   describe '#permit_state' do
     it 'makes the state known to the state machine' do
       machine = described_class.new(:started)
-      
+
       first_result_of_permission = machine.permit_state :closed
       second_result_of_permission = machine.permit_state :closed, :open
-      
+
       expect(first_result_of_permission).to eq(Set.new([:closed]))
       expect(second_result_of_permission).to eq(Set.new([:open]))
-      
+
       expect(machine).to be_known(:started)
       expect(machine).to be_known(:closed)
       expect(machine).to be_known(:open)
     end
-    
+
     it 'does not permit transitions to the newly added state by default' do
       machine = described_class.new(:started)
       machine.permit_state :running
-      
+
       expect(machine).not_to be_may_transition_to(:running)
-      
-      expect {
+
+      expect do
         machine.transition! :running
-      }.to raise_error(described_class::InvalidFlow, /Cannot change states from started to running/)
+      end.to raise_error(described_class::InvalidFlow, /Cannot change states from started to running/)
     end
   end
-  
+
   describe '#permit_transition' do
     it 'raises on an unknown state specified as source' do
       machine = described_class.new(:started)
-      expect {
-        machine.permit_transition :unknown => :started
-      }.to raise_error(VeryTinyStateMachine::UnknownState)
+      expect do
+        machine.permit_transition unknown: :started
+      end.to raise_error(VeryTinyStateMachine::UnknownState)
     end
-    
+
     it 'raises on an unknwon state specified as destination' do
       machine = described_class.new(:started)
-      expect {
-        machine.permit_transition :started => :unknown
-      }.to raise_error(VeryTinyStateMachine::UnknownState)
+      expect do
+        machine.permit_transition started: :unknown
+      end.to raise_error(VeryTinyStateMachine::UnknownState)
     end
-    
+
     it 'returns a Set of transitions permitted after the call' do
       machine = described_class.new(:started)
       machine.permit_state :running
-      
-      result = machine.permit_transition :started => :running
-      
+
+      result = machine.permit_transition started: :running
+
       expect(result).to be_kind_of(Set)
-      expect(result).to eq(Set.new([{:started => :running}]))
-      
-      adding_second_time = machine.permit_transition :started => :running
+      expect(result).to eq(Set.new([{ started: :running }]))
+
+      adding_second_time = machine.permit_transition started: :running
       expect(adding_second_time).to be_kind_of(Set)
       expect(adding_second_time).to be_empty
     end
-    
+
     it 'is able to perform the transition after it has been defined' do
       machine = described_class.new(:started)
       machine.permit_state :running
-      machine.permit_transition :started => :running
+      machine.permit_transition started: :running
       machine.transition! :running
     end
-    
+
     it 'allows the transition from a state to itself only explicitly' do
       machine = described_class.new(:started)
-      expect {
+      expect do
         machine.transition! :started
-      }.to raise_error(described_class::InvalidFlow)
-      
-      machine.permit_transition :started => :started
+      end.to raise_error(described_class::InvalidFlow)
+
+      machine.permit_transition started: :started
       machine.transition! :started
-      expect(machine.flow_so_far).to eq([:started, :started])
+      expect(machine.flow_so_far).to eq(%i[started started])
     end
   end
-  
+
+  describe '#permit_states_and_transitions' do
+    it 'accepts any states and sets up transitions' do
+      machine = described_class.new(:started)
+
+      same_machine = machine.permit_states_and_transitions(started: [:running, :overheat], running: [:stopped])
+
+      expect(same_machine).to eq(machine)
+      expect(machine.may_transition_to?(:running)).to eq(true)
+      expect(machine.may_transition_to?(:stopped)).to eq(false)
+
+      machine.transition! :running
+      expect(machine.may_transition_to?(:stopped)).to eq(true)
+      expect(machine.may_transition_to?(:overheat)).to eq(false)
+    end
+
+    it 'accepts same transitions and states multiple times' do
+      machine = described_class.new(:started)
+
+      machine.permit_states_and_transitions(started: [:running, :overheat], running: [:stopped])
+      machine.permit_states_and_transitions(started: [:running, :overheat], running: [:stopped])
+
+      expect(machine.may_transition_to?(:running)).to eq(true)
+    end
+  end
+
   describe '#flow_so_far' do
     it 'records the flow' do
       machine = described_class.new(:started)
       machine.permit_state :running, :stopped
-      machine.permit_transition :started => :running, :running => :stopped, :stopped => :started
-      
+      machine.permit_transition started: :running, running: :stopped, stopped: :started
+
       machine.transition! :running
       machine.transition! :stopped
       machine.transition! :started
-      
+
       flow = machine.flow_so_far
-      expect(flow).to eq([:started, :running, :stopped, :started])
-      
+      expect(flow).to eq(%i[started running stopped started])
+
       flow << nil
-      expect(flow).not_to eq(machine.flow_so_far), "The flow returned should not link to the mutable array in the machine"
+      expect(flow).not_to eq(machine.flow_so_far), 'The flow returned should not link to the mutable array in the machine'
     end
   end
-  
+
   describe '#transition!' do
     it 'returns the previous state the object was in' do
       machine = described_class.new(:started)
       machine.permit_state :running
-      machine.permit_transition :started => :running
+      machine.permit_transition started: :running
       transitioned_from = machine.transition! :running
       expect(transitioned_from).to eq(:started)
     end
-    
+
     it 'sends all of the callbacks if the object responds to them' do
       fake_acceptor = double('Callback handler')
-      allow(fake_acceptor).to receive(:respond_to?) {|method_name, honor_private_and_public|
+      allow(fake_acceptor).to receive(:respond_to?) { |_method_name, honor_private_and_public|
         expect(honor_private_and_public).to eq(true)
         true
       }
-      
+
       machine = described_class.new(:started, fake_acceptor)
       machine.permit_state :running, :stopped
-      machine.permit_transition :started => :running, :running => :stopped, :stopped => :started
-      
+      machine.permit_transition started: :running, running: :stopped, stopped: :started
+
       expect(fake_acceptor).to receive(:before_every_transition).with(:started, :running)
       expect(fake_acceptor).to receive(:leaving_started_state)
       expect(fake_acceptor).to receive(:entering_running_state)
@@ -138,70 +165,71 @@ describe VeryTinyStateMachine do
 
       machine.transition! :running
     end
-    
+
     it 'dispatches callbacks to private methods as well' do
       acceptor = Class.new do
         def called?
           @entered_state
         end
-        
-        private
+
+                   private
+
         def entering_running_state
           @entered_state = true
         end
       end.new
-      
+
       machine = described_class.new(:started, acceptor)
       machine.permit_state :running, :stopped
-      machine.permit_transition :started => :running, :running => :stopped, :stopped => :started
-      
+      machine.permit_transition started: :running, running: :stopped, stopped: :started
+
       machine.transition! :running
       expect(acceptor).to be_called
     end
-    
+
     it 'does not send the messages to an acceptor that does not respond to those messages' do
       fake_acceptor = double('Callback handler')
-      allow(fake_acceptor).to receive(:respond_to?) {|method_name, honor_private_and_public|
+      allow(fake_acceptor).to receive(:respond_to?) { |_method_name, honor_private_and_public|
         expect(honor_private_and_public).to eq(true)
         false
       }
-      
+
       machine = described_class.new(:started, fake_acceptor)
       machine.permit_state :running, :stopped
-      machine.permit_transition :started => :running, :running => :stopped, :stopped => :started
-      
+      machine.permit_transition started: :running, running: :stopped, stopped: :started
+
       machine.transition! :running
     end
   end
-  
+
   describe '#transition_or_maintain!' do
     it 'does not perform any transitions if the object is already in the requisite state' do
       machine = described_class.new(:perfect)
       machine.transition_or_maintain! :perfect
       expect(machine.flow_so_far).to eq([:perfect])
     end
-    
+
     it 'does perform a transition if the object is not in the requisite state' do
       machine = described_class.new(:perfect)
       machine.permit_state :perfect, :improving
-      machine.permit_transition :perfect => :improving, :improving => :perfect
-      
+      machine.permit_transition perfect: :improving, improving: :perfect
+
       machine.transition_or_maintain! :improving
-      expect(machine.flow_so_far).to eq([:perfect, :improving])
+      expect(machine.flow_so_far).to eq(%i[perfect improving])
     end
   end
-  
+
   describe '#expect!' do
     it 'returns true when the machine is in the requisite state' do
       machine = described_class.new(:started)
       expect(machine.expect!(:started)).to eq(true)
     end
-    
+
     it 'raises an exception if the machine is not in that state' do
       machine = described_class.new(:started)
-      expect {
+      expect do
         machine.expect!(:running)
-      }.to raise_error(VeryTinyStateMachine::InvalidFlow, 'Must be in :running state, but was in :started')
+      end.to raise_error(VeryTinyStateMachine::InvalidFlow, 'Must be in :running state, but was in :started')
     end
   end
 end

data/very_tiny_state_machine.gemspec

@@ -1,63 +1,34 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-# stub: very_tiny_state_machine 2.1.0 ruby lib
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'very_tiny_state_machine'
 
 Gem::Specification.new do |s|
-  s.name = "very_tiny_state_machine"
-  s.version = "2.1.0"
+  s.name = 'very_tiny_state_machine'
+  s.version = VeryTinyStateMachine::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.require_paths = ["lib"]
-  s.authors = ["Julik Tarkhanov"]
-  s.date = "2016-11-01"
+  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.require_paths = ['lib']
+  s.authors = ['Julik Tarkhanov']
   s.description = "You wouldn't beleive how tiny it is"
-  s.email = "me@julik.nl"
+  s.email = 'me@julik.nl'
   s.extra_rdoc_files = [
-    "LICENSE.txt",
-    "README.md"
-  ]
-  s.files = [
-    ".document",
-    ".rspec",
-    ".travis.yml",
-    "Gemfile",
-    "LICENSE.txt",
-    "README.md",
-    "Rakefile",
-    "lib/very_tiny_state_machine.rb",
-    "spec/spec_helper.rb",
-    "spec/very_tiny_state_machine_spec.rb",
-    "very_tiny_state_machine.gemspec"
+    'LICENSE.txt',
+    'README.md'
   ]
-  s.homepage = "http://github.com/WeTransfer/very_tiny_state_machine"
-  s.licenses = ["MIT"]
-  s.rubygems_version = "2.4.5.1"
-  s.summary = "A minuscule state machine for storing state of interesting objects"
+  s.files = `git ls-files -z`.split("\x0")
+  s.homepage = 'http://github.com/WeTransfer/very_tiny_state_machine'
+  s.licenses = ['MIT']
+  s.rubygems_version = '2.4.5.1'
+  s.summary = 'A minuscule state machine for storing state of interesting objects'
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, ["~> 3.2.0"])
-      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
-      s.add_development_dependency(%q<simplecov>, ["~> 0.10"])
-    else
-      s.add_dependency(%q<rspec>, ["~> 3.2.0"])
-      s.add_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_dependency(%q<bundler>, ["~> 1.0"])
-      s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
-      s.add_dependency(%q<simplecov>, ["~> 0.10"])
-    end
-  else
-    s.add_dependency(%q<rspec>, ["~> 3.2.0"])
-    s.add_dependency(%q<rdoc>, ["~> 3.12"])
-    s.add_dependency(%q<bundler>, ["~> 1.0"])
-    s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
-    s.add_dependency(%q<simplecov>, ["~> 0.10"])
-  end
+  s.specification_version = 4
+  s.add_development_dependency('bundler')
+  s.add_development_dependency('rake', '~> 12')
+  s.add_development_dependency('rdoc', ['~> 3'])
+  s.add_development_dependency('rspec', ['~> 3'])
+  s.add_development_dependency('simplecov', ['~> 0.10'])
+  s.add_development_dependency('wetransfer_style', '0.6.0') # Lock since we want to be backwards-compat down to Ruby 2.1
+  s.add_development_dependency('yard')
 end
-

metadata

@@ -1,71 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: very_tiny_state_machine
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Julik Tarkhanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-01 00:00:00.000000000 Z
+date: 2020-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '12'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '3'
 - !ruby/object:Gem::Dependency
-  name: jeweler
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.1
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.1
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: wetransfer_style
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  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'
 description: You wouldn't beleive how tiny it is
 email: me@julik.nl
 executables: []
@@ -89,7 +117,9 @@ extra_rdoc_files:
 - README.md
 files:
 - ".document"
+- ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
 - LICENSE.txt
@@ -118,8 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A minuscule state machine for storing state of interesting objects