jeffp-enumerated_attribute 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+pkg
+rdoc
+coverage
+test/*.log

data/CHANGELOG.rdoc

@@ -0,0 +1,11 @@
+== master
+
+== 0.1.0 / 2009-07-09
+
+* Added dynamic predicate method generation
+* Added options handling
+* Added incrementor and decrementor
+* Added enumeration accessor
+* Added accessor and enumeration value definition
+* Added simple attribute initialization
+* Added DSL for short-hand method definition

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2009 Jeff Patmon
+
+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.rdoc

@@ -0,0 +1,266 @@
+= enumerated_attribute
+
++enumerated_attribute+ simplifies the definition of enumeration-based attributes, their accessors, initializers and common predicate and support methods.
+
+== Resources
+
+Development
+
+* http://github.com/jeffp/enumerated_attribute
+
+Source
+
+* git://github.com/jeffp/enumerated_attribute.git
+
+== Description
+
+Enumerations are a common and useful pattern in programming.  Typically, in Ruby, 
+enumerated attributes are implemented with strings, symbols or constants.  Often the 
+developer is burdened with repeatedly defining common methods in support of each
+attribute.  Such repetition coding unnecessarily increases
+costs and wastes time.
+
++enumerated_attribute+ simplifies the definition of enumerated attributes by emphasizing 
+convention and DRYing the implementation.  Repetitive code such as initializers, accessors, 
+predicate and support methods are automatically generated, resulting in better 
+encapsulation and quicker, more readable code.
+
+Features include:
+* Short and simple definition
+* Dynamically-generated support methods
+* Run-time generated attribute predicates
+* Attribute initialization
+* Method definition short-hand (DSL)
+
+Examples of the usage patterns for some of the above features are shown below.
+
+== Usage
+
+=== Defining the Attribute
+
+Defining an enumerated attribute is as simple as this:
+
+  require 'enumerated_attribute'
+  
+  class Tractor
+    enumerated_attribute :gear, %w(reverse neutral first second over_drive)
+    
+    def initialize
+      @gear = :neutral
+    end
+  end
+
+Notice the plugin +enumerated_attribute+ is required at the top of the code.  
+The +require+ line must be added at least once at some point in the code.  
+It is not included in subsequent examples.
+
+The above code uses +enumerated_attribute+ to define an attribute named 'gear' with five enumeration values.  
+In general, +enumerated_attribute+ takes three parameters: the name of the attribute, an array of 
+enumeration values (either symbols or strings), and an optional hash of options (not shown above).  The complete 
+form of +enumerated_attribute+ looks like this:
+
+  enumerated_attribute :name, array_of_enumerations, hash_of_options
+  
+Defining the attribute :gear has done a number things.  
+It has generated an instance variable '@gear', read/write accessors for the 
+attribute and three support methods
+for the enumeration, including an incrementor and decrementor.  These methods are 
+demonstrated below using the Tractor class defined above:
+
+  Tractor.instance_methods(false)
+  # =>["gear", "gear=", "gears", "gear_next", "gear_previous", ...
+
+  t = Tractor.new
+  t.gear                            # => :neutral
+  t.gear= :reverse                  # => :reverse
+  t.gear                            # => :reverse
+  t.gear= :third
+  # => ArgumentError: 'third' is not an enumerated value for gear attribute
+  
+  t.gears                           # => [:reverse, :neutral, :first, :second, :over_drive]
+  t.gear_next                       # => :neutral
+  t.gear_previous                   # => :reverse
+  t.gear_previous                   # => :over_drive
+  
+The plugin has defined +gear+ and +gear=+ accessors for the attribute.  They can be used 
+to set the attribute to one of the defined enumeration values.  Attempting to set the 
+attribute to something besides a defined enumeration value raises an ArgumentError.
+
++gear_next+ and +gear_previous+ are incrementors and decrementors of the attribute.  
+The increment order is based on the order of the enumeration values in the attribute definition.
+Both the incrementor and decrementor will wrap when reaching the boundary elements 
+of the enumeration array.  For example:
+
+  t.gear = :second
+  t.gear_next                       # => :over_drive
+  t.gear_next                       # => :reverse
+
+
+==== Using Attribute Predicates
+
+Attribute predicates are methods used to query the state of the attribute, 
+for instance, +gear_is_neutral?+ is a predicate method for the gear attribute.  
+The plugin will evaluate and respond to predicate methods
+for any attribute defined with it.  Predicate methods are not pre-generated.  By
+adhering to a specific format, the plugin can recognize attribute predicates
+and generate the methods dynamically.  +enumerated_attribute+ recognizes 
+methods of the following format:
+
+  {attribute name}_{anything}_{enumeration value}?
+
+The predicate method must satisfy three requirements:  it must begin with the name 
+of the attribute,
+it must end with a question mark, and the question mark must be preceded with
+a valid enumeration value (all connected by underscores without colons).  
+So we can write the following two predicate methods without any prior definition and 
+the plugin will recognize, define and respond to them as demonstrated here:
+
+  t.gear= :neutral
+  t.gear_is_in_neutral?             # => true
+  t.gear_is_in_reverse?             # => false
+
+The '_is_in_' part of the methods above is merely semantic but enhances 
+readability.  The contents of the {anything} portion is completely
+at the discretion of the developer.  However, there is one twist.  
+The evaluation of a predicate method can be negated 
+by including 'not' in the the middle {anything} section, such as here:
+
+  t.gear_is_not_in_neutral?         # => false
+  t.gear_is_not_in_reverse?         # => true
+  
+Basically, the shortest acceptable form of a predicate method is:
+
+  t.gear_neutral?                   # => true
+  t.gear_not_neutral?               # => false
+
+
+==== Initializing Attributes
+
+The plugin provides a few ways to eliminate setting the initial value of the attribute in
+the +initialize+ method.  Two ways are demonstrated here:
+
+  class Tractor
+    enum_attr :gear, %w(reverse ^neutral first second third)
+    enum_attr :front_light, %w(off low high), :init=>:off
+  end
+  
+  t=Tractor.new
+  t.gear                            # => :neutral
+  t.front_light                     # => :off
+
+*Note* +enumerated_attribute+ can be abbreviated to +enum_attr+.  The abbreviated
+form will be used in subsequent examples.
+
+The first and simplest way involves designating the initial value by 
+prepending a carot '^' to one of the enumeration values in the definition.  
+The plugin recognizes that the gear attribute is to be initialized to :neutral.  
+Alternatively, the :init option can be used to indicate the initial value of the attribute.
+
+
+==== Changing Method Names
+
+The plugin provides options for changing the method names of the enumeration accessor, incrementor
+and decrementor (ie, +gears+, +gear_next+, +gear_previous+):
+
+  class Tractor
+    enum_attr :lights, %w(^off low high), :plural=>:lights_values, 
+        :inc=>'lights_inc', :dec=>'lights_dec'
+  end
+  
+  t=Tractor.new
+  t.lights_values                   # => [:off, :low, :high]
+  t.lights_inc                      # => :low
+  t.lights_dec                      # => :off
+  
+By default, the plugin uses the plural of the attribute for the accessor method name of the enumeration 
+values.  The pluralization is done simply by adding an 's'.  In the case of 'lights' as an 
+attribute, the default pluralization does not work, so the accessor can be changed using 
+the :plural option.  Likewise, the decrementor
+and incrementor have options :decrementor and :incrementor, or :inc and :dec, for changing
+their method names.
+
+
+=== Defining Other Methods
+
+In the case that other methods are required to support the attribute, 
+the plugin provides a short-hand for defining these methods in the 
++enumerated_attribute+ block.
+
+  class Tractor
+    enum_attr :gear, %(reverse ^neutral first second over_drive) do
+      parked? :neutral
+      driving? [:first, :second, :third]
+    end
+  end
+
+  t=Tractor.new
+  t.parked?                         # => true
+  t.driving?                        # => false
+  
+Two predicate methods are defined for the 'gear' attribute in the above example using 
+the plugin's short-hand.    
+The first method, parked?, defines a method which evaluates 
+the code {@gear == :neutral}.  The second method, driving?, evaluates
+to true if the attribute is set to one of the enumeration values defined in the array 
+[:first, :second, :third].
+  
+For predicate methods requiring fancier logic,
+a block can be used to define the method body.
+
+  class Tractor
+    enum_attr :gear, %(reverse ^neutral first second over_drive) do
+      parked? :neutral
+      driving? [:first, :second, :third]
+    end
+    enum_attr :plow, %(^up down), :plural=>:plow_values do
+      plowing? { self.gear_is_in_first? && @plow == :down }
+    end
+  end
+
+Here, a method plowing? is true if the gear attribute equates to :first 
+and the plow attribute is set to :down.  There is
+no short-hand for the block.  The code must be complete and evaluate in 
+the context of the instance.
+
+Method definitions are not limited to predicate methods.  Other methods 
+can be defined to manipulate the attributes.  Here, two methods are defined acting
+as bounded incrementor and decrementor of the gear attribute.
+
+  class Tractor
+    enum_attr :gear, %(reverse ^neutral first second over_drive) do
+      parked? :neutral
+      driving? [:first, :second, :third]
+      upshift { self.gear_is_in_over_drive? ? self.gear : self.gear_next }
+      downshift { self.driving? ? self.gear_previous : self.gear }      
+    end
+  end
+  
+  t = Tractor.new
+  t.gear                          # => :neutral
+  10.times { t.upshift }
+  t.gear                          # => :over_drive
+  10.times { t.downshift }
+  t.gear                          # => :neutral
+  
+Methods +upshift+ and +downshift+ use the automatically generated 
+incrementor and decrementor as
+well as a couple predicate methods.  +upshift+ increments the gear attribute until
+it reaches over_drive and does not allow a wrap around.  +downshift+ decrements
+until the attribute reaches neutral.
+
+
+== Testing
+
+The plugin uses RSpec for testing.  Make sure you have the RSpec gem installed:
+
+  gem install rspec
+  
+To test the plugin, run:
+
+  rake spec:test
+
+
+== Dependencies
+
+By default, there are no dependencies.
+

data/Rakefile

@@ -0,0 +1,87 @@
+#require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+ 
+spec = Gem::Specification.new do |s|
+  s.name = 'enumerated_attribute'
+  s.version = '0.1.0'
+  s.platform = Gem::Platform::RUBY
+  s.description = 'A enumerated attribute accessor'
+  s.summary = 'Defines enumerated attributes, initial state and dynamic state methods.'
+  
+  s.files = FileList['{examples,lib,tasks,spec}/**/*'] + %w(CHANGELOG.rdoc init.rb LICENSE Rakefile README.rdoc .gitignore) - FileList['test/*.log']
+  s.require_path = 'lib'
+  s.has_rdoc = true
+  s.test_files = Dir['spec/**/*_spec.rb']
+  
+  s.author = 'Jeff Patmon'
+  s.email = 'jpatmon@yahoo.com'
+  s.homepage = 'http://www.jpatmon.com'
+end
+ 
+desc 'Default: run all tests.'
+task :default => :test
+
+require 'spec/version'
+require 'spec/rake/spectask'
+
+namespace :spec do
+  desc "Run all specs"
+  Spec::Rake::SpecTask.new('test') do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    #t.spec_opts = ['--options', 'spec/spec.opts']
+    t.rcov = false
+    #t.rcov_dir = 'coverage'
+    #t.rcov_opts = ['--exclude', "kernel,load-diff-lcs\.rb,instance_exec\.rb,lib/spec.rb,lib/spec/runner.rb,^spec/*,bin/spec,examples,/gems,/Library/Ruby,\.autotest,#{ENV['GEM_HOME']}"]
+  end
+end
+
+
+=begin
+desc "Test the #{spec.name} plugin."
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'spec'
+  t.test_files = spec.test_files
+  t.verbose = true
+end
+ 
+begin
+  require 'rcov/rcovtask'
+  namespace :test do
+    desc "Test the #{spec.name} plugin with Rcov."
+    Rcov::RcovTask.new(:rcov) do |t|
+      t.libs << 'lib'
+      t.test_files = spec.test_files
+      t.rcov_opts << '--exclude="^(?!lib/)"'
+      t.verbose = true
+    end
+  end
+rescue LoadError
+end
+=end
+
+desc "Generate documentation for the #{spec.name} plugin."
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = spec.name
+  #rdoc.template = '../rdoc_template.rb'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc', 'CHANGELOG.rdoc', 'LICENSE', 'lib/**/*.rb')
+end
+ 
+desc 'Generate a gemspec file.'
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end
+ 
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Dir['tasks/**/*.rake'].each {|rake| load rake}

data/init.rb

@@ -0,0 +1 @@
+require 'enumerated_attribute'

data/lib/enumerated_attribute.rb

@@ -0,0 +1,274 @@
+module EnumeratedAttribute
+
+#todo: system wide constants
+#todo: allow nil
+#todo: setter_callback
+#todo: ArgumentError may need to use Errors for ActiveRecord
+
+  def enumerated_attribute(*args, &block)
+    return if args.empty?
+    attr_name = args[0].to_s
+    attr_sym = attr_name.to_sym
+    enums = (args[1] && args[1].instance_of?(Array) ? args[1] : [])
+    index = enums.empty? ? 1 : 2
+    opts = (args[index] && args[index].instance_of?(Hash) ? args[index] : {})
+    
+    raise(ArgumentError, 'second argument of enumerated_attribute/enum_attr is not an array of symbols or strings representing the enum values', caller) if enums.empty?
+
+    #todo: better pluralization of attribute
+    initial_value = nil
+    plural_name = opts[:plural] || opts[:enums_accessor] || opts[:enums] || "#{attr_name}s"
+    incrementor = opts[:incrementor] || opts[:inc] || "#{attr_name}_next"
+    decrementor = opts[:decrementor] || opts[:dec] || "#{attr_name}_previous"
+    
+    class_eval <<-ATTRIB
+      @@enumerated_attribute_names ||= []
+      @@enumerated_attribute_names << '#{attr_name}'
+    ATTRIB
+    
+    unless enums.empty?
+      enums = enums.map{|v| (v =~ /^\^/ ? (initial_value = v[1, v.length-1].to_sym) : v.to_sym )}
+      class_eval <<-ENUMS
+        @@enumerated_attribute_values ||= {}
+        @@enumerated_attribute_values[:#{attr_name}] = [:#{enums.join(',:')}]
+      ENUMS
+    end
+
+    #create accessors
+    attr_reader attr_sym
+    if enums.empty?
+      attr_writer attr_sym
+    else
+      enumerated_attr_writer attr_sym
+    end
+
+    #define dynamic methods in method_missing
+    class_eval <<-METHOD
+      unless @missing_method_for_enumerated_attribute_defined
+        if method_defined?(:method_missing)
+          alias_method(:method_missing_without_enumerated_attribute, :method_missing)
+          def method_missing(methId, *args, &block)
+            return self.send(methId) if define_enumerated_attribute_dynamic_method(methId)
+            method_missing_without_enumerated_attribute(methId, *args, &block)
+          end
+        else
+          def method_missing(methId, *args, &block)
+            return self.send(methId) if define_enumerated_attribute_dynamic_method(methId)
+            super 
+          end
+        end
+        @missing_method_for_enumerated_attribute_defined = true
+      
+        alias_method :respond_to_without_enumerated_attribute?, :respond_to?
+        def respond_to?(method)
+          respond_to_without_enumerated_attribute?(method) || !!parse_dynamic_method_parts(method.to_s)
+        end
+        
+        private
+        
+        def parse_dynamic_method_parts(meth_name)
+          return(nil) unless meth_name[-1, 1] == '?'
+          
+          meth_name.chop! #remove the ?
+          
+          attr = nil
+          @@enumerated_attribute_names.each do |name|
+            if meth_name.sub!(Regexp.new("^"+name.to_s), "")
+              attr = name; break
+            end
+          end
+          return (nil) unless attr
+          attr_sym = attr.to_sym
+          
+          value = nil
+          if @@enumerated_attribute_values.key?(attr_sym)
+            @@enumerated_attribute_values[attr_sym].each do |v|
+              if meth_name.sub!(Regexp.new(v.to_s+"$"), "")
+                value = v; break
+              end
+            end
+          end
+          return (nil) unless value
+          
+          [attr, value, meth_name]
+        end
+      
+        def define_enumerated_attribute_dynamic_method(methId)
+          meth_name = methId.id2name
+          return(false) unless (parts = parse_dynamic_method_parts(meth_name))
+          return(false) unless parts
+          
+          negated = !!parts[2].downcase.match(/_not_/)
+          self.class.define_attribute_state_method(methId, parts[0], parts[1].to_sym, negated)
+          
+          true
+        end
+      end
+    METHOD
+
+    #create state and action methods from block
+    initial_value = opts[:init] || initial_value
+    if block_given?
+      m = EnumeratedAttribute::MethodDefinitionDSL.new(self, attr_name, enums)
+      m.instance_eval(&block)
+      initial_value = m.initial_value || initial_value
+      plural_name = m.pluralized_name || plural_name
+      decrementor = m.decrementor_name || decrementor
+      incrementor = m.incrementor_name || incrementor
+    end
+
+    #define the enum values accessor
+    unless enums.empty?
+      class_eval <<-ENUM
+        def #{plural_name}
+          @@enumerated_attribute_values[:#{attr_name}]
+        end
+        def #{incrementor}
+          z = @@enumerated_attribute_values[:#{attr_name}]
+          index = z.index(@#{attr_name})
+          @#{attr_name} = z[index >= z.size-1 ? 0 : index+1]
+        end
+        def #{decrementor}
+          z = @@enumerated_attribute_values[:#{attr_name}]
+          index = z.index(@#{attr_name})
+          @#{attr_name} = z[index > 0 ? index-1 : z.size-1]
+        end
+      ENUM
+    end
+    
+    #establish initial value
+    if (initial_value = opts[:init] || initial_value)
+      class_eval <<-INITVAL
+        unless @enumerated_attribute_init
+          @enumerated_attribute_init = {}
+          class << self
+            def new_with_enumerated_attribute(*args)
+              result = new_without_enumerated_attribute(*args)
+              @enumerated_attribute_init.each do |k,v|
+                result.instance_variable_set("@"+k.to_s, v)
+              end
+              result
+            end
+            alias_method :new_without_enumerated_attribute, :new
+            alias_method :new, :new_with_enumerated_attribute
+          end
+        end
+        @enumerated_attribute_init[:#{attr_name}] = :#{initial_value}
+      INITVAL
+    end
+    
+  end
+
+  #a short cut
+  alias :enum_attr :enumerated_attribute
+  
+  def define_attribute_state_method(symbol, attr_name, value, negated)
+    define_method symbol do
+      ival = instance_variable_get('@'+attr_name)
+      negated ? ival != value : ival == value
+    end
+  end
+
+  private
+  
+  def enumerated_attr_writer name
+    name = name.to_s
+    class_eval <<-METHOD
+      def #{name}=(val)
+        val = val.to_sym if val.instance_of?(String)
+        raise(ArgumentError, "'" + val.to_s + "' is not an enumerated value for #{name} attribute", caller) unless @@enumerated_attribute_values[:#{name}].include?(val) 
+        @#{name} = val
+      end
+    METHOD
+  end
+  
+  public
+  
+  class MethodDefinitionDSL
+    attr_reader :initial_value, :pluralized_name, :decrementor_name, :incrementor_name
+    
+    def initialize(class_obj, attr_name, values=[])
+      @class_obj = class_obj
+      @attr_name = attr_name
+      @attr_values = values
+    end
+
+    def method_missing(methId, *args, &block)
+      meth_name = methId.id2name
+      if meth_name[-1,1] != '?'
+        #not a state method - this must include either a proc or block - no short cuts
+        if args.size > 0
+          arg = args[0]
+          if arg.instance_of?(Proc)
+            @class_obj.send(:define_method, methId, arg)
+            return 
+          end
+        elsif block_given?
+          @class_obj.send(:define_method, methId, block)
+          return
+        end
+        raise ArgumentError, "method '#{meth_name}' must be followed by a proc or block", caller
+      end
+
+      if (args.size > 0)
+        arg = args[0]
+        case arg
+        when Symbol 
+          return create_method_from_symbol_or_string(meth_name, arg)
+        when String
+          return create_method_from_symbol_or_string(meth_name, arg)
+        when Array
+          return create_method_from_array(meth_name, arg)
+        when Proc
+          @class_obj.send(:define_method, methId, arg)
+          return
+        end
+      elsif block_given?
+        @class_obj.send(:define_method, methId, block)
+        return
+      end
+      raise ArgumentError , "method '#{meth_name}' for :#{@attr_name} attribute must be followed by a symbol, array, proc or block", caller   
+    end
+     
+    def init(value)
+      if (!@attr_values.empty? && !@attr_values.include?(value.to_sym))
+        raise(NameError, "'#{value}' in method 'init' is not an enumeration value for :#{@attr_name} attribute", caller) 
+      end
+      @initial_value = value
+    end
+
+    def decrementor(value); @decrementor_name = value; end
+    def incrementor(value); @incrementor_name = value; end    
+    def enums_accessor(value); @pluralized_name = value; end
+    alias :inc :incrementor
+    alias :dec :decrementor
+    alias :enums :enums_accessor
+    alias :plural :enums_accessor
+    
+    private
+    
+    def create_method_from_symbol_or_string(meth_name, arg)
+      if (!@attr_values.empty? && !@attr_values.include?(arg.to_sym))  
+        raise(NameError, "'#{arg}' in method '#{meth_name}' is not an enumeration value for :#{@attr_name} attribute", caller) 
+      end
+      @class_obj.class_eval("def #{meth_name}; @#{@attr_name} == :#{arg}; end") 
+    end
+
+    def create_method_from_array(meth_name, arg)
+      if !@attr_values.empty?
+        arg.each do |m|
+          if !@attr_values.include?(m.to_sym)
+            raise(NameError, "'#{m}' in method '#{meth_name}' is not an enumeration value for :#{@attr_name} attribute", caller) 
+          end
+        end
+      end
+      @class_obj.class_eval("def #{meth_name}; [:#{arg.join(',:')}].include?(@#{@attr_name}); end")
+    end
+  end  
+end
+
+class Class
+  include EnumeratedAttribute
+end
+
+

data/spec/car.rb

@@ -0,0 +1,37 @@
+require 'enumerated_attribute'
+
+#used to test that method_missing chaining plays nice in inheritance situations
+
+class Vehicle
+  
+  attr_accessor :vehicle_method_hit
+  
+  def initialize
+    @vehicle_method_hit = false
+  end
+  
+  def method_missing(methId, *args)
+    @vehicle_method_hit = true
+    #end here
+  end
+  
+  alias :vmh :vehicle_method_hit
+
+end
+
+class Car < Vehicle  
+  attr_accessor :car_method_hit
+  
+  def initialize
+    super
+    @car_method_hit = false
+  end
+  
+  def method_missing(methId, *args)
+    @car_method_hit = true
+    super
+  end
+  
+  enum_attr :gear, %w(reverse ^neutral drive)  
+  alias :cmt :car_method_hit
+end

data/spec/car_spec.rb

@@ -0,0 +1,21 @@
+require 'spec/car'
+
+#used to test that method_missing chaining plays nice in inheritance situation
+
+describe "Car" do
+  
+  it "should not hit Car method_missing when calling dynamic state method :gear_is_in_reverse?" do
+    c = Car.new
+    c.gear_is_in_reverse?
+    c.car_method_hit.should be_false
+    c.vehicle_method_hit.should be_false
+  end
+  
+  it "should hit Car and Vehicle method_missing when not calling supported dynamic state method" do
+    c = Car.new
+    c.parking_break_is_on?
+    c.car_method_hit.should be_true
+    c.vehicle_method_hit.should be_true
+  end
+    
+end

data/spec/tractor.rb

@@ -0,0 +1,38 @@
+require 'enumerated_attribute'
+
+class Tractor
+  
+  GEAR_ENUM_VALUES = %w(reverse neutral first second over_drive).map{|v| v.to_sym}
+  LIGHTS_ENUM_VALUES = %w(off low high).map{|v| v.to_sym}
+  SIDE_LIGHT_ENUM_VALUES = [:off,:low,:high,:super_high]
+  
+  attr_accessor :name
+  
+  def initialize
+    @name = 'old faithful'
+  end
+  
+  enumerated_attribute :gear, %w(reverse ^neutral first second over_drive) do
+    parked? :neutral
+    driving? [:first, :second, :over_drive]
+    upshift { self.gear_is_in_over_drive? ? self.gear : self.gear_next }
+    downshift { self.driving? ? self.gear_previous : self.gear }
+  end
+  
+  enum_attr :plow, %w(^up down) do
+    plowing? { self.gear_is_in_first? && self.plow == :down }
+  end
+  
+  enum_attr :lights, LIGHTS_ENUM_VALUES, :enums_accessor=>:lights_enums, :init=>:off, :decrementor=>:turn_lights_down, :incrementor=>:turn_lights_up do
+    lights_are_on? [:low, :high]
+    lights_are_not_on? :off
+  end
+  
+  enum_attr :side_light, %w(off low high super_high) do
+    init :off
+    enums_accessor :side_light_enums
+    incrementor :side_light_up
+    decrementor :side_light_down    
+  end
+    
+end

data/spec/tractor_spec.rb

@@ -0,0 +1,239 @@
+require 'spec/tractor'
+
+describe "Tractor" do
+
+  it "should have respond_to? method for :gear_is_in_neutral?" do
+    t=Tractor.new
+    t.respond_to?('gear_is_in_neutral?').should be_true
+  end
+  
+  it "should have respond_to? method for :side_light_is_super_high?" do
+    t=Tractor.new
+    t.respond_to?(:side_light_is_super_high?).should be_true
+  end
+  
+  it "should not have respond_to? method for :gear_is_in_high?" do
+    t=Tractor.new
+    t.respond_to?(:gear_is_in_high?).should be_false
+  end
+  
+  it "should initially set :plow to :up" do
+    t=Tractor.new
+    t.plow.should == :up
+  end
+  
+  it "should have plowing? state method" do
+    t=Tractor.new
+    t.plowing?.should be_false
+    t.plow=:down
+    t.plowing?.should be_false
+    t.gear= :first
+    t.plowing?.should be_true
+    t.plow=:up
+    t.plowing?.should be_false
+  end
+  
+  it "should have :side_light_up incrementor" do
+    t=Tractor.new
+    t.side_light = :off
+    t.side_light_up.should == :low
+    t.side_light_up.should == :high
+    t.side_light_up.should == :super_high
+    t.side_light_up.should == :off
+  end
+  
+  it "should have :side_light_down incrementor" do
+    t=Tractor.new
+    t.side_light_down.should == :super_high
+    t.side_light_down.should == :high
+    t.side_light_down.should == :low
+    t.side_light_down.should == :off    
+  end
+  
+  it "should have :turn_lights_up incrementor" do
+    t=Tractor.new
+    t.lights = :off
+    t.turn_lights_up.should == :low
+    t.turn_lights_up.should == :high
+  end
+  
+  it "should have :turn_lights_down decrementor" do
+    t=Tractor.new
+    t.lights=:high
+    t.turn_lights_down.should == :low
+    t.turn_lights_down.should == :off
+  end
+  
+  it "should have :gear_previous which wraps from :neutral to :over_drive" do
+    t=Tractor.new
+    t.gear_previous.should == :reverse
+    t.gear.should == :reverse
+    t.gear_previous.should == :over_drive
+    t.gear.should == :over_drive
+  end
+  
+  it "should have :gear_next which wraps from :second to :reverse" do
+    t=Tractor.new
+    t.gear = :second
+    t.gear_next.should == :over_drive
+    t.gear.should == :over_drive
+    t.gear_next.should == :reverse
+    t.gear.should == :reverse
+  end
+  
+  it "should have :upshift which increments :gear from :neutral to :over_drive without wrapping" do
+    t=Tractor.new
+    t.upshift.should == :first
+    t.upshift.should == :second
+    t.upshift.should == :over_drive
+    t.upshift.should == :over_drive
+  end
+  
+  it "should have :downshift which decrements :gear from :over_drive to :neutral without wrapping" do
+    t=Tractor.new
+    t.gear = :over_drive
+    t.downshift.should == :second
+    t.downshift.should == :first
+    t.downshift.should == :neutral
+    t.downshift.should == :neutral
+  end
+
+  it "should have parked? method" do
+    t=Tractor.new
+    t.parked?.should be_true
+    t.gear = :reverse
+    t.parked?.should be_false
+  end
+  
+  it "should have driving? method"  do
+    t=Tractor.new
+    t.driving?.should be_false
+    [:first, :second, :over_drive].each do |g|
+      t.gear=g
+      t.driving?.should be_true
+    end
+  end
+  
+  it "should initially set side_light to :off" do
+    t=Tractor.new
+    t.side_light.should == :off
+  end
+  
+  it "should have side_light_enums method" do
+    t = Tractor.new
+    t.side_light_enums.should == Tractor::SIDE_LIGHT_ENUM_VALUES
+  end
+  
+  it "should have state method side_light_is_off?" do
+    t=Tractor.new
+    t.side_light_is_off?.should be_true
+  end
+  
+  it "should have state method side_light_is_super_high?" do
+    t=Tractor.new
+    t.side_light_is_super_high?.should be_false
+  end
+  
+  it "should initially set :gear to :neutral" do
+    t=Tractor.new
+    t.gear.should == :neutral
+  end
+    
+  it "should set lights initially to :off" do
+    t=Tractor.new
+    t.lights.should == :off
+  end
+  
+  it "should create a lights_enums method for all light enumerated values" do 
+    t=Tractor.new
+    t.lights_enums.should == Tractor::LIGHTS_ENUM_VALUES
+  end
+  
+  it "should initially set lights to :off" do
+    t=Tractor.new
+    t.lights.should equal(:off)
+  end
+
+  it "should have dynamic state methods for :reverse and :neutral" do
+    t = Tractor.new
+    t.gear_is_in_reverse?.should be_false
+    t.gear_is_in_neutral?.should be_true
+  end
+  
+  it "should have negative dynamic state methods for :reverses and :neutral" do
+    t = Tractor.new
+    t.gear_is_not_in_reverse?.should be_true
+    t.gear_is_not_in_neutral?.should be_false
+  end
+
+  it "should have negative and positive dynamic state methods for :over_drive" do
+    t = Tractor.new
+    t.gear_is_in_over_drive?.should be_false
+    t.gear_is_not_in_over_drive?.should be_true
+  end
+  
+  it "should have created instance methods for :reverse" do
+    m = Tractor.instance_methods(false)
+    m.should include('gear_is_in_reverse?')
+    m.should include('gear_is_not_in_reverse?')
+  end
+
+  it "should have created instance methods for :neutral" do
+    m = Tractor.instance_methods(false)
+    m.should include('gear_is_in_neutral?')
+    m.should include('gear_is_not_in_neutral?')
+  end
+
+  it "should have created instance methods for :over_drive" do
+    m = Tractor.instance_methods(false)
+    m.should include('gear_is_in_over_drive?')
+    m.should include('gear_is_not_in_over_drive?')
+  end
+  
+  it "should raise NoMethodError for dynamic state methods not querying valid enumeration values" do
+    t = Tractor.new
+    lambda { t.gear_is_in_high? }.should raise_error(NoMethodError)
+  end  
+  
+  it "should convert string values to symbols for attr setters" do
+    t = Tractor.new
+    t.gear= 'reverse'
+    t.gear.should == :reverse
+  end
+    
+  it "should have class variable @@enumerated_attribute_names" do
+    Tractor.class_variable_defined?('@@enumerated_attribute_names').should be_true
+  end
+  
+  it "should have instance method gears equal to enumeration array" do
+    Tractor.new.gears.should == Tractor::GEAR_ENUM_VALUES
+  end
+    
+  it "should have gear attribute initialized to :neutral" do
+    t = Tractor.new
+    t.gear.should == :neutral
+  end
+  
+  it "should set gear attribute to :first" do
+    t = Tractor.new
+    t.gear = :first
+    t.gear.should == :first
+  end
+  
+  it "should raise error when set gear attribute to :broken" do
+    t = Tractor.new
+    lambda { t.gear= :broken }.should raise_error(ArgumentError)
+  end
+
+  it "should have name attribute initially set to 'old faithful'" do
+    t = Tractor.new
+    t.name.should == 'old faithful'
+  end
+  
+  it "should set name attribute to 'broke n busted'" do
+    t = Tractor.new
+    t.name = 'broke n busted'
+    t.name.should == 'broke n busted'
+  end
+  
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: jeffp-enumerated_attribute
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jeff Patmon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-09 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A enumerated attribute accessor
+email: jpatmon@yahoo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/enumerated_attribute.rb
+- spec/car.rb
+- spec/car_spec.rb
+- spec/tractor.rb
+- spec/tractor_spec.rb
+- CHANGELOG.rdoc
+- init.rb
+- LICENSE
+- Rakefile
+- README.rdoc
+- .gitignore
+has_rdoc: false
+homepage: http://www.jpatmon.com
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Defines enumerated attributes, initial state and dynamic state methods.
+test_files: 
+- spec/car_spec.rb
+- spec/tractor_spec.rb