state_methods 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.env
+.powrc
+.rspec
+.zeus*
+tmp

data/.rvmrc

@@ -0,0 +1,2 @@
+[ -e .env ] && . .env
+rvm use 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in state_methods.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 zelig
+
+MIT License
+
+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,106 @@
+# StateMethods
+
+
+Suppose you wish to define  method which executes code dependent on a state of an instance:
+
+```ruby
+def state_method(*args)
+  case state
+  when :a then ...
+  when :b then ...
+  ...
+end
+```
+
+Now suppose you would like this generic behaviour (say coming from an included module or subclass) but would like to override it in some states. You need to rewrite the whole function and fall back to super. 
+
+This implementation of state dependence makes it unavoidable that an instance invocation matches the state against all cases especially if there is many of them and falling back to super makes it worse. Apart from this, while explicit, the case statements may be too verbose.
+
+The [state machine gem](https://github.com/pluginaweek/state_machine) offers such state-driven instance behaviour:
+
+```ruby
+class Vehicle
+  # ...
+  state_machine :state, :initial => :parked do
+    
+    #... describe transitions
+
+    state :parked do
+      def speed
+        0
+      end
+    end
+
+    state :idling, :first_gear do
+      def speed
+        10
+      end
+    end
+
+    state all - [:parked, :stalled, :idling] do
+      def moving?
+        true
+      end
+    end
+
+    state :parked, :stalled, :idling do
+      def moving?
+        false
+      end
+    end
+  end
+end
+```
+
+- Call state-driven behavior that's undefined for the state raises a NoMethodError
+- does not allow for open ended state values
+- order-dependent unsafe specification, but 'all' does not override any specific state, behaves as default
+
+- allow partitions and declarative order-independent specification
+- open ended values 
+- extension via inheritance
+
+class Model
+
+
+source("sm.rb")
+vehicle = Vehicle.new           # => #<Vehicle:0xb7cf4eac @state="parked", @seatbelt_on=false>
+vehicle.state                   # => "parked"
+vehicle.speed                   # => 0
+vehicle.moving?                 # => false
+
+vehicle.ignite                  # => true
+vehicle.state                   # => "idling"
+vehicle.speed                   # => 0
+vehicle.moving?                 # => false
+
+vehicle.shift_up                # => true
+vehicle.state                   # => "first_gear"
+vehicle.speed                   # => 10
+vehicle.moving?                 # => true
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'state_methods'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install state_methods
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/state_methods.rb

@@ -0,0 +1,15 @@
+require "state_methods/version"
+require "state_methods/base"
+require "state_methods/method_utils"
+
+module StateMethods
+
+  # extend ::StateMethods::MethodUtils
+
+  def self.included(base)
+    base.class_eval do
+      include ::StateMethods::Base
+    end
+  end
+
+end

data/lib/state_methods/base.rb

@@ -0,0 +1,69 @@
+require "state_methods/partition"
+require "active_support/core_ext/class/attribute_accessors"
+
+module StateMethods
+
+  class CannotOverrideError < StandardError; end
+  class PartitionNotFound < StandardError; end
+
+  module Base
+
+
+    def self.included(base)
+      base.extend StateMethodsClassMethods
+      base.class_eval do
+        include StateMethodsInstanceMethods
+      end
+    end
+
+    module StateMethodsInstanceMethods
+    end
+
+    module StateMethodsClassMethods
+
+      def new_state_partition(*spec)
+        ::StateMethods::Partition.new(*spec)
+      end
+
+      def set_state_partition(state_accessor, partition_name, spec)
+        orig = get_state_partition(state_accessor, partition_name)
+        begin
+          new_partition = new_state_partition(spec, orig)
+          ::StateMethods::MethodUtils.define_class_method(self, [:partition, state_accessor, partition_name], new_partition)
+          ::StateMethods::MethodUtils.define_instance_method(self, :"#{state_accessor}_is_a?") do |s|
+            current_state = send(state_accessor)
+            current_state == s or
+            self.class.get_state_partition(state_accessor, partition_name).ancestors(current_state||:*).include?(s)
+          end
+        rescue ArgumentError
+          raise CannotOverrideError
+        end
+      end
+
+      def get_state_partition(*args)
+        ::StateMethods::MethodUtils.call(self, [:partition, *args])
+      end
+
+      def state_method(method_name, state_accessor, partition_name)
+        get_state_partition(state_accessor, partition_name) or raise PartitionNotFound
+
+        ::StateMethods::MethodUtils.define_class_method(self, method_name) do |*states, &block|
+          states.each do |s|
+            ::StateMethods::MethodUtils.define_instance_method(self, [method_name, s], &block)
+          end
+        end
+
+        ::StateMethods::MethodUtils.define_instance_method(self, method_name) do |*args|
+          keys = self.class.get_state_partition(state_accessor, partition_name).ancestors(send(state_accessor)||:*)
+          if m = ::StateMethods::MethodUtils.find_defined(self, method_name, *keys)
+            send(m, *args)
+          end
+        end
+
+      end
+
+
+    end
+
+  end
+end

data/lib/state_methods/method_utils.rb

@@ -0,0 +1,54 @@
+module StateMethods
+
+  module MethodUtilsClassMethods
+
+    def find_defined(object, name, *keys)
+      if key = keys.shift
+        m = method_name(name, key)
+        if object.respond_to?(m)
+          m
+        else
+          find_defined(object, name, *keys)
+        end
+      end
+    end
+
+    def define_class_method(klass, name, val=nil, &block)
+      name = method_name(*name) if name.is_a?(Array)
+      (class << klass; self end).send(:define_method, name, &block || -> { val } )
+    end
+
+    def define_instance_method(klass, name, val=nil, &block)
+      name = method_name(*name) if name.is_a?(Array)
+      klass.send(:define_method, name, &block)
+    end
+
+    def method_name(*keys)
+      :"__#{keys.map(&:to_s).join('__')}"
+    end
+
+    def call(object, keys)
+      object.send(method_name(*keys))
+    rescue NoMethodError
+      nil
+    end
+
+    # def set(klass, keys, val=nil, &block)
+    # m = method_name(*keys)
+    # (class << klass; self end).class_eval do
+    # klass.instance_eval do
+    # (class << klass; self end).instance_eval do
+    #   define_method m do |*args|
+    #     val
+    #   end
+    # end
+    # define_class_method(klass, method_name(*keys)) { val }
+    # end
+
+  end
+
+  module MethodUtils
+    extend MethodUtilsClassMethods
+  end
+
+end

data/lib/state_methods/partition.rb

@@ -0,0 +1,53 @@
+module StateMethods
+  class Partition
+    def ==(p)
+      index == p.index
+    end
+
+    def initialize(partition = {}, ancestor = nil)
+      partition = {} if partition == [] || partition == :default
+      raise ArgumentError, "partition must be a Hash" unless partition.is_a?(Hash)
+      partition = { :all => partition } unless partition[:all] || partition['all']
+      @index = process(partition, ancestor ? ancestor.index.dup : {}, ancestor ? nil : [])
+    end
+
+    def ancestors(s)
+      s = s.to_sym
+      # unsafe to prepend s but it catches undeclared state
+      index[s] || (index[:*] && [s, *(index[:*])]) || [s, :all]
+    end
+
+    protected
+
+    def index
+      @index
+    end
+
+    def process(partition, index, prefix)
+      partition.each do |k, v|
+        k = k.to_sym
+        orig_prefix = index[k]
+        new_prefix = nil
+        if prefix
+          new_prefix = [k, *prefix]
+          if orig_prefix
+            raise ArgumentError, "duplicate state or partition '#{k}'" unless new_prefix == orig_prefix
+          else
+            index[k] = new_prefix
+          end
+        else
+          new_prefix = orig_prefix || [k, :all]
+        end
+        case v
+        when Hash then process(v, index, new_prefix) unless v.empty?
+        when Symbol, String then process({ v => {} }, index, new_prefix)
+        when Array then v.each { |e| process({ e => {} }, index, new_prefix) }
+        else
+          raise ArgumentError, "invalid partition specification for '#{k}' => '#{v.inspect}'"
+        end
+      end
+      index
+    end
+
+  end
+end

data/lib/state_methods/version.rb

@@ -0,0 +1,3 @@
+module StateMethods
+  VERSION = "0.0.1"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/state_methods_spec.rb

@@ -0,0 +1,319 @@
+require 'spec_helper'
+require 'state_methods'
+
+describe "state methods" do
+
+  class TestModel
+    include ::StateMethods
+    def state
+      @state
+    end
+    def state=(a)
+      @state = a
+    end
+    def state!(a)
+      self.state = a
+      self
+    end
+    def other_state
+      @other_state
+    end
+    def other_state=(a)
+      @other_state = a
+    end
+    def other_state!(a)
+      self.other_state = a
+      self
+    end
+  end
+
+  def model_class
+    @model_class
+  end
+
+  def model_class!
+    @model_class = Class.new(TestModel)
+  end
+
+  def model_subclass
+    @model_subclass
+  end
+
+  def model_subclass!
+    @model_subclass = Class.new(model_class)
+  end
+
+  def model!
+    @model = (model_subclass || model_class).new
+  end
+
+  def model
+    @model
+  end
+
+  before(:each) do
+    model_class!
+  end
+
+  describe ::StateMethods::Partition do
+    it "default partition" do
+      partition = model_class.new_state_partition(:default)
+      model_class.new_state_partition(:all => []).should == partition
+      model_class.new_state_partition({}).should == partition
+      model_class.new_state_partition().should == partition
+      model_class.new_state_partition([]).should == partition
+    end
+
+    it "partition can mix string/symbol" do
+      partition = model_class.new_state_partition(:a => :b)
+      model_class.new_state_partition(:a => 'b').should == partition
+      model_class.new_state_partition('a' => 'b').should == partition
+      model_class.new_state_partition('a' => :b).should == partition
+    end
+
+    it "partition does not allow duplicate states" do
+      lambda { model_class.new_state_partition(:a => 'a') }.should raise_error(ArgumentError, "duplicate state or partition 'a'")
+    end
+
+    it "partition does not invalid state specification" do
+      lambda { model_class.new_state_partition(:a => nil) }.should raise_error(ArgumentError, "invalid partition specification for 'a' => 'nil'")
+    end
+  end
+
+  describe "state partition declarations are allowed" do
+
+    it "with state, partition name and partition" do
+      model_class.set_state_partition :state, :partition, :a => :b
+      model_class.get_state_partition(:state, :partition).should == model_class.new_state_partition(:a => :b)
+    end
+
+    it "if they extend earlier declarations" do
+      model_class.set_state_partition :state, :partition, :a => :b
+      model_class.set_state_partition :state, :partition, :a => :c
+      model_class.get_state_partition(:state, :partition).should == model_class.new_state_partition(:a => [:b, :c])
+    end
+
+    it "unless they contradict earlier declarations" do
+      model_class.set_state_partition :state, :partition, :a => :b
+      lambda { model_class.set_state_partition :state, :partition, :c => :a }.should raise_error(::StateMethods::CannotOverrideError)
+    end
+
+    it "and are inherited" do
+      model_class.set_state_partition :state, :partition, :a => :b
+      model_subclass = Class.new(model_class)
+      model_subclass.get_state_partition(:state, :partition).should == model_class.new_state_partition(:a => :b)
+    end
+
+    it "and are extensible in subclass, not overwritten in superclass" do
+      model_class.set_state_partition :state, :partition, :a => :b
+      model_subclass = Class.new(model_class)
+      model_subclass.set_state_partition :state, :partition, :a => :c
+      model_subclass.get_state_partition(:state, :partition).should == model_class.new_state_partition(:a => [:b, :c])
+      model_class.get_state_partition(:state, :partition).should == model_class.new_state_partition(:a => :b)
+    end
+
+    it "and define state_is_a? instance method" do
+      model_class.set_state_partition :state, :partition, :a => :b
+      model!.state!(:b)
+      model.state_is_a?(:b).should be_true
+      model.state_is_a?(:a).should be_true
+      model.state_is_a?(:all).should be_true
+      model.state_is_a?(:c).should be_false
+    end
+
+  end
+
+  describe "state method declarations" do
+
+    before(:each) do
+      model_class.set_state_partition :state, :partition, :default
+    end
+
+    it "take state method, partition as arguments" do
+      model_class.state_method :test, :state, :partition
+    end
+
+    it "raise PartitionNotFound error if partition is not set up" do
+      lambda { model_class.state_method :test, :state, :nopartition }.should raise_error(::StateMethods::PartitionNotFound)
+    end
+
+    it "should define class and instance method" do
+      model_class.state_method :test, :state, :partition
+      model_class.should respond_to(:test)
+      model!.should respond_to(:test)
+    end
+
+  end
+
+  describe "state method behaviour" do
+
+    before(:each) do
+      model_class.set_state_partition :state, :partition, :default
+      model_class.state_method :test, :state, :partition
+      model!.state!(:none)
+    end
+
+    shared_examples_for 'singular specification' do
+      it "#test -> nil if none set if state=nil" do
+        model.state!(nil).state.should be_nil
+        model.test.should be_nil
+      end
+
+      it "#test -> 1 if all set to 1 if state=nil" do
+        model_class.test(:all) { 1 }
+        model.state!(nil).state.should be_nil
+        model.test.should == 1
+      end
+
+      it "#test -> 1 if all set to 1 if state=a" do
+        model_class.test(:all) { 1 }
+        model.state!(:a).state.should == :a
+        model.test.should == 1
+      end
+    end
+
+    shared_examples_for 'same-class specification' do
+
+      before(:each) do
+        model!.state!(:none)
+      end
+
+      include_examples 'singular specification'
+
+      it "#test -> 1 if all set to 0 and a set to 1 if state=a" do
+        model_class.test(:all) { 0 }
+        model_class.test(:a) { 1 }
+        model.state!(:a).state.should == :a
+        model.test.should == 1
+      end
+
+      it "#test -> 0 if all set to 0 and a set to 1 if state=b" do
+        model_class.test(:all) { 0 }
+        model_class.test(:a) { 1 }
+        model.state!(:b).state.should == :b
+        model.test.should == 0
+      end
+
+      it "#test -> 1 if a set to 1 and THEN all set to 0  if state=a" do
+        model_class.test(:a) { 1 }
+        model_class.test(:all) { 0 }
+        model.state!(:a).state.should == :a
+        model.test.should == 1
+      end
+    end
+
+    context "with same-class specification" do
+
+      include_examples 'same-class specification'
+
+    end
+
+    context "with multiple state_methods with multiple specification" do
+
+      before(:each) do
+        model_class.set_state_partition :other_state, :partition, :default
+        model_class.state_method :other_test, :other_state, :partition
+        model_class.other_test(:all) { 2 }
+        model!.other_state!(:a)
+        model!.state!(:none)
+      end
+
+      include_examples 'same-class specification'
+
+    end
+
+
+    context "with specification across superclass and subclass" do
+
+      before(:each) do
+        model_subclass!
+        model!.state!(:none)
+      end
+
+      include_examples 'singular specification'
+
+      it "#test -> 1 if all set to 0 and a set to 1 (in subclass) if state=a" do
+        model_class.test(:all) { 0 }
+        model_subclass.test(:a) { 1 }
+        model.state!(:a).state.should == :a
+        model.test.should == 1
+      end
+
+      it "#test -> 0 if all set to 0 and a set to 1 (in subclass) if state=b" do
+        model_class.test(:all) { 0 }
+        model_subclass.test(:a) { 1 }
+        model.state!(:b).state.should == :b
+        model.test.should == 0
+      end
+
+      it "#test -> 1 if a set to 1 and THEN all set to 0 (in subclass) if state=a" do
+        model_class.test(:a) { 1 }
+        model_subclass.test(:all) { 0 }
+        model.state!(:a).state.should == :a
+        model.test.should == 1
+      end
+
+      it "#test -> 1 if all set to 0 (in subclass) and a set to 1 if state=a" do
+        model_subclass.test(:all) { 0 }
+        model_class.test(:a) { 1 }
+        model.state!(:a).state.should == :a
+        model.test.should == 1
+      end
+
+      it "#test -> 0 if all set to 0 (in subclass) and a set to 1 if state=b" do
+        model_subclass.test(:all) { 0 }
+        model_class.test(:a) { 1 }
+        model.state!(:b).state.should == :b
+        model.test.should == 0
+      end
+
+      it "#test -> 1 if a set to 1 (in subclass) and THEN all set to 0  if state=a" do
+        model_subclass.test(:a) { 1 }
+        model_class.test(:all) { 0 }
+        model.state!(:a).state.should == :a
+        model.test.should == 1
+      end
+
+      it "#test -> 0 if a set to 1 (in subclass) and all set to 0  if state=a in superclass" do
+        model_subclass.test(:a) { 1 }
+        model_class.test(:all) { 0 }
+        model_class.new.state!(:a).test.should == 0
+      end
+
+    end
+
+    context "multiple states and state sets" do
+
+      before(:each) do
+        model_class.set_state_partition :state, :partition, { :ab => [:a, :b] }
+        model_class.state_method :test, :state, :partition
+        model_subclass!.set_state_partition :state, :partition, { :cd => [:c, :d], :ab => { :b => [:b0, :b1] } }
+        model!.state!(:none)
+      end
+
+      it "inherit spec from superclass even if state is only explicit in subclass partition" do
+        model_class.test(:c) { 1 }
+        model.state!(:c).state.should == :c
+        model.test.should == 1
+      end
+
+      it "specification block is executed in model instance scope" do
+        model_class.test(:all) { state }
+        model.state!(:a).test.should == :a
+        model.state!(:c).state.should == :c
+        model.test.should == :c
+      end
+
+      it "specification block arguments are passed correctly" do
+        model_class.test(:a) { |first, second, *rest| "state: #{state}, first: #{first}, second: #{second}, rest: #{rest.join(', ')}" }
+        model.state!(:a).state.should == :a
+        model.test(1, 2, 3, 4).should == "state: a, first: 1, second: 2, rest: 3, 4"
+      end
+
+      include_examples 'singular specification'
+
+    end
+
+  end
+
+end

data/state_methods.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'state_methods/version'
+DESC = %q{declarative state aware method definitions}
+
+Gem::Specification.new do |gem|
+  gem.name          = "state_methods"
+  gem.version       = StateMethods::VERSION
+  gem.authors       = ["zelig"]
+  gem.email         = ["viktor.tron@gmail.com"]
+  gem.description   = DESC
+  gem.summary       = DESC
+  gem.homepage      = "https://github.com/zelig/state_methods.git"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'debugger'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'activemodel'
+  gem.add_development_dependency 'state_machine'
+
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: state_methods
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- zelig
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: state_machine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: declarative state aware method definitions
+email:
+- viktor.tron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/state_methods.rb
+- lib/state_methods/base.rb
+- lib/state_methods/method_utils.rb
+- lib/state_methods/partition.rb
+- lib/state_methods/version.rb
+- spec/spec_helper.rb
+- spec/state_methods_spec.rb
+- state_methods.gemspec
+homepage: https://github.com/zelig/state_methods.git
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3006866352214158636
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3006866352214158636
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: declarative state aware method definitions
+test_files:
+- spec/spec_helper.rb
+- spec/state_methods_spec.rb