finite 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1002bb014d485c4ae60030a8d9de3213579f3d2
-  data.tar.gz: 165c19b3e8a913584cd52a78125bc5bdb46e8c97
+  metadata.gz: efb775ca43d0ce5dddd4215fde0c54b5f764e097
+  data.tar.gz: f617e7113c8f30f590c353dfa664776e74cb6c32
 SHA512:
-  metadata.gz: a7feedd329e35cf82cedb04f72c80bbfcc7bb5e60043302a2e18f8b68ee23c837ed259271747991792f7cf4aa70a6a74cd1ec0b1ed7ff7602a961d7f9e165adc
-  data.tar.gz: d9c11ca96d496a28995f88269e6a04a080f98619bb8f3f0f4d9561164550e4fbf478b21a602e86779bff8403a6e6839088eb78046a64df3233307be58f82d540
+  metadata.gz: 7e6a27d3620e1ed8a3d80099d9ff9ae7ac693ac04a81ba570b6048565e9cc6d94cd4a7ff69e5944489d652aec55ace9cabc9b688ae60d64e6c6d37762352f3e0
+  data.tar.gz: ad0e60854b2334e045f78c35e0649e610e56abb9253ed0f22c6260972a8b469206e385052a1748dccc23ef84d7602bee120b44aafd2488aa6ab61f0583197d80

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+spec/null.txt

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode

data/README.md

@@ -1,4 +1,5 @@
-# Finite 0.0.1
+# Finite [![Build Status](https://travis-ci.org/kristenmills/finite.png)](https://travis-ci.org/kristenmills/finite)
+
 
 A simple state machine implementation for ruby
 
@@ -17,8 +18,92 @@ Or install it yourself as:
     $ gem install finite
 
 ## Usage
-
-TODO
+```ruby
+
+class Elevator
+    include Finite
+
+    finite initial: :idle do
+
+        before do
+            "This is called before every state but has no purpose other than to show it's existence in this example."
+        end
+
+        before :doors_closing do
+            puts 'Doors Closing!'
+        end
+
+        before :doors_opening do
+            puts 'Doors Opening!'
+        end
+
+        event :prepare do
+            go from: :idle, to: :doors_closing
+        end
+
+        event :go_up do
+            go from: :doors_closing, to: :elevator_going_up
+            after do
+                puts 'Going Up!'
+            end
+        end
+
+        event :go_down do
+            go from: :doors_closing, to: :elevator_going_down
+            after do
+                puts 'Going Down!'
+            end
+        end
+
+        event :start do
+            go from: [:elevator_going_up, :elevator_going_down], to: :moving
+        end
+
+        event :approach do
+            go from: :moving, to: :stopping
+        end
+
+        event :stop do
+            go from: :stopping, to: :doors_opening
+            before do
+                announce_floor
+            end
+        end
+
+        event :open_doors do
+            go from: :doors_opening, to: :at_floor
+        end
+
+        event :finish do
+            go from: :at_floor, to: :checking_next_dest
+        end
+
+        event :make_request do
+            go from: :checking_next_dest, to: :doors_closing
+        end
+
+        event :make_no_request do
+            go from: :checking_next_dest, to: :idle
+        end
+    end
+
+    def announce_floor
+        puts "Arriving on floor #{rand(10)}"
+    end
+end
+```
+
+```ruby
+elevator = Elevator.new
+elevator.current_state          # => :idle
+elevator.can_prepare?           # => true
+elevator.can_open_doors?        # => false
+elevator.open_doors             # => RuntimeError 'Invalid Transition'
+elevator.idle?                  # => true
+elevator.prepare                # => 'Doors Closing!'
+elevator.current_state          # => :doors_closing
+elevator.possible_events        # => [:go_up, :go_down]
+```
 
 ## Contributing
 

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/finite.gemspec

@@ -20,4 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "yard"
 end

data/lib/finite/class_methods.rb

@@ -0,0 +1,13 @@
+module Finite
+  # The class methods for any class that include the finite base
+  module ClassMethods
+    # The finite method for the dsl
+    #
+    # @param opts [Hash] any options including initial state
+    # @param block [Block] the block of code that creates the state machine
+    def finite(opts, &block)
+      StateMachine.machines ||= Hash.new
+      StateMachine.machines[self] = StateMachine.new(opts[:initial], self, &block)
+    end
+  end
+end

data/lib/finite/event.rb

@@ -1,5 +1,68 @@
 module Finite
+
+  # The event class. Represents an event in the state machine
   class Event
-    # some code
+
+    attr_reader :name, :transitions, :callbacks
+
+    # Create an event object
+    #
+    # @param name [Symbol] the name of the event
+    # @param block [Block] the block of code in the event
+    def initialize(name, &block)
+      @name = name
+      @transitions = Hash.new
+      @callbacks = {before: Array.new, after: Array.new}
+      instance_eval &block
+    end
+
+    # Are two events equal
+    #
+    # @param event [Object] the object you are comparing it to
+    # @return true if they are equal false if not
+    def ==(event)
+      if event.is_a? Event
+        @name == event.name
+      elsif event.is_a? Symbol
+        @name == event
+      else
+        false
+      end
+    end
+
+    # overrriden for puts and print
+    def to_s
+      @name.to_s
+    end
+
+    # Overridden for p
+    def inspect
+      @name
+    end
+
+    private
+    # The transition method for the dsl
+    #
+    # @param opts [Hash] the options for a transition
+    def go(opts)
+      options = []
+      if opts[:from].is_a? Array
+        opts[:from].each do |from|
+          options << {from: from, to: opts[:to]}
+        end
+      else
+        options << opts
+      end
+      options.each do |opt|
+        @transitions[opt[:from]] = Transition.new(opt)
+      end
+    end
+
+    # Create the callback methods
+    [:after, :before].each do |callback|
+      define_method callback do |*args, &block|
+        @callbacks[callback] << block
+      end
+    end
   end
 end

data/lib/finite/finite.rb

@@ -0,0 +1,37 @@
+module Finite
+  # Get's the current state
+  # @return the current state for an object
+  def current_state
+    machine = StateMachine.machines[self.class]
+    @current_state or machine.states[machine.initial]
+  end
+
+  # Get's (and sets) the array of states
+  # @return the array of states
+  def states
+    @states ||= StateMachine.machines[self.class].states
+    @states
+  end
+
+  # Get's (and sets) the array of events
+  # @return the array of events
+  def events
+    @events ||= StateMachine.machines[self.class].events
+    @events
+  end
+
+  # Get's (and sets) the array of callbacks
+  # @return the array of callbacks
+  def callbacks
+    @callbacks ||= StateMachine.machines[self.class].callbacks
+    @callbacks
+  end
+
+  # Get's all the possible events you can perform
+  # @return any event that you can perform given your state
+  def possible_events
+    pos = Array.new
+    events.each_value{|event| pos << event if event.transitions.key?(current_state.name)}
+    pos
+  end
+end

data/lib/finite/machine.rb

@@ -1,5 +1,121 @@
 module Finite
-  class Machine
-    # some code
+  # The State Machine class. Represents the whole state machine
+  class StateMachine
+
+    class << self
+      attr_accessor :machines
+    end
+
+    attr_reader :states, :initial, :events, :callbacks
+
+    # Create a new state machine
+    #
+    # @param initial_state [Symbol] the initial state of this state machine
+    # @param klass [Class] the class of the state machine
+    # @param block [Block] the block of code that creates it
+    def initialize(initial_state, klass, &block)
+      @class = klass
+      @initial = initial_state
+      @states = Hash.new
+      @events = Hash.new
+      @callbacks = {before: Hash.new , after: Hash.new}
+      instance_eval &block
+    end
+
+    # Add an event to the state machine
+    #
+    # @param event_name [Symbol] the event you are trying to add
+    # @param block [Block] the block of code that creates an event
+    # @raise [Exception] if the event already exists
+    def add_event(event_name, &block)
+      # We don't want to randomly override things that we shouldn't
+      raise "Method already taken can_#{event_name}?" if @class.methods.include?(:"can_#{event_name}?")
+      raise "Method already taken #{event_name}" if @class.methods.include?(:"#{event_name}")
+      raise 'Event #{event_name} already exists. Rename or combine the events' if events.include? event_name
+      event = Event.new(event_name, &block)
+      @events[event_name] = event
+      event.transitions.each_value do |transition|
+        add_state transition.to
+        add_state transition.from
+      end
+      @class.send(:define_method, :"can_#{event_name}?") do
+        event.transitions.key? current_state.name
+      end
+      @class.send(:define_method, :"#{event_name}") do
+        if event.transitions.key? current_state.name
+
+          event.callbacks[:before].each do |callback|
+            self.instance_eval &callback
+          end
+
+          if callbacks[:before].key? :all
+            callbacks[:before][:all].each do |callback|
+              self.instance_eval &callback
+            end
+          end
+
+          new_state = states[event.transitions[current_state.name].to]
+
+          if callbacks[:before].key? new_state.name
+            callbacks[:before][new_state.name].each do |callback|
+              self.instance_eval &callback
+            end
+          end
+          @current_state = new_state
+
+          if callbacks[:after].key? :all
+            callbacks[:after][:all].each do |callback|
+              self.instance_eval &callback
+            end
+          end
+          if callbacks[:after].key? current_state.name
+            callbacks[:after][current_state.name].each do |callback|
+              self.instance_eval &callback
+            end
+          end
+
+          event.callbacks[:after].each do |callback|
+            self.instance_eval &callback
+          end
+        else
+          raise 'Invalid Transition'
+        end
+      end
+    end
+
+    # Add a state to the the state machine if the state hasn't already been
+    # created
+    #
+    # @param state [Symbol] the state you are trying to add
+    def add_state(state)
+      if not @states.include? state
+        # Prevents arbitrarily overriding methods that you shouldn't be
+        raise "Method already taken #{state}?" if @class.methods.include?(:"#{state}?")
+        @states[state] = State.new(state)
+        @class.send(:define_method, :"#{state}?"){current_state == state}
+      end
+    end
+
+    private
+    # The event method for the dsl
+    #
+    # @param name [Symbol] the name of the event
+    # @param block [Block] the block of code that creates events
+    def event(name, &block)
+      add_event name, &block
+    end
+
+    # Create the callback methods
+    [:after, :before].each do |callback|
+      define_method callback do |*args, &block|
+        if args.count > 0
+          callbacks[callback][args[0]] ||= Array.new
+          callbacks[callback][args[0]] << block
+        else
+          callbacks[callback][:all] ||= Array.new
+          callbacks[callback][:all] << block
+        end
+      end
+    end
   end
 end

data/lib/finite/state.rb

@@ -1,5 +1,38 @@
 module Finite
-	class State
-    # some code
-	end
+
+  # The State class. Represents a state in the state machine.
+  class State
+    attr_reader :name
+
+    # Create a new state
+    #
+    # @param name [Symbol] the name of the state
+    def initialize(name)
+      @name = name
+    end
+
+    # Overide the == method for state
+    #
+    # @param state [Object] the state your comparing to
+    # @return true if they are equal false if not
+    def ==(state)
+      if state.is_a? Symbol
+        @name == state
+      elsif state.is_a? State
+        @name == state.name
+      else
+        false
+      end
+    end
+
+    # overrriden for puts and print
+    def to_s
+      @name.to_s
+    end
+
+    # Overridden for p
+    def inspect
+      @name
+    end
+  end
 end

data/lib/finite/transition.rb

@@ -1,5 +1,24 @@
 module Finite
+
+  # The transition class. Represents a transition between two states
   class Transition
-    # some code
+
+    attr_reader :to, :from
+
+    # Create a new transition object
+    #
+    # @param opts [Hash] the options for a transition. Include :to and :from
+    def initialize(opts)
+      @from = opts[:from]
+      @to = opts[:to]
+    end
+
+    # Does this transition equal another transition?
+    #
+    # @param other [Transition] another transition
+    # @return true if they are equal false if not
+    def ==(other)
+      from == other.from and to == other.to
+    end
   end
 end

data/lib/finite/version.rb

@@ -1,3 +1,4 @@
 module Finite
-  VERSION = "0.0.1"
+  # The version number
+  VERSION = "1.0.0"
 end

data/lib/finite.rb

@@ -1,5 +1,19 @@
-require 'finite/version'
+[
+  'version',
+  'transition',
+  'event',
+  'state',
+  'machine',
+  'class_methods',
+  'finite'
+].each { |file| require File.join(File.dirname(__FILE__), 'finite', file) }
 
+# The Finite module. The module that contains all the classes and methods for
+# the finite gem.
 module Finite
-  # Your code goes here...
-end
+  # Override included method
+  def self.included(base)
+    base.extend(ClassMethods)
+    super
+  end
+end

data/spec/elevator_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Elevator do
+  before(:each) do
+    @elevator = Elevator.new
+  end
+
+  it 'has a state machine' do
+    expect(Finite::StateMachine.machines[Elevator]).to_not be_nil
+  end
+
+  context 'states' do
+    it 'has a current state' do
+      expect(@elevator.current_state).to_not be_nil
+      expect(@elevator.current_state).to eq(:idle)
+    end
+
+    it 'has methods to tell whether it is in a state or not' do
+      expect(@elevator.idle?).to be_true
+      expect(@elevator.moving?).to be_false
+    end
+
+    it 'can access all states' do
+      expect(@elevator.states).to_not be_nil
+      expect(@elevator.states.count).to be(9)
+    end
+  end
+
+  context 'events' do
+    it 'can access all events' do
+      expect(@elevator.events).to_not be_nil
+      expect(@elevator.events.count).to be(10)
+    end
+
+    it 'can access possible events for a given state' do
+      expect(@elevator.possible_events).to eq([:prepare])
+    end
+
+    it 'has methods to tell whether an event can be performed' do
+      expect(@elevator.can_prepare?).to be_true
+      expect(@elevator.can_go_up?).to be_false
+    end
+
+    it 'can perform events' do
+      @elevator.prepare
+      expect(@elevator.current_state).to eq(:doors_closing)
+      expect(@elevator.doors_closing?).to be_true
+      expect(@elevator.idle?).to be_false
+      expect(@elevator.possible_events).to eq([:go_up,:go_down])
+      expect{@elevator.start}.to raise_error
+      @elevator.go_down
+      expect(@elevator.can_start?).to be_true
+      @elevator.start
+      @elevator.approach
+      @elevator.stop
+    end
+  end
+
+end

data/spec/event_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Finite::Event do
+  before(:each) do
+    @block = Proc.new do
+      go from: :state1, to: :state2
+      after do
+        'hello again'
+      end
+      before do
+        'hello for the first time'
+      end
+    end
+  end
+
+  it 'has a name' do
+    event = Finite::Event.new(:event1, &@block)
+    expect(event.name).to eq(:event1)
+  end
+
+  context 'equality' do
+    it 'equals symbols that have the same name' do
+      event = Finite::Event.new(:event1, &@block)
+      expect(event).to eq(:event1)
+      expect(event).not_to eq(:event2)
+    end
+
+    it 'equals events with the same name' do
+      event1 = Finite::Event.new(:event1, &@block)
+      event2 = Finite::Event.new(:event2, &@block)
+      event3 = Finite::Event.new(:event1, &@block)
+
+      expect(event1).to eq(event3)
+      expect(event1).not_to eq(event2)
+    end
+
+    it "doesn't equal things that aren't symbols or events" do
+      event = Finite::Event.new(:event1, &@block)
+      expect(event).not_to eq('string')
+    end
+  end
+
+  it 'should create transitions' do
+    event = Finite::Event.new(:event1, &@block)
+    event.transitions.count.should be(1)
+    event.transitions[:state1].to.should eq(:state2)
+    event.transitions[:state1].from.should eq(:state1)
+  end
+
+  it 'should create callbacks' do
+    event = Finite::Event.new(:event1, &@block)
+
+    expect(event.callbacks[:before]).not_to be_nil
+    expect(event.callbacks[:after]).not_to be_nil
+    expect(event.callbacks[:after][0].call).to eq('hello again')
+    expect(event.callbacks[:before][0].call).to eq('hello for the first time')
+  end
+
+  it 'has to_s and inspect methods' do
+    event = Finite::Event.new(:event, &@block)
+    expect(event.to_s).to eq('event')
+    expect(event.inspect).to eq(:event)
+  end
+end

data/spec/machine_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Finite::StateMachine do
+  before(:each) do
+    @elevator = Elevator.new
+    @machine = Finite::StateMachine.machines[Elevator]
+  end
+
+  context 'adding events' do
+    it 'has events' do
+      expect(@machine.events.count).to be(10)
+    end
+
+    it 'cannot have events with the same name' do
+      expect{@machine.add_event(:prepare){}}.to raise_error
+    end
+
+    it 'cannot be stupid with your event naming' do
+      expect{@machine.add_event(:to_s)}.to raise_error
+    end
+
+    it 'increases in size when an event is added' do
+      @machine.add_event(:random_event){}
+      expect(@machine.events.count).to be(11)
+    end
+    it 'adds the proper helper methods' do
+      expect(@elevator.methods).to include(:random_event)
+      expect(@elevator.methods).to include(:can_random_event?)
+    end
+  end
+
+  context 'adding states' do
+    it 'has states' do
+      expect(@machine.states.count).to be(9)
+    end
+
+    it 'cannot be stupid with your state naming' do
+      expect{@machine.add_state(:const_defined){}}.to raise_error
+    end
+
+    it 'cannot have states with the same name' do
+      @machine.add_state(:doors_closing){}
+      expect(@machine.states.count).to be(9)
+    end
+
+    it 'increases in size when a state is added' do
+      @machine.add_state(:random_state){}
+      expect(@machine.states.count).to be(10)
+    end
+
+    it 'adds the proper helper method' do
+      expect(@elevator.methods).to include(:random_state?)
+    end
+  end
+
+  context 'callbacks' do
+    it 'has after and before keys' do
+      expect(@machine.callbacks).to include(:before)
+      expect(@machine.callbacks).to include(:after)
+    end
+
+    it 'adds callbacks' do
+      expect(@machine.callbacks[:before]).to include(:doors_closing)
+      expect(@machine.callbacks[:before]).to include(:doors_opening)
+    end
+  end
+end

data/spec/models/elevator.rb

@@ -0,0 +1,94 @@
+
+class Elevator
+  include Finite
+
+  def initialize
+    @before_called = 0
+    @after_called = 0
+  end
+
+  finite initial: :idle do
+
+    before :doors_closing do
+      puts 'Doors Closing!'
+    end
+
+    before :doors_opening do
+      puts 'Doors Opening!'
+    end
+
+    after :doors_closing do
+      puts "I'm no longer idle"
+    end
+
+    before do
+      @before_called += 1
+    end
+
+    after do
+      @after_called += 1
+    end
+
+
+    event :prepare do
+      go from: :idle, to: :doors_closing
+    end
+
+    event :go_up do
+      go from: :doors_closing, to: :elevator_going_up
+      after do
+        puts 'Going Up!'
+      end
+    end
+
+    event :go_down do
+      go from: :doors_closing, to: :elevator_going_down
+      after do
+        puts 'Going Down!'
+      end
+    end
+
+    event :start do
+      go from: [:elevator_going_up, :elevator_going_down], to: :moving
+    end
+
+    event :approach do
+      go from: :moving, to: :stopping
+    end
+
+    event :stop do
+      go from: :stopping, to: :doors_opening
+      before do
+        announce_floor
+      end
+    end
+
+    event :open_doors do
+      go from: :doors_opening, to: :at_floor
+    end
+
+    event :finish do
+      go from: :at_floor, to: :checking_next_dest
+    end
+
+    event :make_request do
+      go from: :checking_next_dest, to: :doors_closing
+    end
+
+    event :make_no_request do
+      go from: :checking_next_dest, to: :idle
+    end
+  end
+  def announce_floor
+    puts "Arriving on floor #{rand(10)}"
+  end
+end
+
+# elevator = Elevator.new
+# elevator.prepare
+# elevator.go_up
+# elevator.start
+# elevator.approach
+# elevator.stop
+# puts elevator.can_open_doors?
+# puts elevator.can_finish?

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'rspec'
+require 'simplecov'
+
+SimpleCov.start
+require File.join(File.dirname(__FILE__), '..', 'lib', 'finite')
+Dir[File.dirname(__FILE__) + "/models/*.rb"].sort.each { |f| require File.expand_path(f) }
+
+RSpec.configure do |config|
+  original_stderr = $stderr
+  original_stdout = $stdout
+  config.before(:all) do
+    # Redirect stderr and stdout
+    $stderr = File.new(File.join(File.dirname(__FILE__), 'null.txt'), 'w')
+    $stdout = File.new(File.join(File.dirname(__FILE__), 'null.txt'), 'w')
+  end
+  config.after(:all) do
+    $stderr = original_stderr
+    $stdout = original_stdout
+  end
+end

data/spec/state_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Finite::State do
+  before(:each) do
+    @name = :state_name
+  end
+
+  it 'has a name' do
+    Finite::State.new(@name).name.should eq(:state_name)
+  end
+  context 'equality' do
+    it 'equals a symbol of the same name' do
+      state = Finite::State.new(@name)
+      expect(state).to eq(:state_name)
+      expect(state).not_to eq(:different_name)
+    end
+
+    it 'equals a state with the same name' do
+      state1 = Finite::State.new(@name)
+      state2 = Finite::State.new(:different_name)
+      state3 = Finite::State.new(@name)
+      expect(state1).to eq(state3)
+      expect(state1).not_to eq(state2)
+    end
+
+    it "doesn't equal objects that aren't states or symbols" do
+      state = Finite::State.new(@name)
+      expect(state).not_to eq('string')
+    end
+  end
+  it 'has to_s and inspect methods' do
+    state = Finite::State.new(@name)
+    expect(state.to_s).to eq('state_name')
+    expect(state.inspect).to eq(:state_name)
+  end
+end

data/spec/transition_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Finite::Transition do
+  it 'has a to and a from' do
+    transition = Finite::Transition.new({from: :state1, to: :state2})
+    expect(transition.from).to eq(:state1)
+    expect(transition.to).to eq(:state2)
+  end
+
+  it 'equals transitions with the same to and from' do
+    transition1 = Finite::Transition.new({from: :state1, to: :state2})
+    transition2 = Finite::Transition.new({from: :state1, to: :state3})
+    transition3 = Finite::Transition.new({from: :state4, to: :state2})
+    transition4 = Finite::Transition.new({from: :state1, to: :state2})
+
+    expect(transition1).not_to eq(transition2)
+    expect(transition1).not_to eq(transition3)
+    expect(transition1).to eq(transition4)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: finite
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Kristen Mills
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-29 00:00:00.000000000 Z
+date: 2013-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,48 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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
+    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: 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: A simple state machine implementation for ruby
 email:
 - kristen@kristen-mills.com
@@ -46,17 +88,27 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - finite.gemspec
 - lib/finite.rb
+- lib/finite/class_methods.rb
 - lib/finite/event.rb
+- lib/finite/finite.rb
 - lib/finite/machine.rb
 - lib/finite/state.rb
 - lib/finite/transition.rb
 - lib/finite/version.rb
+- spec/elevator_spec.rb
+- spec/event_spec.rb
+- spec/machine_spec.rb
+- spec/models/elevator.rb
+- spec/spec_helper.rb
+- spec/state_spec.rb
+- spec/transition_spec.rb
 homepage: http://github.com/kristenmills/finite
 licenses:
 - MIT
@@ -81,4 +133,12 @@ rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: A simple state machine implementation for ruby
-test_files: []
+test_files:
+- spec/elevator_spec.rb
+- spec/event_spec.rb
+- spec/machine_spec.rb
+- spec/models/elevator.rb
+- spec/spec_helper.rb
+- spec/state_spec.rb
+- spec/transition_spec.rb
+has_rdoc: