yasm 0.0.1

data/README.markdown

@@ -0,0 +1,228 @@
+# YASM - Yet Another State Machine
+
+Pronounced "yaz-um."
+
+
+## Install?
+
+    $ gem install yasm
+
+## Why?
+
+In a state machine, there are states, contexts, and actions. Actions have side-effects, conditional logic, etc. States have various allowable actions. 
+Contexts can support various states. All beg to be defined in classes. The other ruby state machines out there are great. But they all have hashitis. 
+Classes and mixins are the cure.
+
+## How?
+
+Let's create a state machine for a vending machine. What does a vending machine do? It lets you input money and make a selection. When you make a selection, 
+it vends the selection. Let's start off with a really simple model of this: 
+
+    class VendingMachine
+      include Yasm::Context
+
+      start :waiting
+    end
+
+    class Waiting; include Yasm::State; end
+
+    class Vending; include Yasm::State; end
+
+So far, we've created a context (a thing that has state), given it a start state, and then defined a couple of states (Waiting, Vending).
+
+So, how do we use this vending machine? We'll need to create some actions first:
+
+    class InputMoney
+      include Yasm::Action
+    end
+    
+    class MakeSelection
+      include Yasm::Action
+      
+      triggers :vending
+    end
+
+    class RetrieveSelection
+      include Yasm::Action
+      
+      triggers :waiting
+    end
+
+And now we can run a simulation:
+    
+    vending_machine = VendingMachine.new
+    
+    vending_machine.state.value 
+      #==> Waiting
+    
+    vending_machine.do! InputMoney
+    
+    vending_machine.state.value 
+      #==> Waiting
+    
+    vending_machine.do! MakeSelection
+    
+    vending_machine.state.value 
+      #==> Vending
+
+    vending_machine.do! RetrieveSelection
+    
+    vending_machine.state.value 
+      #==> Waiting
+
+There's some problems, though. Our simple state machine is a little too simple; someone could make a selection without inputing any money. 
+We need a way to limit the actions that can be applied to our vending machine based on it's current state. How do we do that? Let's redefine
+our states, using the actions macro:
+
+    class Waiting
+      include Yasm::State
+
+      actions :input_money, :make_selection
+    end
+
+    class Vending
+      include Yasm::State
+      
+      actions :retrieve_selection
+    end
+
+Now, when the vending machine is in the `Waiting` state, the only actions we can apply to it are `InputMoney` and `MakeSelection`. If we try to apply
+invalid actions to the context, `Yasm` will raise an exception. 
+
+    vending_machine.state.value 
+      #==> Waiting
+
+    vending_machine.do! RetrieveSelection
+      #==> RuntimeError: We're sorry, but the action `RetrieveSelection` 
+           is not possible given the current state `Waiting`.
+
+    vending_machine.do! InputMoney
+
+    vending_machine.state.value 
+      #==> Waiting
+
+## Side Effects
+
+How can we take our simulation farther? A real vending machine would verify that when you make a selection, 
+you actually have input enough money to pay for that selection. How can we model this? 
+
+For starters, we'll need to add a property to our `VendingMachine` 
+that lets us keep track of how much money was input. We'll also need to initialize our `InputMoney` actions with an amount.
+
+    class VendingMachine
+      include Yasm::Context
+      start :waiting
+
+      attr_accessor :amount_input
+
+      def initialize
+        @amount_input = 0
+      end
+    end 
+
+    class InputMoney
+      include Yasm::Action
+
+      def initialize(amount_input)
+        @amount_input = amount_input
+      end
+
+      def execute
+        context.amount_input += @amount_input
+      end
+    end
+
+Notice I defined the `execute` method on the action. This is the method that gets run whenever an action gets applied to a state container 
+(e.g., `vending_machine.do! InputMoney`). This is where you create side effects. 
+
+Now we can try out adding money into our vending machine: 
+    
+    vending_machine.amount_input
+      # ==> 0
+
+    vending_machine.do! InputMoney.new(10)
+
+    vending_machine.amount_input
+      # ==> 10
+
+As for verifying that we have input enough money to pay for the selection we've chosen, we'll need to create an item, then add that to our `MakeSelection` class:
+
+    class SnickersBar
+      def self.price; 30; end
+    end
+
+    class MakeSelection
+      include Yasm::Action
+
+      def initialize(selection)
+        @selection = selection
+      end
+
+      def execute
+        if context.amount_input >= @selection.price
+          trigger Vending
+        else
+          raise "We're sorry, but you have not input enough money for a #{@selection}"
+        end
+      end
+    end
+
+Notice that we called the `trigger` method inside the `execute` method instead of calling the `triggers` macro on the action. This way,
+we can conditionally move to the next logical state only when our conditions have been met (in this case, that we've input enough money to
+pay for our selection). 
+
+    v = VendingMachine.new
+
+    v.amount_input 
+      #==> 0
+
+    v.do! MakeSelection.new(SnickersBar)
+      #==> RuntimeError: We're sorry, but you have not input enough money for a SnickersBar
+
+    v.do! InputMoney.new(10)
+
+    v.do! MakeSelection.new(SnickersBar)
+      #==> RuntimeError: We're sorry, but you have not input enough money for a SnickersBar
+
+    v.do! InputMoney.new(20)
+
+    v.do! MakeSelection.new(SnickersBar)
+    
+    v.state.value 
+      #==> Vending
+
+    v.do! RetrieveSelection
+
+    v.state.value
+      #==> Waiting
+
+
+## End states
+
+Sometimes, a state is final. Like, what if, out of frustration, you threw the vending machine off the top of a 10 story building? It's probably not going
+to work again after that. You can use the `final!` macro on a state to denote that this is the end.
+
+    class TossOffBuilding
+      include Yasm::Action
+
+      triggers :obliterated
+    end
+
+    class Obliterated
+      include Yasm::State
+
+      final!
+    end
+
+    vending_machine = VendingMachine.new
+    
+    vending_machine.do! TossOffBuilding
+
+    vending_machine.do! MakeSelection.new(SnickersBar)
+    #==> RuntimeError: We're sorry, but the current state `Obliterated` is final. It does not accept any actions 
+
+
+
+## PUBLIC DOMAIN
+
+This software is committed to the public domain. No license. No copyright. DO ANYTHING! 

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/yasm.rb

@@ -0,0 +1,10 @@
+require 'active_support/core_ext/string'
+require 'yasm/conversions'
+require 'yasm/manager'
+require 'yasm/version'
+require 'yasm/state'
+require 'yasm/action'
+require 'yasm/context/anonymous_state_identifier'
+require 'yasm/context/state_configuration'
+require 'yasm/context/state_container'
+require 'yasm/context'

data/lib/yasm/action.rb

@@ -0,0 +1,29 @@
+module Yasm
+  module Action
+    attr_accessor :context, :state_container
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def triggers(state)
+        @trigger_state = state
+      end
+
+      def trigger_state; @trigger_state; end
+    end
+
+    def triggers
+      self.class.trigger_state
+    end
+
+    def trigger(state)
+      Yasm::Manager.change_state :to => state, :on => state_container
+    end
+
+    def execute
+      true
+    end
+  end
+end

data/lib/yasm/context.rb

@@ -0,0 +1,58 @@
+module Yasm
+  module Context
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # for a simple, anonymous state 
+      def start(state)
+        state_configurations[ANONYMOUS_STATE] = StateConfiguration.new
+        state_configurations[ANONYMOUS_STATE].start state
+      end
+
+      # for a named state
+      def state(name, &block)
+        raise ArgumentError, "The state name must respond to `to_sym`" unless name.respond_to?(:to_sym)
+        name = name.to_sym
+        state_configurations[name] = StateConfiguration.new 
+        state_configurations[name].instance_eval &block
+        
+        raise "You must provide a start state for #{name}" unless state_configurations[name].start_state
+
+        define_method(name) { state_container name }
+      end
+
+      # state configuration metadata
+      def state_configurations
+        @state_configurations ||= {}
+      end
+    end
+
+    def do!(*actions)
+      state.do! *actions
+    end
+
+    def state
+      raise "This class has no anonymous state" unless self.class.state_configurations[ANONYMOUS_STATE] 
+      state_container ANONYMOUS_STATE
+    end
+
+    private
+    def state_containers
+      @state_containers ||= {}
+    end
+    
+    def state_container(id)
+      unless state_containers[id]
+        state_containers[id] = 
+          StateContainer.new(
+            :context => self, 
+            :state   => self.class.state_configurations[id].start_state.to_class.new
+          )
+      end
+
+      state_containers[id]
+    end
+  end
+end

data/lib/yasm/context/anonymous_state_identifier.rb

@@ -0,0 +1,5 @@
+module Yasm
+  module Context
+    ANONYMOUS_STATE = :yasm_anonymous_state
+  end
+end

data/lib/yasm/context/state_configuration.rb

@@ -0,0 +1,15 @@
+module Yasm
+  module Context
+    class StateConfiguration
+      attr_reader :start_state
+
+      def initialize(start_state = nil)
+        @start_state = start_state
+      end
+
+      def start(state)
+        @start_state = state
+      end
+    end
+  end
+end

data/lib/yasm/context/state_container.rb

@@ -0,0 +1,31 @@
+module Yasm
+  module Context
+    class StateContainer
+      attr_accessor :context
+      attr_accessor :state #:nodoc:
+      
+      def initialize(options)
+        @context = options[:context]
+        @state   = options[:state]
+      end
+
+      def value; @state; end
+      
+      def state=(s)
+        if s.class == Class
+          @state = s.new
+        else
+          @state = s
+        end
+      end
+
+      def do!(*actions)
+        Yasm::Manager.execute(
+          :context => context, 
+          :state_container => self,
+          :actions => actions
+        )
+      end
+    end
+  end
+end

data/lib/yasm/conversions.rb

@@ -0,0 +1,2 @@
+require 'yasm/conversions/class'
+require 'yasm/conversions/symbol'

data/lib/yasm/conversions/class.rb

@@ -0,0 +1,17 @@
+module Yasm
+  module Conversions
+    module Class
+      def to_sym
+        self.to_s.underscore.to_sym
+      end
+
+      def to_class
+        self
+      end
+    end
+  end
+end
+
+class Class
+  include Yasm::Conversions::Class
+end

data/lib/yasm/conversions/symbol.rb

@@ -0,0 +1,13 @@
+module Yasm
+  module Conversions
+    module Symbol
+      def to_class
+        self.to_s.camelize.constantize
+      end
+    end
+  end
+end
+
+class Symbol
+  include Yasm::Conversions::Symbol
+end

data/lib/yasm/manager.rb

@@ -0,0 +1,36 @@
+module Yasm
+  module Manager
+    module_function
+
+    def change_state(options)
+      new_state       = options[:to]
+      state_container = options[:on]
+      new_state = new_state.to_class if new_state.respond_to? :to_class
+
+      state_container.state = new_state.new
+    end
+    
+    def execute(options)
+      context = options[:context]
+      actions = options[:actions]
+      state_container = options[:state_container]
+
+      actions.each do |action|
+        action                  = action.new if action.class == Class
+        action.context          = context
+        action.state_container  = state_container
+        
+
+        # Verify that the action is possible given the current state
+        if state_container.state.class.final?
+          raise "We're sorry, but the current state `#{state_container.state}` is final. It does not accept any actions."
+        elsif !state_container.state.class.is_allowed?(action.class)
+          raise "We're sorry, but the action `#{action.class}` is not possible given the current state `#{state_container.state}`." 
+        end
+
+        change_state :to => action.triggers.to_class, :on => state_container if action.triggers 
+        action.execute 
+      end
+    end
+  end
+end

data/lib/yasm/state.rb

@@ -0,0 +1,34 @@
+module Yasm
+  module State
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      def actions(*allowed_actions)
+        @allowed_actions = allowed_actions
+      end
+
+      def allowed_actions
+        @allowed_actions
+      end
+
+      def is_allowed?(action)
+        return true if @allowed_actions.nil?
+        @allowed_actions.include? action.to_sym
+      end
+
+      def final!
+        @allowed_actions = []
+      end
+
+      def final?
+        @allowed_actions == []
+      end
+    end
+
+    def to_s
+      self.class.to_s
+    end
+  end
+end

data/lib/yasm/version.rb

@@ -0,0 +1,3 @@
+module Yasm
+  VERSION = File.read(File.expand_path("../../../VERSION", __FILE__)).strip
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+$LOAD_PATH.unshift './lib'
+require 'yasm'
+
+# class VendingMachine
+#   include Yasm::Context
+# 
+#   start Waiting
+# end
+# 
+# class Waiting
+#   include Yasm::State
+# end
+# 
+# class Vending
+# end
+# 
+# class InputMoney
+#   include Yasm::Action
+#   
+#   triggers Vending
+# end
+# 
+# 
+# class VendingMachine
+#   include Yasm::Context
+#   
+#   # start Waiting
+#   # 
+#   # state :status do
+#   #   start Waiting
+#   # end
+#   # 
+#   attr_accessor :money
+#   def initialize
+#     @money = 0
+#   end
+# end
+# 
+# class Waiting
+#   include Yasm::State
+# 
+#   actions InputMoney
+# end
+# 
+# class Vending
+#   include Yasm::State
+# end
+# 
+# class NotAState
+# end
+# 
+# class InputMoney
+#   include Yasm::Action
+# end
+# 
+# class Vend
+#   include Yasm::Action
+#   triggers Vending
+# 
+#   def initialize(item)
+#     @item = item
+#   end
+#   
+#   def execute
+#     puts "Vending #{@item}"
+#     context.do! Refund if context.money > 0
+#   end
+# end
+# 
+# class Refund
+#   include Yasm::Action
+# 
+#   triggers Waiting
+# 
+#   def execute
+#     puts "Refunding #{context.money}"
+#     context.money = 0
+#   end
+# end
+# 
+# class MakeSelection
+#   include Yasm::Action
+#   
+#   def initialize(selection)
+#     @selection = selection
+#   end
+# 
+#   def execute
+#     if context.money >= selection.price
+#       trigger Vending
+#       context.money -= selection.price
+#       context.do! Vend.new(selection)
+#     else
+#       puts "You must enter more money."
+#     end
+#   end
+# end
+# 
+# class NotAnAction
+# end

data/spec/yasm/context_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Yasm::Context do
+  context "when included in a class" do
+    before do
+      class VendingMachine
+        include Yasm::Context
+      end
+
+      class Waiting
+        include Yasm::State
+      end
+
+      class InputMoney
+        include Yasm::Action
+      end
+    end
+    
+    describe "##state" do
+      it "should require something that can be converted to a symbol" do
+        proc { VendingMachine.state(nil) }.should raise_exception(ArgumentError, "The state name must respond to `to_sym`")
+      end
+
+      it "should create a new state configuration" do
+        VendingMachine.state_configurations[:electricity].should be_nil
+        class On; include Yasm::State; end
+        VendingMachine.state(:electricity) { start :on }
+        VendingMachine.state_configurations[:electricity].should_not be_nil
+        VendingMachine.state_configurations[:electricity].start_state.should == :on
+      end
+
+      it "should instance_eval the block on the new state configuration" do
+        VendingMachine.state_configurations[:power].should be_nil
+        class On; include Yasm::State; end
+        VendingMachine.state(:power) { start :on }
+        VendingMachine.state_configurations[:power].should_not be_nil
+        VendingMachine.state_configurations[:power].start_state.should == :on
+      end
+
+      it "should create an instance method that returns the state" do
+        class On; include Yasm::State; end
+        VendingMachine.state(:light) { start :on }
+        VendingMachine.new.light.state.class.should == On
+      end
+    end
+    
+    describe "##start" do
+      context "when called directly on the context" do
+        it "should store the state as the start state of the anonymous state configuration" do
+          VendingMachine.state_configurations[Yasm::Context::ANONYMOUS_STATE].should be_nil
+          VendingMachine.start :waiting 
+          VendingMachine.state_configurations[Yasm::Context::ANONYMOUS_STATE].start_state.should == :waiting
+        end
+      end
+    end
+
+    describe "#do!" do
+      it "should pass all actions passed to it off to the anonymous state_container #do! method" do
+        v = VendingMachine.new
+        v.state.should_receive(:do!).with(InputMoney, InputMoney)
+        v.do! InputMoney, InputMoney
+      end
+    end
+  end
+end

data/spec/yasm/conversions_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Yasm::Conversions::Symbol do
+  it "should create a :to_class instance method on Symbols" do
+    :sym.respond_to?(:to_class).should be_true
+  end
+end
+
+describe Symbol do
+  describe "#to_class" do
+    it "should convert the symbol to a class" do
+      class SymbolTest; end
+      :symbol_test.to_class.should == SymbolTest
+    end
+
+    it "should be the inverse of the Class #to_sym class method" do
+      class SymbolTest; end
+      :symbol_test.to_class.to_sym.should == :symbol_test
+    end
+  end
+end
+
+
+describe Yasm::Conversions::Class do
+  it "should create a :to_sym class method on classes" do
+    class SymbolTest; end
+    SymbolTest.respond_to?(:to_sym).should be_true
+  end
+end
+
+describe Symbol do
+  describe "#to_sym" do
+    it "should convert the class to a symbol" do
+      class SymbolTest; end
+      SymbolTest.to_sym.should == :symbol_test
+    end
+
+    it "should be the inverse of the Symbol #to_class instance method" do
+      class SymbolTest; end
+      SymbolTest.to_sym.to_class.should == SymbolTest
+    end
+  end
+end

data/spec/yasm/manager_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Yasm::Manager do
+  describe "##execute" do
+    before do
+      class VendingMachine
+        include Yasm::Context
+        
+        start :on
+      end
+
+      class Unplug
+        include Yasm::Action
+        
+        triggers :off
+      end
+
+      class PlugIn
+        include Yasm::Action
+        
+        triggers :on
+      end
+
+      class Destroy
+        include Yasm::Action
+
+        triggers :destroyed
+      end
+
+      class On
+        include Yasm::State
+        
+        actions :unplug, :destroy
+      end
+
+      class Off
+        include Yasm::State
+        
+        actions :plug_in, :destroy
+      end
+
+      class Destroyed
+        include Yasm::State
+
+        final!
+      end
+      
+      @vending_machine = VendingMachine.new
+    end
+    
+    it "should apply each action, sequentially, to the appropriate state_container within the context" do
+      @vending_machine.state.value.class.should == On
+      
+      Yasm::Manager.execute :context => @vending_machine, :state_container => @vending_machine.state, :actions => [Unplug]
+      @vending_machine.state.value.class.should == Off
+
+      Yasm::Manager.execute :context => @vending_machine, :state_container => @vending_machine.state, :actions => [PlugIn]
+      @vending_machine.state.value.class.should == On
+    end
+
+    it "should verify that the action is possible given the current state" do
+      @vending_machine.state.value.class.should == On
+      
+      proc { 
+        Yasm::Manager.execute(
+          :context => @vending_machine, 
+          :state_container => @vending_machine.state, 
+          :actions => [PlugIn]
+        )
+      }.should raise_exception("We're sorry, but the action `PlugIn` is not possible given the current state `On`.")
+
+      proc { 
+        Yasm::Manager.execute(
+          :context => @vending_machine, 
+          :state_container => @vending_machine.state, 
+          :actions => [Unplug]
+        )
+      }.should_not raise_exception
+
+      proc {
+        Yasm::Manager.execute(
+          :context => @vending_machine,
+          :state_container => @vending_machine.state,
+          :actions => [Destroy, PlugIn]
+        )
+      }.should raise_exception("We're sorry, but the current state `Destroyed` is final. It does not accept any actions.") 
+    end
+  end
+end

data/spec/yasm/state_container_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Yasm::Context::StateContainer do
+  before do
+    class VendingMachine
+      include Yasm::Context
+    end
+
+    class Waiting
+      include Yasm::State
+    end
+
+    class InputMoney
+      include Yasm::Action
+    end
+  end
+
+  describe "#do!" do
+    it "should pass the actions off to the Yasm::Manager.execute method" do
+      v = VendingMachine.new
+      Yasm::Manager.should_receive(:execute).with(:context => v, :state_container => v.state, :actions => [InputMoney, InputMoney])
+      v.state.do! InputMoney, InputMoney
+    end
+  end
+end

data/spec/yasm/state_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Yasm::State do
+  before do
+    class TestState
+      include Yasm::State
+    end
+
+    class Action1; include Yasm::Action; end
+    class Action2; include Yasm::Action; end
+  end
+
+  describe "##actions" do 
+    it "should set the @allowed_actions to the input to this method" do
+      TestState.actions Action1, Action2 
+      TestState.allowed_actions.should == [Action1, Action2]
+    end
+  end
+
+  describe "##final!" do
+    it "should set the @allowed_actions to an empty array" do
+      TestState.final!
+      TestState.allowed_actions.should == []
+    end
+  end
+
+  describe "##final?" do
+    it "should return true if there are no allowed actions" do
+      TestState.final!
+      TestState.final?.should be_true
+    end
+  end
+end

data/yasm.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 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{yasm}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Matt Parker"]
+  s.date = %q{2011-02-12}
+  s.description = %q{Breaks up states, actions, and contexts into seperate classes.moonmaster9000@gmail.com}
+  s.email = %q{moonmaster9000@gmail.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "VERSION",
+    "lib/yasm.rb",
+    "lib/yasm/action.rb",
+    "lib/yasm/context.rb",
+    "lib/yasm/context/anonymous_state_identifier.rb",
+    "lib/yasm/context/state_configuration.rb",
+    "lib/yasm/context/state_container.rb",
+    "lib/yasm/conversions.rb",
+    "lib/yasm/conversions/class.rb",
+    "lib/yasm/conversions/symbol.rb",
+    "lib/yasm/manager.rb",
+    "lib/yasm/state.rb",
+    "lib/yasm/version.rb",
+    "yasm.gemspec"
+  ]
+  s.homepage = %q{http://github.com/moonmaster9000/yasm}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.0}
+  s.summary = %q{Yet Another State Machine. Pronounced "yaz-um."}
+  s.test_files = [
+    "spec/spec_helper.rb",
+    "spec/yasm/context_spec.rb",
+    "spec/yasm/conversions_spec.rb",
+    "spec/yasm/manager_spec.rb",
+    "spec/yasm/state_container_spec.rb",
+    "spec/yasm/state_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0"])
+      s.add_runtime_dependency(%q<i18n>, ["~> 0.5.0"])
+    else
+      s.add_dependency(%q<activesupport>, ["~> 3.0"])
+      s.add_dependency(%q<i18n>, ["~> 0.5.0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, ["~> 3.0"])
+    s.add_dependency(%q<i18n>, ["~> 0.5.0"])
+  end
+end
+

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification 
+name: yasm
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Matt Parker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-12 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 0
+        - 5
+        - 0
+        version: 0.5.0
+  type: :runtime
+  version_requirements: *id002
+description: Breaks up states, actions, and contexts into seperate classes.moonmaster9000@gmail.com
+email: moonmaster9000@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- VERSION
+- lib/yasm.rb
+- lib/yasm/action.rb
+- lib/yasm/context.rb
+- lib/yasm/context/anonymous_state_identifier.rb
+- lib/yasm/context/state_configuration.rb
+- lib/yasm/context/state_container.rb
+- lib/yasm/conversions.rb
+- lib/yasm/conversions/class.rb
+- lib/yasm/conversions/symbol.rb
+- lib/yasm/manager.rb
+- lib/yasm/state.rb
+- lib/yasm/version.rb
+- yasm.gemspec
+- README.markdown
+- spec/spec_helper.rb
+- spec/yasm/context_spec.rb
+- spec/yasm/conversions_spec.rb
+- spec/yasm/manager_spec.rb
+- spec/yasm/state_container_spec.rb
+- spec/yasm/state_spec.rb
+has_rdoc: true
+homepage: http://github.com/moonmaster9000/yasm
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Yet Another State Machine. Pronounced "yaz-um."
+test_files: 
+- spec/spec_helper.rb
+- spec/yasm/context_spec.rb
+- spec/yasm/conversions_spec.rb
+- spec/yasm/manager_spec.rb
+- spec/yasm/state_container_spec.rb
+- spec/yasm/state_spec.rb