jeffp-enumerated_attribute 0.1.2 → 0.1.4

data/.gitignore

@@ -2,4 +2,4 @@
 pkg
 rdoc
 coverage
-test/*.log
+*.log

data/CHANGELOG.rdoc

@@ -1,5 +1,16 @@
 == master
 
+== 0.1.4 / 2009-07-14
+
+* Removed log files from gem build
+
+== 0.1.3 / 2009-07-14
+
+* Adds Ingration module supporting Object and ActiveRecord
+* Adds extensibility to Integration module
+* Adds ActiveRecord Integration
+* Improves pluralization -- supports /(sh|ch|x|s)$/, /y$/, /[aeiou]y$/ and +'s' pluralization
+
 == 0.1.2 / 2009-07-11
 
 * Added 'is_not' for negated custom method definitions

data/README.rdoc

@@ -31,8 +31,31 @@ Features include:
 * Run-time generated attribute predicates
 * Attribute initialization
 * Method definition short-hand (DSL)
+* ActiveRecord integration
 
-Examples of the usage patterns for some of the above features are shown below.
+== Example
+
+Here's a quick example of what +enumerated_attribute+ can do:
+
+  require 'enumerated_attribute'
+  
+  class Tractor
+    enum_attr :gear, %w(reverse ^neutral first second over_drive) do
+      driving? [:first, :second, :over_drive]
+      upshift { self.gear_is_not_in_over_drive? ? self.gear_next : self.gear }
+    end
+  end
+  
+  t = Tractor.new
+  t.gear                            # => :neutral
+  t.gear_is_in_neutral?             # => true
+  t.driving?                        # => false
+  t.upshift                         # => :first
+  t.driving?                        # => true
+  t.gear = :second                  # => :second
+  t.gear_is_not_in_first?           # => true
+
+An explanation of the above features and their usage follows.
 
 == Usage
 
@@ -193,7 +216,8 @@ and decrementor (ie, +gears+, +gear_next+, +gear_previous+):
   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 
+values.  The pluralization uses a simple algorithm which does not support irregular forms.  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
@@ -281,6 +305,57 @@ well as a couple predicate methods.  +upshift+ increments the gear attribute unt
 it reaches over_drive and does not allow a wrap around.  +downshift+ decrements
 until the attribute reaches neutral.
 
+=== Integration
+
+==== ActiveRecord integration
+
+The plugin can be used with ActiveRecord.  Enumerated attributes may be declared on 
+column attributes or as independent enumerations.  Declaring an enumerated attribute
+on a column attribute will enforce the enumeration using symbols.  The 
+enumerated column attribute must be declared as a STRING in the database schema.  
+The enumerated attribute will be stored as a string but retrieved in code as a symbol.  The 
+enumeration functionality is consistent across integrations.
+
+  require 'enumerated_attribute'
+  require 'active_record'
+	
+  class Order < ActiveRecord::Base	
+    enum_attr :status, %w(^hold, processing, delayed, shipped)
+    enum_attr :billing_status, 
+      %w(^unauthorized, authorized, auth_failed, captured, capture_failed, closed)
+  end
+	
+  o = Order.new
+  o.status                          # => :hold
+  o.billing_status                  # => :unauthorized
+  o.save!
+	
+  o = Order.new(:invoice=>'43556334-W84', :status=>:processing, :billing=>:authorized)
+  o.save!
+  o.status                          # => :processing
+  o.invoice                         # => "43556334-W84"
+	
+
+=== Implementation Notes
+
+==== New and Method_missing methods
+
+The plugin chains both the 'new' and the 'method_missing' methods.  Any 'new' and 'method_missing' 
+implementations in the same class declaring an enumerated_attribute should come before the 
+declaration; otherwise, the 'new' and 'method_missing' implementations must chain in order to avoid 
+overwriting the plugin's methods.  The best approach is shown here:
+
+  class A
+    def self.new(*args)
+      ...
+    end
+    def self.method_missing(methId, *args, &blk)
+      ...
+    end
+		
+    enum_attr :state, %w(cold warm hot boiling)
+  end
+
 
 == Testing
 
@@ -288,12 +363,21 @@ The plugin uses RSpec for testing.  Make sure you have the RSpec gem installed:
 
   gem install rspec
   
-To test the plugin, run:
+To test the plugin for regular ruby objects, run:
 
-  rake spec:test
+  rake spec
+	
+Testing ActiveRecord integration requires the install of Sqlite3 and the 
+sqlite3-ruby gem.  To test ActiveRecord, run:
 
+  rake spec:active_record
+	
+To test all specs:
+
+  rake spec:all
 
-== Dependencies
 
-By default, there are no dependencies.
+== Dependencies
 
+* ActiveRecord
+* Sqlite3 and sqlite3-ruby gem (for testing)

data/Rakefile

@@ -5,47 +5,43 @@ require 'rake/contrib/sshpublisher'
  
 spec = Gem::Specification.new do |s|
   s.name = 'enumerated_attribute'
-  s.version = '0.1.2'
+  s.version = '0.1.4'
   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.files = FileList['{examples,lib,tasks,spec}/**/*'] + %w(CHANGELOG.rdoc init.rb LICENSE Rakefile README.rdoc .gitignore) - FileList['**/*.log']
   s.require_path = 'lib'
   s.has_rdoc = true
-  s.test_files = Dir['spec/**/*_spec.rb']
+  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.libs << 'lib' << 'spec'
-    #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
+desc "Run specs"
+Spec::Rake::SpecTask.new(:spec) do |t|
+	t.spec_files = FileList['spec/*_spec.rb']
+	t.libs << 'lib' << 'spec'
+	t.rcov = false
+	#t.spec_opts = ['--options', 'spec/spec.opts']
+	#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
 
-desc "Run test"
-Spec::Rake::SpecTask.new(:test) do |t|
-  t.spec_files = FileList['spec/**/*_spec.rb']
-  t.libs << 'lib' << 'spec'
-  #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']}"]
+namespace :spec do
+  desc "Run ActiveRecord integration specs"
+	Spec::Rake::SpecTask.new(:active_record) do |t|
+		t.spec_files = FileList['spec/active_record/*_spec.rb']
+		t.libs << 'lib' << 'spec/active_record'
+		t.rcov = false
+	end
+	desc "Run all specs"
+	task :all=>[:spec, :active_record] 
 end
 
 =begin

data/lib/enumerated_attribute.rb

@@ -1,27 +1,9 @@
 module EnumeratedAttribute
 
-#todo: is_not/is -- test raised errors contain useful info on invalid syntax
-#todo: dynamic_enums
-#todo: system wide constants
-#todo: setter_callback
-#todo: ArgumentError may need to use Errors for ActiveRecord
-#todo: test new chaining plays nice
-#todo: attribute methods gear.enums, gear.inc, gear.dec
-
-  def enum_attr_reader(*args, &block)
-    if args.length > 1
-      args << {} if args.length == 2
-      args[2][:writer] = false if args[2].kind_of?(Hash)
-    end
-    enumerated_attribute(*args, &block)
-  end
-  def enum_attr_writer(*args, &block)
-    if args.length > 1
-      args << {} if args.length == 2
-      args[2][:reader] = false if args[2].kind_of?(Hash)
-    end
-    enumerated_attribute(*args, &block)
-  end
+	class EnumeratedAttributeError < StandardError; end
+	class IntegrationError < EnumeratedAttributeError; end
+	class InvalidEnumeration < EnumeratedAttributeError; end
+	class InvalidDefinition < EnumeratedAttributeError; end
   
   def enumerated_attribute(*args, &block)
     return if args.empty?
@@ -31,40 +13,66 @@ module EnumeratedAttribute
     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?
+    raise(InvalidDefinition, '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"
+    plural_name = opts[:plural] || opts[:enums_accessor] || opts[:enums] || begin 
+			case
+			when attr_name =~ /[aeiou]y$/
+				"#{attr_name}s"
+			when attr_name =~ /y$/
+				attr_name.sub(/y$/, 'ies')
+			when attr_name =~ /(sh|ch|x|s)$/
+				"#{attr_name}es"
+			else
+				"#{attr_name}s"
+			end
+		end
     incrementor = opts[:incrementor] || opts[:inc] || "#{attr_name}_next"
     decrementor = opts[:decrementor] || opts[:dec] || "#{attr_name}_previous"
-    
+
+		enums = enums.map{|v| (v =~ /^\^/ ? (initial_value = v[1, v.length-1].to_sym) : v.to_sym )}
+
     class_eval <<-ATTRIB
       @@enumerated_attribute_names ||= []
       @@enumerated_attribute_names << '#{attr_name}'
+			@@enumerated_attribute_options ||={}
+			@@enumerated_attribute_options[:#{attr_name}] = {#{opts.to_a.map{|v| ':'+v.first.to_s+'=>:'+v.last.to_s}.join(', ')}}
+			@@enumerated_attribute_values ||= {}
+			@@enumerated_attribute_values[:#{attr_name}] = [:#{enums.join(',:')}]
     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
-
+		
+		#define_enumerated_attribute_[writer, reader] may be modified in a named Integrations module (see Integrations::ActiveRecord)
+		class_eval <<-MAP
+			unless @integration_map
+				@integration_map = Integrations.find_integration_map(self)
+				@integration_map[:aliasing].each do |p|
+					alias_method(p.first, p.last)
+				end
+				include(@integration_map[:module]) if @integration_map[:module]
+				
+				def self.has_enumerated_attribute?(name)
+					@@enumerated_attribute_names.include?(name.to_s)
+				end
+				def self.enumerated_attribute_allows_nil?(name)
+					return (false) unless @@enumerated_attribute_options[name.to_sym]
+					@@enumerated_attribute_options[name.to_sym][:nil] || false
+				end
+				def self.enumerated_attribute_allows_value?(name, value)
+					return (false) unless @@enumerated_attribute_values[name.to_sym]
+					return enumerated_attribute_allows_nil?(name) if value == nil
+					@@enumerated_attribute_values[name.to_sym].include?(value.to_sym)
+				end
+			end
+		MAP
+		
     #create accessors
-    attr_reader attr_sym unless (opts.key?(:reader) && !opts[:reader])
-    unless (opts.key?(:writer) && !opts[:writer])
-      if enums.empty?
-        attr_writer attr_sym 
-      else
-        enumerated_attr_writer(attr_sym, opts[:nil] || false)
-      end
-    end
+		define_enumerated_attribute_reader_method(attr_sym) unless (opts.key?(:reader) && !opts[:reader])
+		define_enumerated_attribute_writer_method(attr_sym) unless (opts.key?(:writer) && !opts[:writer])
     
     #define dynamic methods in method_missing
     class_eval <<-METHOD
-      unless @missing_method_for_enumerated_attribute_defined
+      unless @enumerated_attribute_define_once_only
         if method_defined?(:method_missing)
           alias_method(:method_missing_without_enumerated_attribute, :method_missing)
           def method_missing(methId, *args, &block)
@@ -77,13 +85,19 @@ module EnumeratedAttribute
             super 
           end
         end
-        @missing_method_for_enumerated_attribute_defined = true
+        @enumerated_attribute_define_once_only = 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
-        
+        end				
+				
+				def initialize_enumerated_attributes(only_if_nil = false)
+					self.class.enumerated_attribute_initial_value_list.each do |k,v|
+						self.write_enumerated_attribute(k, v) unless (only_if_nil && read_enumerated_attribute(k) != nil)
+					end
+				end
+
         private
         
         def parse_dynamic_method_parts(meth_name)
@@ -126,6 +140,7 @@ module EnumeratedAttribute
           
           true
         end
+								
       end
     METHOD
 
@@ -141,74 +156,226 @@ module EnumeratedAttribute
     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
-
+		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})
+				write_enumerated_attribute(:#{attr_name}, z[index >= z.size-1 ? 0 : index+1])
+			end
+			def #{decrementor}
+				z = @@enumerated_attribute_values[:#{attr_name}]
+				index = z.index(@#{attr_name})
+				write_enumerated_attribute(:#{attr_name}, z[index > 0 ? index-1 : z.size-1])
+			end
+		ENUM
+		
+		unless @enumerated_attribute_init
+			define_enumerated_attribute_new_method
+		end
+		@enumerated_attribute_init ||= {}		
+		if (initial_value = opts[:init] || initial_value)
+			@enumerated_attribute_init[attr_sym] = initial_value 
+		end
+		class_eval do
+			class << self
+				def enumerated_attribute_initial_value_list; @enumerated_attribute_init; end
+			end
+		end		
+	end
+	
   #a short cut
   alias :enum_attr :enumerated_attribute
   
   def define_enumerated_attribute_custom_method(symbol, attr_name, value, negated)
     define_method symbol do
-      ival = instance_variable_get('@'+attr_name)
+      ival = read_enumerated_attribute(attr_name)
       negated ? ival != value : ival == value
     end
   end
 
   private
-  
-  def enumerated_attr_writer name, allow_nil=false
+	  
+	#these implementations are for basic ruby objects - integrations (see Integrations::ActiveRecord) may alter them
+	def define_enumerated_attribute_new_method
+		class_eval <<-NEWMETH
+			class << self
+				alias_method :new_without_enumerated_attribute, :new
+				def new(*args, &block)
+					result = new_without_enumerated_attribute(*args)
+					result.initialize_enumerated_attributes
+					yield result if block_given?
+					result
+				end
+			end
+		NEWMETH
+	end
+	
+  def define_enumerated_attribute_writer_method name
     name = name.to_s
     class_eval <<-METHOD
-      def #{name}=(val)        
-        val = val.to_sym if val.instance_of?(String)
-        unless (val == nil && #{allow_nil})
-          raise(ArgumentError, 
-            (val == nil ? "nil is not allowed on #{name} attribute, set :nil=>true option" : "'" + val.to_s + "' is not an enumeration value for #{name} attribute"), 
-            caller) unless @@enumerated_attribute_values[:#{name}].include?(val) 
-        end
-        @#{name} = val
-      end
+      def #{name}=(val); write_enumerated_attribute(:#{name}, val); end    
     METHOD
   end
   
+	def define_enumerated_attribute_reader_method name
+		name = name.to_s
+		class_eval <<-METHOD
+			def #{name}; read_enumerated_attribute(:#{name}); end
+		METHOD
+	end
+	
+	module Integrations
+		module Object
+			def self.included(klass)
+				klass.extend(ClassMethods)
+			end
+
+			def write_enumerated_attribute(name, val)
+				name = name.to_s
+				val = val.to_sym if val
+				unless self.class.enumerated_attribute_allows_value?(name, val)
+					raise(InvalidEnumeration, "nil is not allowed on '#{name}' attribute, set :nil=>true option", caller) unless val
+					raise(InvalidEnumeration, ":#{val} is not a defined enumeration value for the '#{name}' attribute", caller) 
+				end
+				instance_variable_set('@'+name, val)
+			end
+			
+			def read_enumerated_attribute(name)
+				return instance_variable_get('@'+name.to_s)
+			end
+
+			module ClassMethods
+			end
+		
+		end
+		
+		module ActiveRecord
+			def self.included(klass)
+				klass.extend(ClassMethods)
+			end
+			
+			def write_enumerated_attribute(name, val)
+				name = name.to_s
+				return write_attribute(name, val) unless self.class.has_enumerated_attribute?(name)
+				val_str = val.to_s if val
+				val_sym = val.to_sym if val
+				unless self.class.enumerated_attribute_allows_value?(name, val_sym)
+					raise(InvalidEnumeration, "nil is not allowed on '#{name}' attribute, set :nil=>true option", caller) unless val
+					raise(InvalidEnumeration, ":#{val_str} is not a defined enumeration value for the '#{name}' attribute", caller)
+				end
+				return instance_variable_set('@'+name, val_sym) unless self.has_attribute?(name)
+				write_attribute(name, val_str)
+			end
+			
+			def read_enumerated_attribute(name)
+				name = name.to_s
+				#if not enumerated - let active record handle it
+				return read_attribute(name) unless self.class.has_enumerated_attribute?(name)
+				#if enumerated, is it an active record attribute, if not, the value is stored in an instance variable
+				return instance_variable_get('@'+name) unless self.has_attribute?(name)
+				#this is an enumerated active record attribute
+				val = read_attribute(name)
+				val = val.to_sym if (!!val && self.class.has_enumerated_attribute?(name))
+				val
+			end
+			
+			def attributes=(attrs, guard_protected_attributes=true)
+				return if attrs.nil?
+				#check the attributes then turn them over 
+				attrs.each do |k, v|
+					if self.class.has_enumerated_attribute?(k)
+						unless self.class.enumerated_attribute_allows_value?(k, v)
+							raise InvalidEnumeration, ":#{v.to_s} is not a defined enumeration value for the '#{k.to_s}' attribute", caller
+						end
+						attrs[k] = v.to_s
+					end
+				end
+				
+				super
+			end
+			
+			def attributes
+				super.map do |k,v|
+					self.class.has_enumerated_attribute?(k) ? v.to_sym : v
+				end
+			end
+			
+      def [](attr_name); read_enumerated_attribute(attr_name); end
+      def []=(attr_name, value); write_enumerated_attribute(attr_name, value); end
+			
+			private
+						
+			def attribute=(attr_name, value); write_enumerated_attribute(attr_name, value); end
+									
+			module ClassMethods
+				private
+				
+				def construct_attributes_from_arguments(attribute_names, arguments)
+					attributes = super
+					attributes.each { |k,v| attributes[k] = v.to_s if has_enumerated_attribute?(k) }
+					attributes
+				end			
+				
+				def instantiate(record)
+					object = super(record)
+					@enumerated_attribute_init.each do |k,v|
+						unless object.has_attribute?(k)
+							object.write_enumerated_attribute(k, v)
+						end
+					end
+					object
+				end
+				
+				def define_enumerated_attribute_new_method
+					class_eval <<-INITVAL
+						class << self
+							alias_method :new_without_enumerated_attribute, :new
+							def new(*args, &block)
+								result = new_without_enumerated_attribute(*args, &block)
+								params = (!args.empty? && args.first.instance_of?(Hash)) ? args.first : {}
+								params.each { |k, v| result.write_enumerated_attribute(k, v) }
+								result.initialize_enumerated_attributes(true)
+								yield result if block_given?
+								result
+							end
+						end
+					INITVAL
+				end
+
+			end
+		end
+	
+		module Datamapper
+		end
+	
+		@@integration_map = {}
+		
+		def self.add_integration_map(base_klass_name, module_object, aliasing_array=[])
+			@@integration_map[base_klass_name] = {:module=>module_object, :aliasing=>aliasing_array}
+		end
+		class << self
+			alias_method(:add, :add_integration_map)
+		end
+		
+		#included mappings
+		add('Object', EnumeratedAttribute::Integrations::Object)
+		add('ActiveRecord::Base', EnumeratedAttribute::Integrations::ActiveRecord)
+		
+		def self.find_integration_map(klass)
+			path = "#{klass}"
+			begin
+				return @@integration_map[klass.to_s] if @@integration_map.key?(klass.to_s)
+				klass = klass.superclass
+				path << " < #{klass}"
+			end while klass
+			raise EnumeratedAttribute::IntegrationError, "Unable to find integration for class hierarchy '#{path}'", caller
+		end
+		
+	end
+	
   public
   
   class MethodDefinition
@@ -246,13 +413,13 @@ module EnumeratedAttribute
     end
     
     def is_not(*args)
-      arg = args[0] if args.length > 0
+      arg = args.first if args.length > 0
       MethodDefinition.new(nil, arg, true)
     end
     alias :isnt :is_not
     
     def is(*args)
-      arg = args[0] if args.length > 0
+      arg = args.first if args.length > 0
       MethodDefinition.new(nil, arg)
     end
 
@@ -261,7 +428,7 @@ module EnumeratedAttribute
       
       meth_def = nil
       if args.size > 0
-        arg = args[0]
+        arg = args.first
         if arg.instance_of?(EnumeratedAttribute::MethodDefinition)
           if arg.has_method_name?
             raise_method_syntax_error(meth_name, arg.method_name)
@@ -282,7 +449,7 @@ module EnumeratedAttribute
      
     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) 
+        raise(InvalidDefinition, "'#{value}' in method 'init' is not an enumeration value for :#{@attr_name} attribute", caller) 
       end
       @initial_value = value
     end
@@ -300,7 +467,7 @@ module EnumeratedAttribute
     def raise_method_syntax_error(meth_name, offending_token=nil)
       suffix = offending_token ? "found '#{offending_token}'" : "found nothing" 
       followed_by = (meth_name[-1,1] == '?' ? "is_not, an enumeration value, an array of enumeration values, " : "") + "a proc, lambda or code block"
-      raise NameError, "'#{meth_name}' should be followed by #{followed_by} -- but #{suffix}"
+      raise InvalidDefinition, "'#{meth_name}' should be followed by #{followed_by} -- but #{suffix}"
     end
         
     def evaluate_method_definition(mdef)
@@ -333,7 +500,7 @@ module EnumeratedAttribute
     
     def create_custom_method_for_symbol_or_string(mdef)
       if (!@attr_values.empty? && !@attr_values.include?(mdef.argument.to_sym))
-        raise(NameError, "'#{mdef.argument}' in method '#{mdef.method_name}' is not an enumeration value for :#{@attr_name} attribute", caller) 
+        raise(InvalidDefinition, "'#{mdef.argument}' in method '#{mdef.method_name}' is not an enumeration value for :#{@attr_name} attribute", caller) 
       end
       @class_obj.class_eval("def #{mdef.method_name}; @#{@attr_name} #{mdef.negated ? '!=' : '=='} :#{mdef.argument}; end") 
     end
@@ -342,7 +509,7 @@ module EnumeratedAttribute
       if !@attr_values.empty?
         mdef.argument.each do |m|
           if !@attr_values.include?(m.to_sym)
-            raise(NameError, "'#{m}' in method '#{mdef.method_name}' is not an enumeration value for :#{@attr_name} attribute", caller) 
+            raise(InvalidDefinition, "'#{m}' in method '#{mdef.method_name}' is not an enumeration value for :#{@attr_name} attribute", caller) 
           end
         end
       end