state_methods 0.0.1 → 0.1.0

data/lib/state_methods.rb

@@ -1,5 +1,5 @@
 require "state_methods/version"
-require "state_methods/base"
+require "state_methods/implementations"
 require "state_methods/method_utils"
 
 module StateMethods
@@ -8,7 +8,7 @@ module StateMethods
 
   def self.included(base)
     base.class_eval do
-      include ::StateMethods::Base
+      include ::StateMethods::Implementations
     end
   end
 

data/lib/state_methods/factory.rb

@@ -0,0 +1,50 @@
+require "state_methods/partition"
+
+module StateMethods
+
+  class Factory
+
+    def initialize(klass, state_accessor, partition)
+      @klass = klass
+      @state_accessor = state_accessor
+      @partition = partition
+      @keys = [state_accessor]
+      init
+    end
+
+    def init
+    end
+
+    def check(method_name, force = false)
+    end
+
+    def factory_for(klass)
+      self
+    end
+
+    def declare(method_name)
+      this = self
+      ::StateMethods::MethodUtils.define_class_method(@klass, method_name) do |*states, &block|
+        factory = this.factory_for(self)
+        states.each do |state|
+          factory.set(self, method_name, state, &block)
+        end
+      end
+      check(method_name, force=true)
+
+      state_accessor = @state_accessor
+      ::StateMethods::MethodUtils.define_instance_method(@klass, method_name) do |*args|
+        state = send(state_accessor) || :*
+        factory = this.factory_for(self.class)
+        begin
+          factory.get(self, method_name, state, *args)
+        rescue Undefined
+          nil
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/state_methods/implementations.rb

@@ -0,0 +1,90 @@
+require "active_support/core_ext/class/attribute_accessors"
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/string/inflections.rb'
+require "state_methods/factory"
+require "state_methods/implementations/functional"
+require "state_methods/implementations/classy"
+
+module StateMethods
+
+  class CannotOverrideError < ArgumentError; end
+  class UndeclaredState < ArgumentError; end
+  class PartitionNotFound < StandardError; end
+  class Undefined < StandardError; end
+  IMPLEMENTATION = 'Functional'
+  # IMPLEMENTATION = 'Classy'
+  mattr_accessor :implementation
+  @@implementation = IMPLEMENTATION
+
+  module Implementations
+
+    def self.included(base)
+      base.class_eval do
+        class_attribute :_state_partitions
+        self._state_partitions = {}
+        include InstanceMethods
+      end
+      base.extend ClassMethods
+    end
+
+    module InstanceMethods
+    end
+
+    module ClassMethods
+
+      def state_method(method_name, state_accessor, options = {})
+        raise ArgumentError, "'#{method_name}' already defined" if respond_to?(method_name)
+        factory = _state_method_factory_for(state_accessor, options)
+        factory.declare(method_name)
+      end
+
+      def _state_method_factory_for(state_accessor, options = {})
+        @_state_method_factories ||= {}
+        factory = @_state_method_factories[state_accessor]
+        unless factory
+          partition = _state_partition_for(state_accessor, options) or raise(PartitionNotFound)
+          factory_class = begin
+            implementation = options[:implementation] || ::StateMethods.implementation
+            "::StateMethods::Implementations::#{implementation}".constantize
+          rescue NameError
+            raise ArgumentError, "implementation '#{implementation}' not found"
+          end
+          factory = @_state_method_factories[state_accessor] ||= factory_class.new(self, state_accessor, partition)
+        end
+        factory
+      end
+
+      def _state_partition_for(state_accessor, options = {})
+        orig = _state_partitions[state_accessor]
+        extension = options[:extend]
+        spec = options[:partition]
+        if orig
+          raise ArgumentError, "partition for '#{state_accessor}' already defined" if spec
+        else
+          raise ArgumentError, "partition for '#{state_accessor}' not defined" if extension
+        end
+        spec ||= extension
+        return orig unless spec
+        raise ArgumentError, "partition for '#{state_accessor}' should be set before state_method calls within a class" if
+        @_state_method_factories && @_state_method_factories[state_accessor]
+        begin
+          new_partition = ::StateMethods::Partition.new(spec, orig)
+          ::StateMethods::MethodUtils.define_instance_method(self, :"#{state_accessor}_is_a?") do |s|
+            current_state = send(state_accessor)
+            current_state == s or
+            new_partition.ancestors(current_state||:*).include?(s)
+          end
+          self._state_partitions = _state_partitions.merge(state_accessor => new_partition)
+          new_partition
+        rescue ::StateMethods::DuplicateStateError => exc
+          if orig
+            raise CannotOverrideError, exc.to_s
+          else
+            raise exc
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/state_methods/implementations/classy.rb

@@ -0,0 +1,148 @@
+require 'active_support/core_ext/class/attribute.rb'
+
+module StateMethods
+  module Implementations
+    class Proxy
+      class_attribute :_keys
+
+      def initialize(base)
+        @base = base
+      end
+
+      def base_proxy_for(state)
+        @base.class._state_method_factory_for(*_keys).class_for(state).new(@base)
+      end
+
+    end
+
+    class Classy < StateMethods::Factory
+
+      def init
+        proxy_const = [:proxy, @state_accessor].join('_').camelize
+        @proxy = if Object.const_defined?(proxy_const)
+          proxy_const.constantize
+        else
+          keys = @keys
+          make!(proxy_const, Proxy) do
+            self._keys = keys
+          end
+        end
+
+        @superclass = @klass.superclass
+        if @superclass.respond_to?(:_state_method_factory_for)
+          begin
+            @super_proxy = @superclass._state_method_factory_for(*@keys)
+          rescue PartitionNotFound
+          end
+        end
+        @partition.index.each do |state, ancestors|
+          superstate = ancestors[1]
+          make(state, superstate)
+        end
+      end
+
+      def check(method_name, force = false)
+        ok = begin
+          Proxy.new(nil).send(method_name)
+          false
+        rescue NoMethodError
+          true
+        rescue
+          false
+        end
+        unless ok
+          if force
+            @proxy.send(:undef_method, method_name)
+          else
+            raise ArgumentError, "method '#{method_name}' won't work"
+          end
+        end
+        set(@klass, method_name, :all) { raise Undefined }
+      end
+
+      def factory_for(klass)
+        if klass == @klass
+          self
+        else
+          klass._state_method_factory_for(*@keys)
+        end
+      end
+
+      def set(klass, method_name, state, &block)
+        # klass.should == @klass
+        klass = begin
+          class_for(state)
+        rescue NameError
+          raise UndeclaredState
+        end
+        ::StateMethods::MethodUtils.define_instance_method(klass, method_name) do |*args|
+          @base.instance_exec(*args, &block)
+        end
+      end
+
+      def get(instance, method_name, state, *args)
+        # instance.class.should == @klass
+        klass = nil
+        [state, :*, :all].find do |s|
+          begin klass = class_for(s)
+          rescue NameError
+          end
+        end
+        if klass
+          base = klass.new(instance)
+          # if base.respond_to?(method_name)
+          base.send(method_name, *args)
+          # else
+          #   raise Undefined
+          # end
+        end
+      end
+
+      def state_superclass_for(state)
+        begin
+          @super_proxy && @super_proxy.class_for(state)
+        rescue NameError
+        end
+      end
+
+      def class_for(state)
+        const_for(state).constantize
+      end
+
+      def const_for(state)
+        [@klass, @state_accessor, state].join('_').sub('*','star').camelize
+      end
+
+      def make!(const, state_superclass, &block)
+        new_class = Class.new(state_superclass,&block)
+        Object.send(:remove_const, const) if Object.const_defined?(const)
+        Object.const_set(const, new_class, true)
+        new_class
+      end
+
+      def make(state, superstate)
+        const = const_for(state)
+        unless Object.const_defined?(const)
+          if state_superclass = state_superclass_for(state)
+            make!(const, state_superclass)
+          elsif superstate
+            make!(const, @proxy) do
+              define_method :method_missing do |method_name, *args, &block|
+                klass = base_proxy_for(superstate)
+                klass.send(method_name, *args, &block)
+              end
+              define_method :respond_to_missing? do |name, include_private = false|
+                name == method_name or super
+              end
+            end
+          else
+            make!(const, @proxy)
+          end
+        end
+        const.constantize
+      end
+
+    end
+
+  end
+end

data/lib/state_methods/implementations/functional.rb

@@ -0,0 +1,21 @@
+module StateMethods
+  module Implementations
+    class Functional < StateMethods::Factory
+
+      def set(klass, method_name, state, &block)
+        ::StateMethods::MethodUtils.define_instance_method(klass, [method_name, state], &block)
+      end
+
+      def get(instance, method_name, state, *args)
+        partition = instance.class._state_partition_for(@state_accessor)
+        keys = partition.ancestors(state)
+        if m = ::StateMethods::MethodUtils.find_defined(instance, method_name, *keys)
+          instance.send(m, *args)
+        else
+          raise Undefined
+        end
+      end
+
+    end
+  end
+end

data/lib/state_methods/partition.rb

@@ -1,4 +1,6 @@
 module StateMethods
+  class DuplicateStateError < ArgumentError; end
+
   class Partition
     def ==(p)
       index == p.index
@@ -6,8 +8,7 @@ module StateMethods
 
     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']
+      partition = { :all => partition } unless partition.is_a?(Hash) && (ancestor || partition[:all] || partition['all'])
       @index = process(partition, ancestor ? ancestor.index.dup : {}, ancestor ? nil : [])
     end
 
@@ -17,12 +18,12 @@ module StateMethods
       index[s] || (index[:*] && [s, *(index[:*])]) || [s, :all]
     end
 
-    protected
-
     def index
       @index
     end
 
+    protected
+
     def process(partition, index, prefix)
       partition.each do |k, v|
         k = k.to_sym
@@ -31,13 +32,12 @@ module StateMethods
         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
+            raise DuplicateStateError, k unless new_prefix == orig_prefix
           end
         else
           new_prefix = orig_prefix || [k, :all]
         end
+        index[k] = new_prefix
         case v
         when Hash then process(v, index, new_prefix) unless v.empty?
         when Symbol, String then process({ v => {} }, index, new_prefix)
@@ -46,6 +46,7 @@ module StateMethods
           raise ArgumentError, "invalid partition specification for '#{k}' => '#{v.inspect}'"
         end
       end
+      # puts index
       index
     end
 

data/lib/state_methods/version.rb

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

data/spec/state_methods_spec.rb

@@ -1,8 +1,35 @@
 require 'spec_helper'
 require 'state_methods'
 
+class Object
+  @_consts_to_remove = []
+  class << self
+    alias :orig_const_set :const_set
+  end
+  def self.const_set(const, new_class, remove = false)
+    @_consts_to_remove << const if remove
+    orig_const_set(const, new_class)
+  end
+  def self.remove_consts_to_remove!
+    @_consts_to_remove.each { |c| remove_const(c) }
+    @_consts_to_remove = []
+  end
+end
+
 describe "state methods" do
 
+  after(:each) do
+    Object.remove_consts_to_remove!
+  end
+
+  def state_partition!(*spec)
+    ::StateMethods::Partition.new(*spec)
+  end
+
+  def state_partition
+    @state_partition
+  end
+
   class TestModel
     include ::StateMethods
     def state
@@ -33,6 +60,10 @@ describe "state methods" do
 
   def model_class!
     @model_class = Class.new(TestModel)
+    const = 'TestModel1'
+    Object.send(:remove_const, const) if Object.const_defined?(const)
+    Object.const_set(const, @model_class)
+    @model_class
   end
 
   def model_subclass
@@ -41,6 +72,10 @@ describe "state methods" do
 
   def model_subclass!
     @model_subclass = Class.new(model_class)
+    const = 'TestModel2'
+    Object.send(:remove_const, const) if Object.const_defined?(const)
+    Object.const_set(const, @model_subclass)
+    @model_subclass
   end
 
   def model!
@@ -55,265 +90,298 @@ describe "state methods" do
     model_class!
   end
 
-  describe ::StateMethods::Partition do
+  describe "partitions" 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
+      partition = state_partition!(:default)
+      state_partition!(:all => []).should == partition
+      state_partition!({}).should == partition
+      state_partition!().should == partition
+      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
+      partition = state_partition!(:a => :b)
+      state_partition!(:a => 'b').should == partition
+      state_partition!('a' => 'b').should == partition
+      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'")
+      lambda { state_partition!(:a => 'a') }.should raise_error(::StateMethods::DuplicateStateError, "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'")
+      lambda { 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)
+    it "with state and no option they retrieve correct partition" do
+      model_class._state_partition_for(:state).should be_nil
+      model_class._state_partition_for(:state, :partition => { :a => :b })
+      model_class._state_partition_for(:state).should == state_partition!(:a => :b)
+    end
+
+    it "with state, partition option and retrieve correct partition" do
+      model_class._state_partition_for(:state, :partition => { :a => :b }).should == state_partition!(:a => :b)
+    end
+
+    it "with partition option only once for a state accessor" do
+      model_class._state_partition_for :state, :partition => { :a => :b }
+      lambda { model_class._state_partition_for :state, :partition => { :a => :b } }.should raise_error(ArgumentError, "partition for 'state' already defined")
     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])
+    it "with extend option only if they extend earlier declarations" do
+      model_class._state_partition_for :state, :partition => { :a => :b }
+      lambda { model_class._state_partition_for :state, :extend => { :c => :a } }.should raise_error(::StateMethods::CannotOverrideError, "a")
     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)
+    it "with extend option only if partition is already defined for the state accessor" do
+      lambda { model_class._state_partition_for :state, :extend => { :a => :b } }.should raise_error(ArgumentError, "partition for 'state' not defined")
+    end
+
+    it "with extend option after state accessor is defined" do
+      model_class._state_partition_for :state, :partition => { :a => :b }
+      model_class._state_partition_for(:state, :extend => { :a => :c }).should == state_partition!(:a => [:b, :c])
     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)
+      model_class._state_partition_for :state, :partition => { :a => :b }
+      model_subclass!._state_partition_for(:state).should == 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)
+      model_class._state_partition_for :state, :partition => { :a => :b }
+      model_subclass!._state_partition_for :state, :extend => { :a => :c }
+      model_subclass._state_partition_for(:state).should == state_partition!(:a => [:b, :c])
+      model_class._state_partition_for(:state).should == state_partition!(:a => :b)
     end
 
     it "and define state_is_a? instance method" do
-      model_class.set_state_partition :state, :partition, :a => :b
+      model_class._state_partition_for :state, :partition => { :a => [:b, :c] }
       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
+      model.state_is_a?(:none).should be_false
     end
 
   end
 
-  describe "state method declarations" do
+  shared_examples_for 'implementation' do
 
-    before(:each) do
-      model_class.set_state_partition :state, :partition, :default
-    end
+    describe "state method declarations" do
 
-    it "take state method, partition as arguments" do
-      model_class.state_method :test, :state, :partition
-    end
+      # before(:each) do
+      #   model_class._state_partition_for :state, :partition => :default
+      # 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
+      it "take state method, partition option as arguments" do
+        model_class.state_method :test, :state, :partition => :default
       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
+      it "raise PartitionNotFound error if partition is not set up" do
+        lambda { model_class.state_method :test, :state }.should raise_error(::StateMethods::PartitionNotFound)
       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
+      it "raise PartitionNotFound error if partition is not set up" do
+        model_class.state_method :test, :state, :partition => :default
+        lambda { model_class.state_method :test, :state }.should raise_error(ArgumentError, "'test' already defined")
       end
-    end
-
-    shared_examples_for 'same-class specification' do
 
-      before(:each) do
-        model!.state!(:none)
+      it "should define class and instance method" do
+        model_class.state_method :test, :state, :partition => :default
+        model_class.should respond_to(:test)
+        model!.should respond_to(:test)
       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
+    describe "state method behaviour" do
 
-      include_examples 'same-class specification'
+      context "single method and state" do
 
-    end
+        before(:each) do
+          model_class.state_method :test, :state, :partition => [:a, :b]
+          model!.state!(:none)
+        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)
+        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.state_method :other_test, :other_state, :partition => :default
+            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 }
+            m = model_class.new.state!(:a)
+            m.state.should == :a
+            m.test.should == 0
+          end
+
+        end
       end
 
-      include_examples 'same-class specification'
+      context "multiple states and state sets" do
 
-    end
+        before(:each) do
+          model_class.state_method :test, :state, :partition => { :ab => [:a, :b] }
+          model_subclass!._state_partition_for :state, :extend => { :cd => [:c, :d], :ab => { :b => [:b0, :b1] } }
+          model!.state!(:none)
+        end
 
+        it "inherit suprestate spec from superclass even if state is only explicit in subclass partition" do
+          model_class.test(:b) { 1 }
+          model_subclass.test(:ab) { 0 }
+          model.state!(:b0).state.should == :b0
+          model.test.should == 1
+        end
 
-    context "with specification across superclass and subclass" do
+        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
 
-      before(:each) do
-        model_subclass!
-        model!.state!(:none)
-      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'
+        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
+  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'
+  context "functional implementation" do
+    include_examples 'implementation'
+  end
 
+  context "classy implementation" do
+    before(:all) do
+      ::StateMethods.implementation = 'Classy'
     end
-
+    include_examples 'implementation'
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: state_methods
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-21 00:00:00.000000000 Z
+date: 2013-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: debugger
@@ -105,7 +105,10 @@ files:
 - README.md
 - Rakefile
 - lib/state_methods.rb
-- lib/state_methods/base.rb
+- lib/state_methods/factory.rb
+- lib/state_methods/implementations.rb
+- lib/state_methods/implementations/classy.rb
+- lib/state_methods/implementations/functional.rb
 - lib/state_methods/method_utils.rb
 - lib/state_methods/partition.rb
 - lib/state_methods/version.rb
@@ -126,7 +129,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3006866352214158636
+      hash: 2652737864788483720
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -135,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3006866352214158636
+      hash: 2652737864788483720
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24

data/lib/state_methods/base.rb

@@ -1,69 +0,0 @@
-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