enumerated_state 0.0.4 → 0.0.7

data/README.rdoc

@@ -15,11 +15,13 @@ Use
 	
 == Description
 
-This gem belongs to the ASPIUM family of gems -- (Another State Pattern Implementation
+This gem belongs to the ASPIUM family of gems -- (Another State Pattern Implemented
 Using Mixology).  This ASPIUM adds state pattern support to enumerated attributes (see enumerated_attribute[http://github.com/jeffp/enumerated_attribute])
 and allows multiple state variables per object, one for each enumerated attribute.
 
-== Basic implementation
+== Usage
+
+=== Basic implementation
 
 If you are using enumerated_attribute, you may have code looking something like
 
@@ -34,7 +36,7 @@ If you are using enumerated_attribute, you may have code looking something like
     end
   end
 
-Enumerated State lets you clean it up as so
+We can clean this up a little by using acts_as_enumerated_state like this
 
   class Tractor
     enum_attr :gear, %w(reverse ^neutral first)
@@ -53,13 +55,15 @@ Enumerated State lets you clean it up as so
     end
   end
 
-== Multi-variable state and enum value conflicts
+=== Multi-variable state and enum value conflicts
 
-Use the :module option to avoid naming conflicts between enumerated attributes
+If your attributes share some enum values with the same name, there will be confusion as to which
+module belongs to which enumeration.  You can clear up the collision by using the
+:module option like this
 
   class Foobar
     enum_attr :alpha, %w(state1 state2)
-    enum_attr :beta, %w(state1 state2 state3)  # names will overlap when mapped to modules
+    enum_attr :beta, %w(state1 state2 state3)  # names will collide when mapped to modules
 
     acts_as_enumerated_state :alpha
     acts_as_enumerated_state :beta, :module=>'Beta'
@@ -74,6 +78,46 @@ Use the :module option to avoid naming conflicts between enumerated attributes
     end
   end
 
+=== Strict versus non-strict
+
+By default, acts_as_enumerated_state assigns one module for each enumeration and fails
+when it cannot find the module.  For example, the following code causes an error
+
+  class Tractor
+    enum_attr :gear, %w(reverse neutral first)
+    acts_as_enumerated_state :gear
+
+    module Reverse ...  end
+    # where's the module for :neutral?
+    module First ... end
+  end
+
+  Tractor.new.gear = :neutral  #error because there's no module
+
+But sometimes you may not need a module for each enumeration.  You may want some enumerations
+to use a method defined by the object itself.  You can back off the strictness
+by setting the :strict option to false like this
+
+  class Tractor
+    enum_attr :gear, %w(reverse neutral first)
+    acts_as_enumerated_state :gear, :strict=>false
+
+    def motion; 'stopped'; end
+
+    module Reverse
+      def motion; 'backwards'; end
+    end
+    # no neutral module needed
+    module First
+      def motion; 'forwards'; end
+    end
+  end
+
+  t = Tractor.new
+  t.gear = :neutral
+  t.motion   # calls motion on the object and returns 'stopped'
+
+
 == Dependencies
 
 * meta_programming

data/lib/enumerated_state.rb

@@ -11,41 +11,45 @@ module EnumeratedState
 end
 
 class Class
-
   def acts_as_enumerated_state(enum_attr, opts={})
     enum_attr = enum_attr.to_sym
     unless (self.respond_to?(:has_enumerated_attribute?) && self.has_enumerated_attribute?(enum_attr))
       raise ArgumentError, "enumerated attribute :#{enum_attr} not defined"
     end
 
-    self.extend EnumeratedStateClassMethods
-    self.set_enumerated_state_property(enum_attr, :module_prefix, opts[:module] ? "#{opts[:module]}::" : '')
-    self.set_enumerated_state_property(enum_attr, :strict, opts[:strict] == false ? false : true)
-
     if self.method_defined?("write_enumerated_attribute_without_#{enum_attr}")
       raise EnumeratedState::RedefinitionError, "Enumerated state already defined for :#{enum_attr}"
     end
 
+    self.extend EnumeratedStateClassMethods # unless self.has_module?(EnumeratedStateClassMethods)
+    self.set_enumerated_state_property(enum_attr, :module_prefix, opts[:module] ? "#{opts[:module]}::" : '')
+    self.set_enumerated_state_property(enum_attr, :strict, opts[:strict] == false ? false : true)
+
     define_chained_method(:write_enumerated_attribute, enum_attr) do |attribute, value|
-      if (value != (old_value = self.read_enumerated_attribute(attribute)))
-        unless old_value.nil?
-          _module = self.class.get_module_for_enumerated_state(attribute, old_value)
-          self.unmix(_module) if _module
+      without_method = "write_enumerated_attribute_without_#{enum_attr}".to_sym
+
+      unless enum_attr == attribute.to_sym
+        self.__send__(without_method, attribute, value)
+      else
+        old_value = self.read_enumerated_attribute(enum_attr)
+        result = self.__send__(without_method, attribute, value)
+
+        unless value == old_value
+          unless old_value.nil?
+            _module = self.class.get_module_for_enumerated_state(attribute, old_value)
+            self.unmix(_module) if _module
+          end
+          unless value.nil?
+            _module = self.class.get_module_for_enumerated_state(attribute, value)
+            self.mixin(_module) if _module
+          end
         end
-      end
-      self.__send__("write_enumerated_attribute_without_#{enum_attr}".to_sym, attribute, value)
-      if (enum_attr == attribute.to_sym && !value.nil?)
-        _module = self.class.get_module_for_enumerated_state(attribute, value)
-        self.mixin(_module) if _module
+        result
       end
     end
   end
   alias_method :enumerated_state_pattern, :acts_as_enumerated_state
 
-  module EnumeratedStateHelpers
-
-  end
-
   module EnumeratedStateClassMethods
     def get_module_for_enumerated_state(attribute, value)
       value = value.to_sym unless value.nil?

data/spec/enumerated_state_spec.rb

@@ -411,6 +411,32 @@ describe 'Enumerated State' do
     end
   end
 
+  describe "implementation with double states does not cause error" do
+    it "should not raise error" do
+      lambda {
+        class Impl30
+          enum_attr :enum1, %w(e1 e2)
+          acts_as_enumerated_state :enum1
+
+          enum_attr :enum2, %w(e3 e4)
+          acts_as_enumerated_state :enum2
+
+          module E1; def hi; 'hi e1'; end; end
+          module E2; def hi; 'hi e2'; end; end
+          module E3; def hello; 'hello e3'; end; end
+          module E4; def hello; 'hello e4'; end; end
+        end
+
+        obj = Impl30.new
+        obj.enum1 = :e1
+        obj.hi.should == 'hi e1'
+        obj.enum2 = :e3
+        obj.hello.should == 'hello e3'
+      }.should_not raise_exception
+    end
+
+  end
+
   describe "implementation error checking" do
 
     it "should raise exception when redeclaring enumerated states in subclass" do

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: enumerated_state
 version: !ruby/object:Gem::Version 
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - Jeff Patmon
@@ -14,16 +15,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-28 00:00:00 -07:00
+date: 2010-05-29 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: enumerated_attribute
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         - 2
@@ -35,9 +38,11 @@ dependencies:
   name: mixology
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 23
         segments: 
         - 0
         - 2
@@ -49,9 +54,11 @@ dependencies:
   name: meta_programming
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 21
         segments: 
         - 0
         - 2
@@ -87,25 +94,29 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 57
       segments: 
       - 1
       - 8
       - 7
       version: 1.8.7
 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.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: ASPIUM (Another State Pattern Implementation Using Mixology)