very_tiny_state_machine 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 40cb0d3afb2f9c64b8eb616492132d2c45d424f0
+  data.tar.gz: 7ccefb4f23c017273a13c5b696bdbf10b2978db6
+SHA512:
+  metadata.gz: 1c95e4e56f4c9da12c9bf07cf007060e885f7201b646ea0c5d604a949d51f27b8684ac7f202bcdaf9507afa808f17b6264e6e45d1db524089a24a43a44e28e05
+  data.tar.gz: 26e7aeba3f817d853f9f6bce6a4695f6a76a0f00c728b4b1a8a7d2e3f3d3932f6f3cc7254ae43afea8a0c5b60eeebc1a4ffe8f53fdf382208aa19b9b3ecf096f

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+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

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2016 WeTransfer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# very_tiny_state_machine
+
+For when the others are not tiny enough.
+
+The entire state machine lives in a separate variable, and does not pollute the class or the module of the caller.
+The state machine has the ability to dispatch callbacks when states are switched, and the callbacks
+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
+    
+    # Then, lower down the code
+    @automaton.transition! :processing
+
+The object supplied as the optional second argument will receive messages when states are switched around,
+in the following order (using the state machine from the previous example):
+   
+    # self.leaving_initialized_state
+    # self.entering_processing_state
+    # self.transitioning_from_initialized_to_processing_state
+    # ..the state variable is switched here
+    # self.after_transitioning_from_initialized_to_processing_state
+    # self.after_leaving_initialized_state
+    # self.after_entering_processing_state
+
+You can see in which state the machine is in:
+
+    @automaton.in_state?(:processing) #=> true
+    @automaton.in_state?(:initialized) #=> false
+
+and state machine has your back if you want to do something invalid:
+
+    @automaton.transition :initialized # Will raise TinyStateMachine::InvalidFlow
+    @automaton.transition :something_odd # Will raise TinyStateMachine::UnknownState
+
+## Contributing to very_tiny_state_machine
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2016 WeTransfer. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+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 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['spec'].execute
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "very_tiny_state_machine #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/very_tiny_state_machine.rb

@@ -0,0 +1,215 @@
+require 'thread'
+require 'set'
+
+# A mini state machine object that can be used to track a state flow.
+#
+# The entire state machine lives in a separate variable, and does not pollute the
+# class or the module of the caller.
+# The state machine has the ability to dispatch callbacks when states are switched, the callbacks
+# are dispatched to the given object.
+#
+#     @automaton = VeryTinyStateMachine.new(:initialized, self)
+#     @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
+#     # ..the state variable is switched here
+#     # self.after_transitioning_from_initialized_to_processing_state
+#     # self.after_leaving_initialized_state
+#     # self.after_entering_processing_state
+#
+#     @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 = '1.0.0'
+  
+  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
+  # @param object_handling_callbacks[#send, #respond_to?] the callback handler that will receive transition notifications
+  def initialize(initial_state, object_handling_callbacks = nil)
+    @mutex = Mutex.new
+    @state = initial_state.to_sym
+    @flow = [@state]
+    @permitted_states = Set.new([initial_state])
+    @permitted_transitions = Set.new
+    @callbacks_via = object_handling_callbacks
+  end
+  
+  # Permit a single state or multiple states
+  #
+  # @param states [Array] states to permit
+  # @return [Set] the Set of states added to permitted states as the result of the call
+  def permit_state(*states)
+    states_to_permit = Set.new(states.map(&:to_sym))
+    will_be_added = states_to_permit - @permitted_states
+    @permitted_states += states_to_permit
+    will_be_added
+  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:
+  #
+  #     @machine.permit_transition :initialized => :failed, :running => :closed
+  #     @machine.permit_transition :initialized => :running
+  #
+  # @param from_to_hash[Hash] the transitions to allow
+  # @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 |
+      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}
+    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
+  # @return [Boolean] whether the state is known
+  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}
+    @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
+  # @return [Boolean] whether the machine is in that state currently
+  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
+  # @raise InvalidFlow
+  # @return [TrueClass] true if the machine is in the requisite state
+  def expect!(requisite_state)
+    unless requisite_state.to_sym == @state
+      raise InvalidFlow, "Must be in #{requisite_state.inspect} state, but was in #{@state.inspect}"
+    end
+    true
+  end
+
+  # Transition to a given state. Will raise an InvalidFlow exception if the transition is impossible.
+  # Additionally, if you want to transition to a state that is already activated, an InvalidFlow will
+  # 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:
+  #
+  # * leaving_initialized_state
+  # * entering_processing_state
+  # * transitioning_from_initialized_to_processing_state
+  # ..the state variable is switched here
+  # * after_transitioning_from_initialized_to_processing_state
+  # * after_leaving_initialized_state
+  # * after_entering_processing_state
+  #
+  # The return value of the callbacks does not matter.
+  #
+  # @param new_state[#to_sym] the state to transition to.
+  # @return [Symbol] the state that the machine has just left
+  # @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)
+      @mutex.synchronize do
+        dispatch_callbacks_before_transition(new_state)
+        previous = @state
+        @state = new_state.to_sym
+        @flow << new_state.to_sym
+        dispatch_callbacks_after_transition(previous)
+        previous
+      end
+    else
+      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.
+  #
+  # @see TinyStateMachine#transition!
+  # @param new_state[Symbol,String] the state to transition to.
+  # @raise InvalidFlow
+  # @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)
+      @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)
+      @callbacks_via.send("after_leaving_#{from}_state")
+    end
+    
+    if @callbacks_via.respond_to?("after_entering_#{to}_state", also_protected_and_private=true)
+      @callbacks_via.send("after_entering_#{to}_state")
+    end
+  end
+  
+  def dispatch_callbacks_before_transition(to)
+    from = @state
+    if @callbacks_via.respond_to?("leaving_#{from}_state", also_protected_and_private=true)
+      @callbacks_via.send("leaving_#{from}_state")
+    end
+    
+    if @callbacks_via.respond_to?("entering_#{to}_state", also_protected_and_private=true)
+      @callbacks_via.send("entering_#{to}_state")
+    end
+    
+    if @callbacks_via.respond_to?("transitioning_from_#{from}_to_#{to}", also_protected_and_private=true)
+      @callbacks_via.send("transitioning_from_#{from}_to_#{to}")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'simplecov'
+SimpleCov.start
+
+require 'very_tiny_state_machine'
+
+RSpec.configure { |config| config.order = 'random' }

data/spec/very_tiny_state_machine_spec.rb

@@ -0,0 +1,205 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe VeryTinyStateMachine do
+  describe '#initialize' do
+    it 'creates a state machine and sets its initial state' do
+      machine = described_class.new(:started)
+      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)
+    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 {
+        machine.transition! :running
+      }.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)
+    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)
+    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
+      
+      expect(result).to be_kind_of(Set)
+      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.transition! :running
+    end
+    
+    it 'allows the transition from a state to itself only explicitly' do
+      machine = described_class.new(:started)
+      expect {
+        machine.transition! :started
+      }.to raise_error(described_class::InvalidFlow)
+      
+      machine.permit_transition :started => :started
+      machine.transition! :started
+      expect(machine.flow_so_far).to eq([:started, :started])
+    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.transition! :running
+      machine.transition! :stopped
+      machine.transition! :started
+      
+      flow = machine.flow_so_far
+      expect(flow).to eq([: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"
+    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
+      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|
+        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
+      
+      expect(fake_acceptor).to receive(:leaving_started_state)
+      expect(fake_acceptor).to receive(:entering_running_state)
+      expect(fake_acceptor).to receive(:transitioning_from_started_to_running)
+      expect(fake_acceptor).to receive(:after_transitioning_from_started_to_running_state)
+      expect(fake_acceptor).to receive(:after_leaving_started_state)
+      expect(fake_acceptor).to receive(:after_entering_running_state)
+      
+      machine.transition! :running
+    end
+    
+    it 'dispatches callbacks to private methods as well' do
+      acceptor = Class.new do
+        def called?
+          @entered_state
+        end
+        
+        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.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|
+        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.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.transition_or_maintain! :improving
+      expect(machine.flow_so_far).to eq([: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 {
+        machine.expect!(:running)
+      }.to raise_error(VeryTinyStateMachine::InvalidFlow, 'Must be in :running state, but was in :started')
+    end
+  end
+end

data/very_tiny_state_machine.gemspec

@@ -0,0 +1,62 @@
+# 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 1.0.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "very_tiny_state_machine"
+  s.version = "1.0.0"
+
+  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-01-14"
+  s.description = "You wouldn't beleive how tiny it is"
+  s.email = "me@julik.nl"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "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"
+  ]
+  s.homepage = "http://github.com/WeTransfer/very_tiny_state_machine"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.2.2"
+  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
+end
+

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: very_tiny_state_machine
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Julik Tarkhanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: You wouldn't beleive how tiny it is
+email: me@julik.nl
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".rspec"
+- 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
+homepage: http://github.com/WeTransfer/very_tiny_state_machine
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A minuscule state machine for storing state of interesting objects
+test_files: []