edave-enumerated_attribute 0.2.18

data/spec/cfg.rb

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

data/spec/inheritance_classes.rb

@@ -0,0 +1,16 @@
+require 'enumerated_attribute'
+
+class Base
+	enum_attr :base1, %w(^one two three four)
+	enum_attr :inherited1, %w(^one two three four)
+	enum_attr :inherited2, %w(^one two three four)
+end
+
+class Sub < Base
+	enum_attr :sub1, %w(one ^two three four)
+	enum_attr :inherited1, %w(one ^two three four)
+	enum_attr :inherited2, %w(^five six seven eight)
+end
+
+class Sub2 < Base
+end

data/spec/inheritance_spec.rb

@@ -0,0 +1,80 @@
+require 'inheritance_classes'
+
+def one_to_four; [:one, :two, :three, :four]; end
+def five_to_eight; [:five, :six, :seven, :eight]; end
+
+describe "Base" do
+	it "should have :base1 init to :one" do
+		o=Base.new
+		o.base1.should == :one
+		o.enums(:base1).should == one_to_four
+		o.base1_previous.should == :four
+	end
+	it "should have :inherited1 init to :one" do
+		o=Base.new
+		o.inherited1.should == :one
+		o.enums(:inherited1).should == one_to_four
+		o.inherited1_previous.should == :four
+	end
+	it "should have :inherited2 init to :one" do
+		o=Base.new
+		o.inherited2.should == :one
+		o.enums(:inherited2).should == one_to_four
+		o.inherited2_previous.should == :four
+	end	
+end
+
+describe "Sub<Base" do
+	it "should instantiate an object" do
+		lambda { s=Sub.new }.should_not raise_error
+	end
+	it "should have :sub1 init to :two" do
+		o=Sub.new
+		o.sub1.should == :two
+		o.enums(:sub1).should == one_to_four
+		o.sub1_previous.should == :one
+	end
+	it "should have :base1 init to :one" do
+		o=Sub.new
+		o.base1.should == :one
+		o.enums(:base1).should == one_to_four
+		o.base1_previous.should == :four
+	end
+	it "should have :inherited1 init to :two" do
+		o=Sub.new
+		o.inherited1.should == :two
+		o.enums(:inherited1).should == one_to_four
+		o.inherited1_previous.should == :one
+	end
+	it "should have :inherited2 init to :five" do
+		o=Sub.new
+		o.inherited2.should == :five
+		o.enums(:inherited2).should == five_to_eight
+		o.inherited2_previous.should == :eight
+	end		
+end
+
+describe "Sub2<Base" do
+	it "should instantiate an object" do
+		lambda {s=Sub2.new}.should_not raise_error
+	end
+	it "should have :base1 init to :one" do
+		o=Sub2.new
+		o.base1.should == :one
+		o.enums(:base1).should == one_to_four
+		o.base1_previous.should == :four
+	end
+	it "should have :inherited1 init to :one" do
+		o=Sub2.new
+		o.inherited1.should == :one
+		o.enums(:inherited1).should == one_to_four
+		o.inherited1_previous.should == :four
+	end
+	it "should have :inherited2 init to :one" do
+		o=Sub2.new
+		o.inherited2.should == :one
+		o.enums(:inherited2).should == one_to_four
+		o.inherited2_previous.should == :four
+	end	
+end
+

data/spec/new_and_method_missing_spec.rb

@@ -0,0 +1,73 @@
+require 'car'
+
+#used to test that method_missing chaining plays nice in inheritance situation
+
+describe "CarWithMethods" do
+	
+	it "should initialize Car and Vehicle _method_missing_called? to false" do
+		c= CarWithMethods.new
+		c.car_method_missing_called?.should be_false
+		c.vehicle_method_missing_called?.should be_false
+	end
+	
+	it "should initialize Car and Vehicle _new_called? to false" do
+		CarWithMethods.reset
+		CarWithMethods.car_new_called?.should be_false
+		CarWithMethods.vehicle_new_called?.should be_false
+	end
+	
+	it "should initialize :gear to :neutral" do
+		c = CarWithMethods.new
+		c.gear.should == :neutral
+	end
+	
+	it "should hit both new methods for Car and Vehicle on instantiation" do
+		CarWithMethods.reset
+		CarWithMethods.new
+		CarWithMethods.car_new_called?.should be_true
+		CarWithMethods.vehicle_new_called?.should be_true
+	end
+  
+  it "should not hit method_missing when calling dynamic predicate method :gear_is_in_reverse?" do
+    c = CarWithMethods.new
+    c.gear_is_in_reverse?
+    c.car_method_missing_called?.should be_false
+    c.vehicle_method_missing_called?.should be_false
+  end
+  
+  it "should hit Car and Vehicle method_missing when calling unsupported dynamic predicate method" do
+    c = CarWithMethods.new
+    c.parking_break_is_on?
+    c.car_method_missing_called?.should be_true
+    c.vehicle_method_missing_called?.should be_true
+  end
+end
+
+describe "CarWithoutMethods" do
+	
+	it "should set Car and Vehicle _new_called? to false when calling :reset" do
+		CarWithoutMethods.reset
+		CarWithoutMethods.car_new_called?.should be_false
+		CarWithoutMethods.vehicle_new_called?.should be_false
+	end
+	
+	it "should hit only Vehicle _new_called? on instantiation" do
+		CarWithoutMethods.reset
+		CarWithoutMethods.new
+		CarWithoutMethods.car_new_called?.should be_false
+		CarWithoutMethods.vehicle_new_called?.should be_true
+	end
+		
+	it "should not hit Vehicle method_missing when calling dynamic predicate method :gear_is_in_first?" do
+		c = CarWithoutMethods.new		
+		c.gear_is_in_drive?
+		c.vehicle_method_missing_called?.should be_false
+	end
+	
+	it "should hit Vehicle method_missing when calling unsupported predicate method" do
+		c = CarWithoutMethods.new
+		c.parking_break2_is_on?
+		c.vehicle_method_missing_called?.should be_true
+	end	
+    
+end

data/spec/plural.rb

@@ -0,0 +1,8 @@
+require 'enumerated_attribute'
+
+class Plural
+		enum_attr :box, %w(small medium large)
+		enum_attr :batch, %w(none daily weekly)
+		enum_attr :cherry, %w(red green yellow)
+		enum_attr :guy, %w(handsome funny cool)
+end

data/spec/poro_spec.rb

@@ -0,0 +1,420 @@
+require 'rubygems'
+require 'tractor'
+require 'plural'
+
+Spec::Matchers.define :define_instance_method do |method_name|
+  match do |klass_or_object|
+    if klass_or_object.is_a?(Class)
+      klass_or_object.method_defined?(method_name.to_sym)
+    else
+      klass_or_object.class.method_defined?(method_name.to_sym)
+    end
+  end
+end
+
+describe "enumerated_attributes caching" do
+  class Impl1
+    enum_attr :enum1, %w(e1 e2)
+    enumerated_attributes
+    enum_attr :enum2, %w(e3 e4)
+  end
+  it "should have enum2 described even though enumerated_attributes cached state" do
+    obj = Impl1.new
+    lambda { obj.enum2 = :e3 }.should_not raise_exception
+  end
+end
+describe "Plural" do
+	it "should have plural accessor :boxes for :box" do
+		p=Plural.new
+		p.should define_instance_method(:boxes) #methods.should include("boxes")
+		p.boxes.should == [:small, :medium, :large]
+	end
+	it "should have plural accessor :batches for :batch" do
+		p=Plural.new
+		p.should define_instance_method(:batches) #methods.should include("batches")
+		p.batches.should == [:none, :daily, :weekly]
+	end
+	it "should have plural accessor :cherries for :cherry" do
+		p=Plural.new
+		p.should define_instance_method(:cherries) #methods.should include("cherries")
+		p.cherries.should == [:red, :green, :yellow]
+	end
+	it "should have plural accessor :guys for :guy" do
+		p=Plural.new
+		p.should define_instance_method(:guys) #methods.should include("guys")
+		p.guys.should == [:handsome, :funny, :cool]
+	end
+	
+end
+
+describe "Tractor" do
+
+	it "should have default labels for :gear attribute" do
+		labels_hash = {:reverse=>'Reverse', :neutral=>'Neutral', :first=>'First', :second=>'Second', :over_drive=>'Over drive'}
+		labels = ['Reverse', 'Neutral', 'First', 'Second', 'Over drive']
+		select_options = [['Reverse', 'reverse'], ['Neutral', 'neutral'], ['First', 'first'], ['Second', 'second'], ['Over drive', 'over_drive']]
+		t=Tractor.new
+		t.gears.labels.should == labels
+		labels_hash.each do |k,v|
+			t.gears.label(k).should == v
+		end
+		t.gears.hash.should == labels_hash
+		t.gears.select_options.should == select_options
+	end
+	
+	it "should retrieve :gear enums through enums method" do
+		t=Tractor.new
+		t.enums(:gear).should == t.gears
+	end
+	
+	it "should retrieve custom labels for :side_light attribute" do
+		labels_hash = {:off=>'OFF', :low=>'LOW DIM', :high=>'HIGH BEAM', :super_high=>'SUPER BEAM'}
+		t=Tractor.new
+		enum = t.enums(:side_light)
+		t.enums(:side_light).hash.each do |k,v|
+			enum.label(k).should == labels_hash[k]
+		end
+	end
+	
+	it "should return a Symbol type from reader methods" do
+		t=Tractor.new
+		t.gear.should be_an_instance_of(Symbol)
+	end	
+	
+	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
+		t.gear.should == :neutral
+		s=Tractor.new
+		s.gear.should == :neutral
+	end
+	
+  it "should dynamically create :plow_nil? and :plow_not_nil?" do
+    t=Tractor.new
+    t.plow_nil?.should be_false
+    t.plow_not_nil?.should be_true
+    t.plow = nil
+    t.plow_not_nil?.should be_false
+    t.plow_nil?.should be_true
+    Tractor.should define_instance_method(:plow_nil?) 
+    Tractor.should define_instance_method(:plow_not_nil?) 
+  end
+  
+  it "should dynamically create :plow_is_nil? and :plow_is_not_nil?" do
+    t=Tractor.new
+    t.plow_is_nil?.should be_false
+    t.plow_is_not_nil?.should be_true
+    t.plow = nil
+    t.plow_is_not_nil?.should be_false
+    t.plow_is_nil?.should be_true
+    Tractor.should define_instance_method(:plow_is_nil?) 
+    Tractor.should define_instance_method(:plow_is_not_nil?) 
+  end
+  
+  it "should negate result for not_parked? defined with is_not" do
+    t=Tractor.new
+    t.gear = :neutral
+    t.not_parked?.should be_false
+  end
+  
+  it "should negate result for not_driving? defined with is_not" do
+    t=Tractor.new
+    t.gear = :neutral
+    t.not_driving?.should be_true
+  end
+
+=begin
+  it "should have getter but no setter for :temperature" do
+    Tractor.instance_methods.should_not include('temperature=')
+    Tractor.instance_methods.should include('temperature')
+  end
+  
+  it "should have setter but no getter for :ignition" do
+    Tractor.instance_methods.should_not include('ignition')
+    Tractor.instance_methods.should include('ignition=')
+  end
+=end
+
+  it "should be able to set :plow to nil" do
+    t=Tractor.new
+    lambda { t.plow = nil }.should_not raise_error(EnumeratedAttribute::InvalidEnumeration)
+  end
+  
+  it "should have method :plow_nil? that operates correctly" do
+    t=Tractor.new
+    t.plow.should_not be_nil
+    t.plow_nil?.should be_false
+    t.plow = nil
+    t.plow.should be_nil
+    t.plow_nil?.should be_true
+  end
+  
+  it "should raise EnumeratedAttribute::InvalidEnumeration when setting :gear to nil" do
+    t=Tractor.new
+    lambda{ t.gear = nil }.should raise_error(EnumeratedAttribute::InvalidEnumeration)
+  end
+  
+  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 return true when calling respond_to? for :gear_is_in_neutral? with an optional argument" do
+    t=Tractor.new
+    t.respond_to?(:gear_is_in_neutral?, true).should be_true
+    t.respond_to?(:gear_is_in_neutral?, false).should be_true
+  end
+
+  it "should return true when called respond_to? for :gear_is_in_high? with an optional argument" do
+    t=Tractor.new
+    t.respond_to?(:gear_is_in_high?, true).should be_false
+    t.respond_to?(:gear_is_in_high?, false).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
+    Tractor.should define_instance_method(:gear_is_in_reverse?)
+    Tractor.should define_instance_method(:gear_is_not_in_reverse?)
+  end
+
+  it "should have created instance methods for :neutral" do
+    Tractor.should define_instance_method(:gear_is_in_neutral?)
+    Tractor.should define_instance_method(:gear_is_not_in_neutral?)
+  end
+
+  it "should have created instance methods for :over_drive" do
+    Tractor.should define_instance_method :gear_is_in_over_drive?
+    Tractor.should define_instance_method :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 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(EnumeratedAttribute::InvalidEnumeration)
+  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