jeffp-enumerated_attribute 0.1.6 → 0.1.7

data/CHANGELOG.rdoc

@@ -1,5 +1,14 @@
 == master
 
+== 0.1.7 / 2009-07-17
+
+* Added abbreviated predicate methods
+* Added and cleaned documentation
+
+== 0.1.6 / 2009-07-15
+
+* Refactored
+
 == 0.1.5 / 2009-07-14
 
 * Refactored to remove unnecessary class methods from class

data/README.rdoc

@@ -1,6 +1,6 @@
 = enumerated_attribute
 
-+enumerated_attribute+ simplifies the definition of enumeration-based attributes, their accessors, initializers and common predicate and support methods.
++enumerated_attribute+ simplifies the definition of enumeration-based attributes, their accessors, initializers and common predicate and enumeration methods.
 
 == Resources
 
@@ -22,13 +22,13 @@ 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.
+predicate and enumeration methods are automatically generated, resulting in better 
+encapsulation, quicker implementation and cleaner code.
 
 Features include:
 * Short and simple definition
-* Dynamically-generated support methods
-* Run-time generated attribute predicates
+* Auto-defined attribute methods
+* Dynamically-generated predicate methods
 * Attribute initialization
 * Method definition short-hand (DSL)
 * ActiveRecord integration
@@ -48,7 +48,7 @@ Here's a quick example of what +enumerated_attribute+ can do:
   
   t = Tractor.new
   t.gear                            # => :neutral
-  t.gear_is_in_neutral?             # => true
+  t.gear_is_neutral?                # => true
   t.driving?                        # => false
   t.upshift                         # => :first
   t.driving?                        # => true
@@ -87,8 +87,8 @@ form of +enumerated_attribute+ looks like this:
 Defining the attribute :gear has done a number things.  
 It has generated an instance variable '@gear', read/write accessors for the 
 attribute and support methods
-for the enumeration, including an incrementor and decrementor.  These methods are 
-demonstrated below using the Tractor class defined above:
+for the enumeration, such as incrementor and decrementor methods.  These methods are 
+demonstrated below using the Tractor class above:
 
   Tractor.instance_methods(false)
   # =>["gear", "gear=", "gears", "gear_next", "gear_previous", ...
@@ -119,15 +119,15 @@ of the enumeration array.  For example:
   t.gear_next                       # => :reverse
 
 
-==== Using Attribute Predicates
+==== Dynamically-Generating Predicates Methods
 
-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:
+Predicate methods are methods that query the state of the attribute, 
+for instance, gear_is_neutral? is a predicate method that returns 'true' if 
+the gear attribute is in the :neutral state.  
+By default, predicate methods are not predefined, instead, they are dynamically generated.  
+The plugin will evaluate and respond to methods adhering to a format that it 
+can associate with an attribute name and one of the attribute's enumeration values.  
++enumerated_attribute+ recognizes predicate methods of the following format:
 
   {attribute name}_{anything}_{enumeration value}?
 
@@ -157,6 +157,27 @@ Basically, the shortest acceptable form of a predicate method is:
   t.gear_not_neutral?               # => false
 
 
+==== Abbreviating Predicate Methods
+
+In the case that an enumeration value is associated with only one 
+attribute, the attribute name can be left out of the predicate method name.
+The plugin will infer the attribute from the enum value in the method name.
+The abbreviate format can be written like this:
+
+  {anything}{_}{enumeration value}?
+	
+And results in the following possibilities:
+
+  t.gear = :neutral
+  t.neutral?                        # => true
+  t.is_neutral?                     # => true
+  t.not_neutral?                    # => false
+  t.is_not_neutral?                 # => false
+	
+Calling the abbreviated form of the method containing an enumeration value
+belonging to two or more attributes throws an AmbiguousMethod error.
+
+
 ==== Initializing Attributes
 
 The plugin provides a few ways to eliminate setting the initial value of the attribute in
@@ -233,7 +254,7 @@ the plugin provides a short-hand for defining these methods in the
   class Tractor
     enum_attr :gear, %w(reverse ^neutral first second over_drive) do
       parked? :neutral
-      driving? [:first, :second, :third]
+      driving? [:first, :second, :over_drive]
     end
   end
 
@@ -246,7 +267,7 @@ 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].
+[:first, :second, :over_drive].
 
 The same short-hand can be used to define methods where the attribute 'is not' equal to the
 indicated value or 'is not' included in the array of values.
@@ -254,7 +275,7 @@ indicated value or 'is not' included in the array of values.
   class Tractor
     enum_attr :gear, %w(reverse ^neutral first second over_drive) do
       not_parked? is_not :neutral
-      not_driving? is_not [:first, :second, :third]
+      not_driving? is_not [:first, :second, :over_drive]
     end
   end
 
@@ -267,7 +288,7 @@ a block can be used to define the method body.
   class Tractor
     enum_attr :gear, %w(reverse ^neutral first second over_drive) do
       parked? :neutral
-      driving? [:first, :second, :third]
+      driving? [:first, :second, :over_drive]
     end
     enum_attr :plow, %w(^up down), :plural=>:plow_values do
       plowing? { self.gear_is_in_first? && @plow == :down }
@@ -286,7 +307,7 @@ as bounded incrementor and decrementor of the gear attribute.
   class Tractor
     enum_attr :gear, %w(reverse ^neutral first second over_drive) do
       parked? :neutral
-      driving? [:first, :second, :third]
+      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
@@ -349,7 +370,9 @@ overwriting the plugin's methods.  The best approach is shown here:
     def self.new(*args)
       ...
     end
-    def self.method_missing(methId, *args, &blk)
+
+    private
+    def method_missing(methId, *args, &blk)
       ...
     end
 		

data/Rakefile

@@ -2,10 +2,10 @@
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
 require 'rake/contrib/sshpublisher'
- 
+
 spec = Gem::Specification.new do |s|
   s.name = 'enumerated_attribute'
-  s.version = '0.1.6'
+  s.version = '0.1.7'
   s.platform = Gem::Platform::RUBY
   s.description = 'An enumerated attribute accessor'
   s.summary = 'Add enumerated attributes with initialization, dynamic predicate methods, more ...'
@@ -44,29 +44,6 @@ namespace :spec do
 	task :all=>[:spec, :active_record] 
 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|

data/lib/enumerated_attribute.rb

@@ -12,12 +12,6 @@ module EnumeratedAttribute
 		end
 		alias_method :enum_attr, :enumerated_attribute
 		
-		#these implementations are for basic ruby objects - integrations (see Integrations::ActiveRecord and Integrations::Object) may alter them
-		#def define_enumerated_attribute_custom_method(symbol, attr_name, value, negated)
-		#private
-		#def define_enumerated_attribute_new_method
-		#def define_enumerated_attribute_writer_method name
-		#def define_enumerated_attribute_reader_method name
 	end
 	
 end

data/lib/enumerated_attribute/attribute.rb

@@ -7,11 +7,10 @@ module EnumeratedAttribute
 	class IntegrationError < EnumeratedAttributeError; end
 	class InvalidEnumeration < EnumeratedAttributeError; end
 	class InvalidDefinition < EnumeratedAttributeError; end
+	class AmbiguousMethod < EnumeratedAttributeError; end
 
 	module Attribute
-#		def included(klass); klass.extend(ClassMethods); end
-		
-#		module ClassMethods
+	
 			private
 			def create_enumerated_attribute(*args, &block)
 				return if args.empty?
@@ -98,8 +97,8 @@ module EnumeratedAttribute
 					
 						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				
+							respond_to_without_enumerated_attribute?(method) || (!!parse_dynamic_method_parts!(method.to_s) rescue false)
+						end
 						
 						def initialize_enumerated_attributes(only_if_nil = false)
 							self.class.enumerated_attribute_initial_value_list.each do |k,v|
@@ -109,7 +108,7 @@ module EnumeratedAttribute
 
 						private
 						
-						def parse_dynamic_method_parts(meth_name)
+						def parse_dynamic_method_parts!(meth_name)
 							return(nil) unless meth_name[-1, 1] == '?'
 							
 							middle = meth_name.chop #remove the ?
@@ -120,17 +119,31 @@ module EnumeratedAttribute
 									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|
+							attr_sym = attr ? attr.to_sym : nil
+							if (enum_values = @@enumerated_attribute_values[attr_sym] )	#nil if [nil]
+								enum_values.each do |v|
 									if middle.sub!(Regexp.new(v.to_s+"$"), "")
 										value = v; break
 									end
+								end	
+							else
+								#search through enum values one at time and identify any ambiguities
+								@@enumerated_attribute_values.each do |attr_key,enums|
+									enums.each do|v|
+										if middle.match(v.to_s+"$")
+											raise(AmbiguousMethod, meth_name+" is ambiguous, use something like "+attr_sym.to_s+(middle[0,1]=='_'? '' : '_')+middle+"? or "+attr_key.to_s+(middle[0,1]=='_'? '' : '_')+middle+"?", caller) if attr_sym
+											attr_sym = attr_key
+											value = v
+										end
+									end
 								end
+								return (nil) unless attr_sym
+								attr = attr_sym.to_s
+								middle.sub!(Regexp.new(value.to_s+"$"), "")
 							end
+						
 							unless value #check for nil?
 								return (nil) unless middle.sub!(Regexp.new('nil$'), "")
 								value = nil
@@ -141,9 +154,10 @@ module EnumeratedAttribute
 					
 						def define_enumerated_attribute_dynamic_method(methId)
 							meth_name = methId.id2name
-							return(false) unless (parts = parse_dynamic_method_parts(meth_name))
+							parts = parse_dynamic_method_parts!(meth_name)
+							return(false) unless parts
 							
-							negated = !!parts[1].downcase.match(/_not_/)
+							negated = !!parts[1].downcase.match(/(^|_)not_/)
 							value = parts[2] ? parts[2].to_sym : nil
 							self.class.define_enumerated_attribute_custom_method(methId, parts[0], value, negated)
 							
@@ -203,6 +217,12 @@ module EnumeratedAttribute
 				
 			end		
 		end
-	#end	
+		
+		#these methods are called by create_enumerated_attribute but defined by the integration (see Integrations::ActiveRecord and Integrations::Object) may alter them
+		#def define_enumerated_attribute_custom_method(symbol, attr_name, value, negated)
+		#private
+		#def define_enumerated_attribute_new_method
+		#def define_enumerated_attribute_writer_method name
+		#def define_enumerated_attribute_reader_method name		
 	
 end

data/spec/active_record/cfg.rb

@@ -1,3 +1,5 @@
+#irb -r cfg ==> to work configure for working in IRB
+$: << '../../lib'
 require 'test_in_memory'
-require '../../lib/enumerated_attribute'
+require 'enumerated_attribute'
 require 'race_car'

data/spec/cfg.rb

@@ -0,0 +1,6 @@
+#irb -r cfg ==> to work configure for working in IRB
+$: << '../lib'
+require 'enumerated_attribute'
+require 'tractor'
+require 'car'
+require 'plural'

data/spec/poro_spec.rb

@@ -26,6 +26,31 @@ describe "Plural" do
 end
 
 describe "Tractor" do
+	
+	it "should not raise errors for dynamic predicate methods missing attribute name" do
+		t=Tractor.new
+		lambda{ t.neutral?.should be_true }.should_not raise_error
+		lambda{ t.is_neutral?.should be_true }.should_not raise_error
+		lambda{ t.not_neutral?.should be_false}.should_not raise_error
+		t.gear = :first
+		t.neutral?.should be_false
+		t.not_neutral?.should be_true
+	end
+	
+	it "should raise AmbiguousMethod when calling :off?" do
+		t=Tractor.new
+		lambda { t.off? }.should raise_error(EnumeratedAttribute::AmbiguousMethod)
+	end
+	
+	it "should raise AmbiguousMethod when calling :in_reverse?" do
+		t=Tractor.new
+		lambda {t.in_reverse?}.should raise_error(EnumeratedAttribute::AmbiguousMethod)
+	end
+	
+	it "should raise AmbiguousMethod when calling :not_reverse?" do
+		t=Tractor.new
+		lambda {t.not_reverse?}.should raise_error(EnumeratedAttribute::AmbiguousMethod)
+	end	
 
   it "should initialize :gear for two instances of the same class" do
 		t=Tractor.new

data/spec/tractor.rb

@@ -20,6 +20,8 @@ class Tractor
     upshift { self.gear_is_in_over_drive? ? self.gear : self.gear_next }
     downshift { self.driving? ? self.gear_previous : self.gear }
   end
+	
+	enum_attr :pto, %w(reverse ^off forward)
   
   enum_attr :plow, %w(^up down), :nil=>true do
     plowing? { self.gear_is_in_first? && self.plow == :down }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jeffp-enumerated_attribute
 version: !ruby/object:Gem::Version 
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors: 
 - Jeff Patmon
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-14 00:00:00 -07:00
+date: 2009-07-17 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -39,6 +39,7 @@ files:
 - spec/active_record/single_table_inheritance_spec.rb
 - spec/active_record/test_in_memory.rb
 - spec/car.rb
+- spec/cfg.rb
 - spec/new_and_method_missing_spec.rb
 - spec/plural.rb
 - spec/poro_spec.rb