dm-core 0.9.5 → 0.9.6

data/spec/unit/adapters/in_memory_adapter_spec.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', "..", 'spec_helper'))
+
+describe DataMapper::Adapters::InMemoryAdapter do
+  before do
+    DataMapper.setup(:inmem, :adapter => 'in_memory')
+
+    class Heffalump
+      include DataMapper::Resource
+
+      def self.default_repository_name
+        :inmem
+      end
+
+      property :color,      String, :key => true # TODO: Drop the 'must have a key' limitation
+      property :num_spots,  Integer
+      property :striped,    Boolean
+    end
+
+    @heff1 = Heffalump.create(:color => 'Black', :num_spots => 0,   :striped => true)
+    @heff2 = Heffalump.create(:color => 'Brown', :num_spots => 25,  :striped => false)
+    @heff3 = Heffalump.create(:color => 'Blue',  :num_spots => nil, :striped => false)
+  end
+
+  it 'should successfully save an object' do
+    @heff1.new_record?.should be_false
+  end
+
+  it 'should be able to get the object' do
+    Heffalump.get('Black').should == @heff1
+  end
+
+  it 'should be able to get all the objects' do
+    Heffalump.all.should == [@heff1, @heff2, @heff3]
+  end
+
+  it 'should be able to search for objects with equal value' do
+    Heffalump.all(:striped => true).should == [@heff1]
+  end
+
+  it 'should be able to search for objects included in an array of values' do
+    Heffalump.all(:num_spots => [ 25, 50, 75, 100 ]).should == [@heff2]
+  end
+
+  it 'should be able to search for objects included in a range of values' do
+    Heffalump.all(:num_spots => 25..100).should == [@heff2]
+  end
+
+  it 'should be able to search for objects with nil value' do
+    Heffalump.all(:num_spots => nil).should == [@heff3]
+  end
+
+  it 'should be able to search for objects with not equal value' do
+    Heffalump.all(:striped.not => true).should == [@heff2, @heff3]
+  end
+
+  it 'should be able to search for objects not included in an array of values' do
+    Heffalump.all(:num_spots.not => [ 25, 50, 75, 100 ]).should == [@heff1, @heff3]
+  end
+
+  it 'should be able to search for objects not included in a range of values' do
+    Heffalump.all(:num_spots.not => 25..100).should == [@heff1, @heff3]
+  end
+
+  it 'should be able to search for objects with not nil value' do
+    Heffalump.all(:num_spots.not => nil).should == [@heff1, @heff2]
+  end
+
+  it 'should be able to search for objects that match value' do
+    Heffalump.all(:color.like => 'Bl').should == [@heff1, @heff3]
+  end
+
+  it 'should be able to search for objects with value greater than' do
+    Heffalump.all(:num_spots.gt => 0).should == [@heff2]
+  end
+
+  it 'should be able to search for objects with value greater than or equal to' do
+    Heffalump.all(:num_spots.gte => 0).should == [@heff1, @heff2]
+  end
+
+  it 'should be able to search for objects with value less than' do
+    Heffalump.all(:num_spots.lt => 1).should == [@heff1]
+  end
+
+  it 'should be able to search for objects with value less than or equal to' do
+    Heffalump.all(:num_spots.lte => 0).should == [@heff1]
+  end
+
+  it 'should be able to update an object' do
+    @heff1.num_spots = 10
+    @heff1.save
+    Heffalump.get('Black').num_spots.should == 10
+  end
+
+  it 'should be able to destroy an object' do
+    @heff1.destroy
+    Heffalump.all.size.should == 2
+  end
+end

data/spec/unit/associations/many_to_many_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_hel
 
 describe DataMapper::Associations::ManyToMany do
 
-  load_models_for_metaphor :vehicles
+  load_models_for_metaphor :vehicles, :content
 
   it 'should allow a declaration' do
     lambda do
@@ -11,6 +11,21 @@ describe DataMapper::Associations::ManyToMany do
       end
     end.should_not raise_error
   end
+
+  it 'should handle models inside modules' do
+    lambda do
+      module Content
+        class Dialect
+          has n, :locales, :through => Resource, :class_name => "Language::Locale"
+        end
+
+        class Locale
+          has n, :dialects, :through => Resource, :class_name => "Language::Dialect"
+        end
+      end
+    end.should_not raise_error
+  end
+
 end
 
 describe DataMapper::Associations::ManyToMany::Proxy do

data/spec/unit/model_spec.rb

@@ -147,22 +147,6 @@ describe 'DataMapper::Model' do
     end
   end
 
-  it 'should provide #inheritance_property' do
-    ModelSpec::Resource.should respond_to(:inheritance_property)
-  end
-
-  describe '#inheritance_property' do
-    it 'should return a Property object' do
-      ModelSpec::Resource.inheritance_property(:legacy).should be_kind_of(DataMapper::Property)
-      ModelSpec::Resource.inheritance_property(:legacy).name.should == :type
-      ModelSpec::Resource.inheritance_property(:legacy).type.should == DM::Discriminator
-    end
-
-    it 'should use default repository when not passed any arguments' do
-      ModelSpec::Resource.inheritance_property.object_id.should == ModelSpec::Resource.inheritance_property(:default).object_id
-    end
-  end
-
   it 'should provide #get' do
     ModelSpec::Resource.should respond_to(:get)
   end

data/spec/unit/property_set_spec.rb

@@ -24,7 +24,7 @@ end
 
 describe DataMapper::PropertySet do
   before :each do
-    @properties = Icon.properties(:default)
+    @properties = Icon.properties(:default).dup
   end
 
   it "#slice should find properties" do
@@ -35,6 +35,13 @@ describe DataMapper::PropertySet do
     @properties.select { |property| property.primitive == Integer }.should have(3).entries
   end
 
+  it "#clear should clear out set" do
+    @properties.clear
+    @properties.key.should == []
+    @properties.defaults.should == []
+    @properties.length.should == 0
+  end
+
   it "#[] should find properties by name (Symbol or String)" do
     default_properties = [ :id, 'name', :width, 'height' ]
     @properties.each_with_index do |property,i|

data/spec/unit/property_spec.rb

@@ -1,221 +1,405 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
 describe DataMapper::Property do
-  before :all do
+  before :each do
+    Object.send(:remove_const, :Zoo) if defined?(Zoo)
     class Zoo
       include DataMapper::Resource
+
+      property :id, DataMapper::Types::Serial
     end
 
+    Object.send(:remove_const, :Name) if defined?(Name)
     class Name < DataMapper::Type
       primitive String
-      size 100
+      track :hash
+
+      def self.load(value, property)
+        value.split(", ").reverse
+      end
+
+      def self.dump(value, property)
+        value && value.reverse.join(", ")
+      end
+
+      def self.typecast(value, property)
+        value
+      end
     end
 
+    Object.send(:remove_const, :Tomato) if defined?(Tomato)
     class Tomato
       include DataMapper::Resource
     end
   end
 
-  before do
-    @property = DataMapper::Property.new(Zoo, :name, String, :default => 'San Diego')
-  end
-
-  it 'should provide .new' do
-    DataMapper::Property.should respond_to(:new)
-  end
-
   describe '.new' do
     [ Float, BigDecimal ].each do |primitive|
       describe "with a #{primitive} primitive" do
-        it 'should raise an ArgumentError if precision is equal to or less than 0' do
-          lambda{
-            DataMapper::Property.new(Zoo, :test, primitive, :precision => 0)
+        it 'should raise an ArgumentError if precision is 0' do
+          lambda {
+            Zoo.class_eval <<-RUBY
+              property :test, #{primitive}, :precision => 0
+            RUBY
           }.should raise_error(ArgumentError)
+        end
 
-          lambda{
-            DataMapper::Property.new(Zoo, :test, primitive, :precision => -1)
+        it "raises an ArgumentError if precision is less than 0" do
+          lambda {
+            Zoo.class_eval <<-RUBY
+              property :test, #{primitive}, :precision => -1
+            RUBY
           }.should raise_error(ArgumentError)
         end
 
         it 'should raise an ArgumentError if scale is less than 0' do
-          lambda{
-            DataMapper::Property.new(Zoo, :test, primitive, :scale => -1)
+          lambda {
+            Zoo.class_eval <<-RUBY
+              property :test, #{primitive}, :scale => -1
+            RUBY
           }.should raise_error(ArgumentError)
         end
 
         it 'should raise an ArgumentError if precision is less than scale' do
-          lambda{
-            DataMapper::Property.new(Zoo, :test, primitive, :precision => 1, :scale => 2)
+          lambda {
+            Zoo.class_eval <<-RUBY
+              property :test, #{primitive}, :precision => 1, :scale => 2
+            RUBY
           }.should raise_error(ArgumentError)
         end
       end
     end
   end
 
-  it 'should provide #field' do
-    @property.should respond_to(:field)
-  end
-
   describe '#field' do
-    it 'should accept a custom field' do
-      property = DataMapper::Property.new(Zoo, :location, String, :field => 'City')
-      property.field.should == 'City'
-    end
+    before(:each) do
+      Zoo.class_eval do
+        property :location, String, :field => "City"
 
-    it 'should use repository name if passed in' do
-      @property.field(:default).should == 'name'
+        repository(:mock) do
+          property :location, String, :field => "MockCity"
+        end
+      end
     end
 
-    it 'should return default field if no repository name passed in' do
-      @property.field.should == 'name'
+    it 'should accept a custom field' do
+      Zoo.properties[:location].field.should == 'City'
     end
-  end
 
-  it 'should provide #get' do
-    @property.should respond_to(:get)
+    # How is this supposed to work?
+    it 'should use repository name if passed in' do
+      pending
+      Zoo.properties[:location].field(:mock).should == 'MockCity'
+    end
   end
 
   describe '#get' do
     before do
-      @original_values = {}
-      @resource        = mock('resource', :kind_of? => true, :new_record? => true, :original_values => @original_values)
+      Zoo.class_eval do
+        property :name, String, :default => "San Diego"
+        property :address, String
+      end
+      @resource        = Zoo.new
     end
 
     describe 'when setting the default on initial access' do
-      before do
-        # make sure there was no original value
-        @original_values.should_not have_key(:name)
+      it 'should set the ivar to the default' do
+        @resource.name.should == 'San Diego'
+      end
 
-        # force the default to be set
-        @resource.should_receive(:instance_variable_get).with('@name').twice.and_return(nil)
-        @resource.should_receive(:attribute_loaded?).with(:name).and_return(false)
+      it 'should set the original value to nil' do
+        @resource.original_values[:name].should == nil
       end
+    end
 
-      it 'should set the ivar to the default' do
-        @resource.should_receive(:instance_variable_set).with('@name', 'San Diego')
+    it "should not reload the default if you set the property to nil" do
+      @resource.name = nil
+      @resource.name.should == nil
+    end
+  end
+
+  describe '#get, when tracking via :hash' do
+    before do
+      Zoo.class_eval do
+        property :name, String, :lazy => true, :track => :hash
+      end
+      Zoo.auto_migrate!
+      @resource = Zoo.create(:name => "San Diego")
+    end
 
-        @property.get(@resource).should == 'San Diego'
+    describe 'when setting the default on initial access' do
+      it 'should set the ivar to the default' do
+        @resource.name.should == "San Diego"
       end
 
       it 'should set the original value to nil' do
-        @property.get(@resource).should == 'San Diego'
+        @resource.name
+        @resource.original_values[:name].should == "San Diego".hash
+      end
 
-        @original_values.should == { :name => nil }
+      it "should know it's dirty if a change was made to the object" do
+        @resource.name.upcase!
+        @resource.should be_dirty
       end
     end
   end
 
-  it 'should provide #get!' do
-    @property.should respond_to(:get!)
+  describe '#get, when tracking via :get' do
+    before do
+      Zoo.class_eval do
+        property :name, String
+      end
+      Zoo.auto_migrate!
+      @resource = Zoo.create(:name => "San Diego")
+    end
+
+    describe 'when setting the default on initial access' do
+      it 'should set the ivar to the default' do
+        @resource.name.should == "San Diego"
+      end
+
+      it 'should set the original value to "San Diego"' do
+        @resource.name
+        @resource.original_values[:name].should == "San Diego"
+      end
+    end
+
+    it "should know it's dirty if a change was made to the object" do
+      @resource.name.upcase!
+      @resource.name
+      @resource.should be_dirty
+      @resource.original_values[:name].should == "San Diego"
+    end
   end
 
-  describe '#get!' do
-    it 'should get the resource instance variable' do
-      resource = mock('resource', :kind_of? => true)
-      resource.should_receive(:instance_variable_get).with('@name').and_return('Portland Zoo')
-      @property.get!(resource).should == 'Portland Zoo'
+  describe 'with Proc defaults' do
+    it "calls the proc" do
+      Zoo.class_eval do
+        property :name, String, :default => proc {|r,p| "San Diego"}
+        property :address, String
+      end
+
+      Zoo.new.name.should == "San Diego"
+    end
+
+    it "provides the resource to the proc" do
+      Zoo.class_eval do
+        property :name, String, :default => proc {|r,p| r.address}
+        property :address, String
+      end
+
+      zoo = Zoo.new
+      zoo.address = "San Diego"
+      zoo.name.should == "San Diego"
+    end
+
+    it "provides the property to the proc" do
+      Zoo.class_eval do
+        property :name, String, :default => proc {|r,p| p.name.to_s}
+      end
+
+      zoo = Zoo.new
+      zoo.name.should == "name"
     end
   end
 
-  it 'should provide #set' do
-    @property.should respond_to(:set)
+
+  describe '#get!' do
+    it 'should get the resource' do
+      Zoo.class_eval do
+        property :name, String
+      end
+
+      resource = Zoo.new(:name => "Portland Zoo")
+      resource.name.should == "Portland Zoo"
+    end
   end
 
   describe '#set' do
-    before do
-      @original_values = {}
-      @resource        = mock('resource', :kind_of? => true, :original_values => @original_values, :new_record? => true)
+    before(:each) do
+      Zoo.class_eval do
+        property :name, String
+        property :age, Integer
+        property :description, String, :lazy => true
+      end
+      Zoo.auto_migrate!
+      Zoo.create(:name => "San Diego Zoo", :age => 888,
+        :description => "Great Zoo")
+      @resource = Zoo.new
     end
 
     it 'should typecast the value' do
-      @property.should_receive(:typecast).with(888)
-      @property.set(@resource, 888)
+      @resource.age = "888"
+      @resource.age.should == 888
+    end
+
+    it "should lazy load itself first" do
+      resource = Zoo.first
+      resource.description = "Still a Great Zoo"
+      resource.original_values[:description].should == "Great Zoo"
     end
-  end
 
-  it 'should provide #set!' do
-    @property.should respond_to(:set!)
+    it "should only set original_values once" do
+      resource = Zoo.first
+      resource.description = "Still a Great Zoo"
+      resource.description = "What can I say. This is one great Zoo"
+      resource.original_values[:description].should == "Great Zoo"
+    end
   end
 
   describe '#set!' do
-    it 'should set the resource instance variable' do
-      resource = mock('resource', :kind_of? => true)
-      resource.should_receive(:instance_variable_set).with('@name', 'Seattle Zoo').and_return(resource)
-      @property.set!(resource, 'Seattle Zoo').object_id.should == resource.object_id
+    before do
+      Zoo.class_eval do
+        property :name, String
+        property :age, Integer
+      end
     end
-  end
 
-  it "should evaluate two similar properties as equal" do
-    p1 = DataMapper::Property.new(Zoo, :name, String, { :size => 30 })
-    p2 = DataMapper::Property.new(Zoo, :name, String, { :size => 30 })
-    p3 = DataMapper::Property.new(Zoo, :title, String, { :size => 30 })
-    p1.eql?(p2).should == true
-    p1.hash.should == p2.hash
-    p1.eql?(p3).should == false
-    p1.hash.should_not == p3.hash
+    it 'should set the resource' do
+      resource = Zoo.new
+      resource.name = "Seattle Zoo"
+      resource.name.should == "Seattle Zoo"
+    end
   end
 
+  # What is this for?
+  # ---
+  # it "should evaluate two similar properties as equal" do
+  #   p1 = DataMapper::Property.new(Zoo, :name, String, { :size => 30 })
+  #   p2 = DataMapper::Property.new(Zoo, :name, String, { :size => 30 })
+  #   p3 = DataMapper::Property.new(Zoo, :title, String, { :size => 30 })
+  #   p1.eql?(p2).should == true
+  #   p1.hash.should == p2.hash
+  #   p1.eql?(p3).should == false
+  #   p1.hash.should_not == p3.hash
+  # end
+
   it "should create a String property" do
-    property = DataMapper::Property.new(Zoo, :name, String, { :size => 30 })
+    Zoo.class_eval do
+      property :name, String, :size => 30
+    end
 
-    property.primitive.should == String
+    resource = Zoo.new
+    resource.name = 100
+    resource.name.should == "100"
   end
 
   it "should not have key that is lazy" do
-    property = DataMapper::Property.new(Zoo, :id, DataMapper::Types::Text, { :key => true })
-    property.lazy?.should == false
+    Zoo.class_eval do
+      property :id, DataMapper::Types::Text, :key => true
+      property :name, String, :lazy => true
+    end
+    Zoo.auto_migrate!
+
+    Zoo.create(:id => "100", :name => "San Diego Zoo")
+    zoo = Zoo.first
+
+    # Do we mean for attribute_loaded? to be public?
+    zoo.attribute_loaded?(:id).should == true
+  end
+
+  it "should lazily load other non-loaded, non-lazy fields" do
+    # This somewhat contorted setup is to successfully test that
+    # the list of eager properties to be loaded when it's initially
+    # missing is, in fact, repository-scoped
+    Zoo.class_eval do
+      property :id, DataMapper::Types::Serial
+      property :name, String, :lazy => true
+      property :address, String, :lazy => true
+
+      repository(:default2) do
+        property :name, String
+        property :address, String
+      end
+    end
+
+    repository(:default2) do
+      Zoo.auto_migrate!
+      Zoo.create(:name => "San Diego Zoo", :address => "San Diego")
+    end
+    repository(:default2) do
+      zoo = Zoo.first(:fields => [:id])
+
+      zoo.attribute_loaded?(:name).should == false
+      zoo.attribute_loaded?(:address).should == false
+      zoo.name
+      zoo.attribute_loaded?(:name).should == true
+      zoo.attribute_loaded?(:address).should == true
+    end
   end
 
   it "should use a custom type Name property" do
-    class Name < DataMapper::Type
-      primitive String
+    Zoo.class_eval do
+      property :name, Name
     end
 
-    property = DataMapper::Property.new(Zoo, :name, Name, {})
+    Zoo.auto_migrate!
 
-    property.primitive.should == String
-    property.type.should == Name
-    property.primitive.should == property.type.primitive
+    zoo = Zoo.create(:name => %w(Zoo San\ Diego))
+    Zoo.first.name.should == %w(Zoo San\ Diego)
   end
 
   it "should override type options with property options" do
-    property = DataMapper::Property.new(Zoo, :name, Name, { :size => 50 })
-    options = property.instance_variable_get(:@options)
+    Zoo.class_eval do
+      property :name, Name, :track => :get
+    end
 
-    options[:size].should == 50
-  end
+    Zoo.auto_migrate!
 
-  it "should determine nullness" do
-    DataMapper::Property.new(Tomato,:botanical_name,String,{:nullable => true}).options[:nullable].should == true
-  end
+    Zoo.create(:name => %w(Awesome Person\ Dude))
+    zoo = Zoo.first
+    zoo.name = %w(Awesome Person\ Dude)
 
-  it "should determine its name"  do
-    DataMapper::Property.new(Tomato,:botanical_name,String,{}).name.should == :botanical_name
+    # If we were tracking by hash, this would cause zoo to be dirty,
+    # as its hash would not match the original. Since we've overridden
+    # and are tracking by :get, it won't be dirty
+    zoo.name.stub!(:hash).and_return(1)
+    zoo.should_not be_dirty
   end
 
-  it "should determine laziness" do
-    DataMapper::Property.new(Tomato,:botanical_name,String,{:lazy => true}).lazy?.should == true
-    DataMapper::Property.new(Tomato,:seedless,TrueClass,{}).lazy?.should == false
-  end
+  describe "public details" do
+    before do
+      Zoo.class_eval do
+        property :botanical_name, String, :nullable => true, :lazy => true
+        property :colloquial_name, DataMapper::Types::Text, :default => "Tomato"
+      end
+      Zoo.auto_migrate!
+    end
 
-  it "should automatically set laziness to true on text fields?" do
-    DataMapper::Property.new(Tomato,:botanical_name,DataMapper::Types::Text,{}).lazy?.should == true
-  end
+    it "should determine nullness" do
+      Zoo.properties[:botanical_name].options[:nullable].should be_true
+    end
 
-  it "should determine whether it is a key" do
-    DataMapper::Property.new(Tomato,:id,Integer,{:key => true}).key?.should == true
-    DataMapper::Property.new(Tomato,:botanical_name,String,{}).key?.should == false
-  end
+    it "should determine its name"  do
+      Zoo.properties[:botanical_name].name.should == :botanical_name
+    end
 
-  it "should determine whether it is serial" do
-    DataMapper::Property.new(Tomato,:id,Integer,{:serial => true}).serial?.should == true
-    DataMapper::Property.new(Tomato,:botanical_name,String,{}).serial?.should == false
-  end
+    # lazy? is not exposed to or used by the adapters, so it should be tested indirectly
+    it "should determine laziness" do
+      Zoo.create(:botanical_name => "Calystegia sepium")
+      Zoo.first.attribute_loaded?(:botanical_name).should be_false
+    end
+
+    it "should automatically set laziness to true on text fields" do
+      Zoo.create(:colloquial_name => "American hedge bindweed")
+      Zoo.first.attribute_loaded?(:colloquial_name).should be_false
+    end
+
+    it "should determine whether it is a key" do
+      zoo = Zoo.create(:botanical_name => "Calystegia sepium")
+      id = zoo.id
+      Zoo.first.id.should == id
+    end
+
+    it "should determine whether it is serial" do
+      zoo = Zoo.create(:botanical_name => "Calystegia sepium")
+      zoo.id.should_not be_nil
+    end
 
-  it "should determine a default value" do
-    resource = mock('resource')
-    property = DataMapper::Property.new(Tomato, :botanical_name, String, :default => 'Tomato')
-    property.default_for(resource).should == 'Tomato'
+    it "should determine a default value" do
+      zoo = Zoo.new
+      zoo.colloquial_name.should == "Tomato"
+    end
   end
 
   describe "reader and writer visibility" do
@@ -242,9 +426,11 @@ describe DataMapper::Property do
       { :reader => :private, :writer => :private }       => [:private,   :private],
     }.each do |input, output|
       it "#{input.inspect} should make reader #{output[0]} and writer #{output[1]}" do
-        property = DataMapper::Property.new(Tomato, :botanical_name, String, input)
-        property.reader_visibility.should == output[0]
-        property.writer_visibility.should == output[1]
+        Tomato.class_eval <<-RUBY
+          property :botanical_name, String, #{input.inspect}
+        RUBY
+        Tomato.send("#{output[0]}_instance_methods").should include("botanical_name")
+        Tomato.send("#{output[1]}_instance_methods").should include("botanical_name=")
       end
     end
 
@@ -264,16 +450,20 @@ describe DataMapper::Property do
     ].each do |input|
       it "#{input.inspect} should raise ArgumentError" do
         lambda {
-          property = DataMapper::Property.new(Tomato, :family, String, input)
+          Tomato.class_eval <<-RUBY
+            property :family, String, #{input.inspect}
+          RUBY
         }.should raise_error(ArgumentError)
       end
     end
   end
 
-  it "should return an instance variable name" do
-   DataMapper::Property.new(Tomato, :flavor, String, {}).instance_variable_name.should == '@flavor'
-   DataMapper::Property.new(Tomato, :ripe, TrueClass, {}).instance_variable_name.should == '@ripe' #not @ripe?
-  end
+  # This is handled by get!
+  # ---
+  # it "should return an instance variable name" do
+  #  DataMapper::Property.new(Tomato, :flavor, String, {}).instance_variable_name.should == '@flavor'
+  #  DataMapper::Property.new(Tomato, :ripe, TrueClass, {}).instance_variable_name.should == '@ripe' #not @ripe?
+  # end
 
   it "should append ? to TrueClass property reader methods" do
     class Potato
@@ -283,60 +473,61 @@ describe DataMapper::Property do
       property :public, TrueClass
     end
 
-    Potato.new().should respond_to(:fresh)
-    Potato.new().should respond_to(:fresh?)
-
     Potato.new(:fresh => true).should be_fresh
-
-    Potato.new().should respond_to(:public)
-    Potato.new().should respond_to(:public?)
   end
 
   it "should move unknown options into Property#extra_options" do
-    d = DataMapper::Property.new(Tomato,:botanical_name,String,{:foo=>:bar})
-    d.extra_options.should == {:foo => :bar}
+    Tomato.class_eval do
+      property :botanical_name, String, :foo => :bar
+    end
+    Tomato.properties[:botanical_name].extra_options.should == {:foo => :bar}
   end
 
-  it 'should return the attribute value from a given instance' do
-    class Tomato
-      include DataMapper::Resource
-      property :id, Integer, :key => true
+  it 'should provide #custom?' do
+    Zoo.class_eval do
+      property :name, Name, :size => 50
+      property :state, String, :size => 2
     end
-
-    tomato = Tomato.new(:id => 1)
-    tomato.model.properties(:default)[:id].get(tomato).should == 1
+    Zoo.properties[:name].should be_custom
+    Zoo.properties[:state].should_not be_custom
   end
 
-  it 'should set the attribute value in a given instance' do
-    tomato = Tomato.new
-    tomato.model.properties(:default)[:id].set(tomato, 2)
-    tomato.id.should == 2
+  it "should set the field to the correct field_naming_convention" do
+    Zoo.class_eval { property :species, String }
+    Tomato.class_eval { property :genetic_history, DataMapper::Types::Text }
+
+    Zoo.properties[:species].field.should == "species"
+    Tomato.properties[:genetic_history].field.should == "genetic_history"
   end
 
-  it 'should provide #custom?' do
-    DataMapper::Property.new(Zoo, :name, Name, { :size => 50 }).should be_custom
-    DataMapper::Property.new(Zoo, :state, String, { :size => 2 }).should_not be_custom
+  it "should provide the primitive mapping" do
+    Zoo.class_eval do
+      property :poverty, String
+      property :fortune, DataMapper::Types::Text
+    end
+
+    Zoo.properties[:poverty].primitive.should == String
+    Zoo.properties[:fortune].primitive.should == String
   end
 
-  it "should set the field to the correct field_naming_convention" do
-    DataMapper::Property.new(Zoo, :species, String, {}).field(:default).should == 'species'
-    DataMapper::Property.new(Tomato, :genetic_history, DataMapper::Types::Text, {}).field(:default).should == "genetic_history"
+  it "should make it possible to define an integer size" do
+    Zoo.class_eval { property :cleanliness, String, :size => 100 }
+    Zoo.properties[:cleanliness].size.should == 100
   end
 
-  it "should provide the primitive mapping" do
-    DataMapper::Property.new(Zoo, :poverty, String, {}).primitive.should == String
-    DataMapper::Property.new(Zoo, :fortune, DataMapper::Types::Text, {}).primitive.should == String
+  it "should make it possible to define an integer length (which defines size)" do
+    Zoo.class_eval { property :cleanliness, String, :length => 100 }
+    Zoo.properties[:cleanliness].size.should == 100
   end
 
-  it "should provide a size/length" do
-    DataMapper::Property.new(Zoo, :cleanliness, String, { :size => 100 }).size.should == 100
-    DataMapper::Property.new(Zoo, :cleanliness, String, { :length => 200 }).size.should == 200
-    DataMapper::Property.new(Zoo, :cleanliness, String, { :size => (0..100) }).size.should == 100
-    DataMapper::Property.new(Zoo, :cleanliness, String, { :length => (0..200) }).size.should == 200
+  it "should make it possible to define a range size" do
+    Zoo.class_eval { property :cleanliness, String, :size => 0..100 }
+    Zoo.properties[:cleanliness].size.should == 100
   end
 
-  it 'should provide #typecast' do
-    DataMapper::Property.new(Zoo, :name, String).should respond_to(:typecast)
+  it "should make it possible to define a range length (which defines size)" do
+    Zoo.class_eval { property :cleanliness, String, :length => 0..100 }
+    Zoo.properties[:cleanliness].size.should == 100
   end
 
   describe '#typecast' do
@@ -349,169 +540,214 @@ describe DataMapper::Property do
     end
 
     it 'should pass through the value if it is the same type when typecasting' do
-      value = 'San Diego'
-      property = DataMapper::Property.new(Zoo, :name, String)
-      property.typecast(value).object_id.should == value.object_id
+      Zoo.class_eval do
+        property :name, String
+      end
+      zoo = Zoo.new
+      value = "San Diego"
+      def value.to_s() "San Francisco" end
+      zoo.name = value
+      zoo.name.should == "San Diego"
     end
 
     it 'should pass through the value nil when typecasting' do
-      property = DataMapper::Property.new(Zoo, :string, String)
-      property.typecast(nil).should == nil
+      Zoo.class_eval do
+        property :name, String
+      end
+
+      zoo = Zoo.new
+      zoo.name = nil
+      zoo.name.should == nil
     end
 
     it 'should pass through the value for an Object property' do
-      value = 'a ruby object'
-      property = DataMapper::Property.new(Zoo, :object, Object)
-      property.typecast(value).object_id.should == value.object_id
+      value = Object.new
+      Zoo.class_eval do
+        property :object, Object
+      end
+
+      zoo = Zoo.new
+      zoo.object = value
+      zoo.object.object_id.should == value.object_id
     end
 
     [ true, 'true', 'TRUE', 1, '1', 't', 'T' ].each do |value|
       it "should typecast #{value.inspect} to true for a TrueClass property" do
-        property = DataMapper::Property.new(Zoo, :true_class, TrueClass)
-        property.typecast(value).should == true
+        Zoo.class_eval do
+          property :boolean, TrueClass
+        end
+
+        zoo = Zoo.new
+        zoo.boolean = value
+        zoo.boolean.should == true
       end
     end
 
     [ false, 'false', 'FALSE', 0, '0', 'f', 'F' ].each do |value|
       it "should typecast #{value.inspect} to false for a Boolean property" do
-        property = DataMapper::Property.new(Zoo, :true_class, TrueClass)
-        property.typecast(value).should == false
+        Zoo.class_eval do
+          property :boolean, TrueClass
+        end
+
+        zoo = Zoo.new
+        zoo.boolean = value
+        zoo.boolean.should == false
       end
     end
 
     it 'should typecast nil to nil for a Boolean property' do
-      property = DataMapper::Property.new(Zoo, :true_class, TrueClass)
-      property.typecast(nil).should == nil
+      Zoo.class_eval do
+        property :boolean, TrueClass
+      end
+
+      zoo = Zoo.new
+      zoo.boolean = nil
+      zoo.boolean.should == nil
     end
 
     it 'should typecast "0" to "0" for a String property' do
-      property = DataMapper::Property.new(Zoo, :string, String)
-      property.typecast(0).should == '0'
+      Zoo.class_eval do
+        property :string, String
+      end
+
+      zoo = Zoo.new
+      zoo.string = "0"
+      zoo.string.should == "0"
     end
 
     { '0' => 0.0, '0.0' => 0.0, 0 => 0.0, 0.0 => 0.0, BigDecimal('0.0') => 0.0 }.each do |value,expected|
       it "should typecast #{format(value)} to #{format(expected)} for a Float property" do
-        property = DataMapper::Property.new(Zoo, :float, Float)
-        property.typecast(value).should == expected
-      end
-    end
-
-    { '-8' => -8, '-8.0' => -8, -8 => -8, -8.0 => -8, BigDecimal('8.0') => 8 }.each do |value,expected|
-      it "should typecast #{format(value)} to #{format(expected)} for an Integer property" do
-        property = DataMapper::Property.new(Zoo, :integer, Integer)
-        property.typecast(value).should == expected
-      end
-    end
+        Zoo.class_eval do
+          property :float, Float
+        end
 
-    { '0' => 0, '0.0' => 0, 0 => 0, 0.0 => 0, BigDecimal('0.0') => 0 }.each do |value,expected|
-      it "should typecast #{format(value)} to #{format(expected)} for an Integer property" do
-        property = DataMapper::Property.new(Zoo, :integer, Integer)
-        property.typecast(value).should == expected
+        zoo = Zoo.new
+        zoo.float = value
+        zoo.float.should == expected
       end
     end
 
-    { '5' => 5, '5.0' => 5, 5 => 5, 5.0 => 5, BigDecimal('5.0') => 5 }.each do |value,expected|
+    { '-8' => -8, '-8.0' => -8, -8 => -8, -8.0 => -8, BigDecimal('8.0') => 8,
+      '0' => 0, '0.0' => 0, 0 => 0, 0.0 => 0, BigDecimal('0.0') => 0,
+      '5' => 5, '5.0' => 5, 5 => 5, 5.0 => 5, BigDecimal('5.0') => 5,
+      'none' => nil, 'almost 5' => nil, '-3 change' => -3, '9 items' => 9}.each do |value,expected|
       it "should typecast #{format(value)} to #{format(expected)} for an Integer property" do
-        property = DataMapper::Property.new(Zoo, :integer, Integer)
-        property.typecast(value).should == expected
-      end
-    end
+        Zoo.class_eval do
+          property :int, Integer
+        end
 
-    { 'none' => nil, 'almost 5' => nil, '-3 change' => -3, '9 items' => 9 }.each do |value,expected|
-      it "should typecast #{format(value)} to #{format(expected)} for an Integer property" do
-        property = DataMapper::Property.new(Zoo, :integer, Integer)
-        property.typecast(value).should == expected
+        zoo = Zoo.new
+        zoo.int = value
+        zoo.int.should == expected
       end
     end
 
     { '0' => BigDecimal('0'), '0.0' => BigDecimal('0.0'), 0.0 => BigDecimal('0.0'), BigDecimal('0.0') => BigDecimal('0.0') }.each do |value,expected|
       it "should typecast #{format(value)} to #{format(expected)} for a BigDecimal property" do
-        property = DataMapper::Property.new(Zoo, :big_decimal, BigDecimal)
-        property.typecast(value).should == expected
+        Zoo.class_eval do
+          property :big_decimal, BigDecimal
+        end
+
+        zoo = Zoo.new
+        zoo.big_decimal = value
+        zoo.big_decimal.should == expected
       end
     end
 
     it 'should typecast value for a DateTime property' do
-      property = DataMapper::Property.new(Zoo, :date_time, DateTime)
-      property.typecast('2000-01-01 00:00:00').should == DateTime.new(2000, 1, 1, 0, 0, 0)
+      Zoo.class_eval { property :date_time, DateTime }
+      zoo = Zoo.new
+      zoo.date_time = '2000-01-01 00:00:00'
+      zoo.date_time.should == DateTime.new(2000, 1, 1, 0, 0, 0)
     end
 
     it 'should typecast value for a Date property' do
-      property = DataMapper::Property.new(Zoo, :date, Date)
-      property.typecast('2000-01-01').should == Date.new(2000, 1, 1)
+      Zoo.class_eval { property :date, Date }
+      zoo = Zoo.new
+      zoo.date = '2000-01-01'
+      zoo.date.should == Date.new(2000, 1, 1)
     end
 
     it 'should typecast value for a Time property' do
-      property = DataMapper::Property.new(Zoo, :time, Time)
-      property.typecast('2000-01-01 01:01:01.123456').should == Time.local(2000, 1, 1, 1, 1, 1, 123456)
+      Zoo.class_eval { property :time, Time }
+      zoo = Zoo.new
+      zoo.time = '2000-01-01 01:01:01.123456'
+      zoo.time.should == Time.local(2000, 1, 1, 1, 1, 1, 123456)
     end
 
     it 'should typecast Hash for a Time property' do
-      property = DataMapper::Property.new(Zoo, :time, Time)
-      property.typecast(
-        :year => 2002, "month" => 1, :day => 1, "hour" => 12, :min => 0, :sec => 0
-      ).should == Time.local(2002, 1, 1, 12, 0, 0)
+      Zoo.class_eval { property :time, Time }
+      zoo = Zoo.new
+      zoo.time = {:year => 2002, "month" => 1, :day => 1, "hour" => 12, :min => 0, :sec => 0}
+      zoo.time.should == Time.local(2002, 1, 1, 12, 0, 0)
     end
 
     it 'should typecast Hash for a Date property' do
-      property = DataMapper::Property.new(Zoo, :date, Date)
-      property.typecast(:year => 2002, "month" => 1, :day => 1).should == Date.new(2002, 1, 1)
+      Zoo.class_eval { property :date, Date }
+      zoo = Zoo.new
+      zoo.date = {:year => 2002, "month" => 1, :day => 1}
+      zoo.date.should == Date.new(2002, 1, 1)
     end
 
     it 'should typecast Hash for a DateTime property' do
-      property = DataMapper::Property.new(Zoo, :date_time, DateTime)
-      property.typecast(
-        :year => 2002, :month => 1, :day => 1, "hour" => 12, :min => 0, "sec" => 0
-      ).should == DateTime.new(2002, 1, 1, 12, 0, 0)
+      Zoo.class_eval { property :date_time, DateTime }
+      zoo = Zoo.new
+      zoo.date_time = {:year => 2002, :month => 1, :day => 1, "hour" => 12, :min => 0, "sec" => 0}
+      zoo.date_time.should == DateTime.new(2002, 1, 1, 12, 0, 0)
     end
 
     it 'should use now as defaults for missing parts of a Hash to Time typecast' do
       now = Time.now
-      property = DataMapper::Property.new(Zoo, :time, Time)
-      property.typecast(
-        :month => 1, :day => 1
-      ).should == Time.local(now.year, 1, 1, now.hour, now.min, now.sec)
+      Zoo.class_eval { property :time, Time }
+      zoo = Zoo.new
+      zoo.time = {:month => 1, :day => 1}
+      zoo.time.should == Time.local(now.year, 1, 1, now.hour, now.min, now.sec)
     end
 
     it 'should use now as defaults for missing parts of a Hash to Date typecast' do
       now = Time.now
-      property = DataMapper::Property.new(Zoo, :date, Date)
-      property.typecast(
-        :month => 1, :day => 1
-      ).should == Date.new(now.year, 1, 1)
+      Zoo.class_eval { property :date, Date }
+      zoo = Zoo.new
+      zoo.date = {:month => 1, :day => 1}
+      zoo.date.should == Date.new(now.year, 1, 1)
     end
 
     it 'should use now as defaults for missing parts of a Hash to DateTime typecast' do
       now = Time.now
-      property = DataMapper::Property.new(Zoo, :date_time, DateTime)
-      property.typecast(
-        :month => 1, :day => 1
-      ).should == DateTime.new(now.year, 1, 1, now.hour, now.min, now.sec)
+      Zoo.class_eval { property :date_time, DateTime }
+      zoo = Zoo.new
+      zoo.date_time = {:month => 1, :day => 1}
+      zoo.date_time.should == DateTime.new(now.year, 1, 1, now.hour, now.min, now.sec)
     end
 
     it 'should rescue after trying to typecast an invalid Date value from a hash' do
-      property = DataMapper::Property.new(Zoo, :date, Date)
-      property.typecast(:year => 2002, :month => 2, :day => 31).should == Date.new(2002, 3, 3)
+      now = Time.now
+      Zoo.class_eval { property :date, Date }
+      zoo = Zoo.new
+      zoo.date = {:year => 2002, :month => 2, :day => 31}
+      zoo.date.should == Date.new(2002, 3, 3)
     end
 
     it 'should rescue after trying to typecast an invalid DateTime value from a hash' do
-      property = DataMapper::Property.new(Zoo, :date_time, DateTime)
-      property.typecast(
+      now = Time.now
+      Zoo.class_eval { property :date_time, DateTime }
+      zoo = Zoo.new
+      zoo.date_time = {
         :year => 2002, :month => 2, :day => 31, :hour => 12, :min => 0, :sec => 0
-      ).should == DateTime.new(2002, 3, 3, 12, 0, 0)
+      }
+      zoo.date_time.should == DateTime.new(2002, 3, 3, 12, 0, 0)
     end
 
     it 'should typecast value for a Class property' do
-      property = DataMapper::Property.new(Zoo, :class, Class)
-      property.typecast('Zoo').should == Zoo
+      Zoo.class_eval { property :klass, Class }
+      zoo = Zoo.new
+      zoo.klass = "Zoo"
+      zoo.klass.should == Zoo
     end
   end
 
-  it 'should provide #inspect' do
-    DataMapper::Property.new(Zoo, :name, String).should respond_to(:inspect)
-  end
-
   it 'should return an abbreviated representation of the property when inspected' do
-    DataMapper::Property.new(Zoo, :name, String).inspect.should == '#<Property:Zoo:name>'
+    Zoo.class_eval { property :name, String }
+    Zoo.properties[:name].inspect.should == '#<Property:Zoo:name>'
   end
 end