dm-core 1.0.0 → 1.0.1

data/lib/dm-core/property/discriminator.rb

@@ -8,7 +8,7 @@ module DataMapper
 
       # @api private
       def bind
-        model.default_scope(repository_name).update(name => model.descendants)
+        model.default_scope(repository_name).update(name => model.descendants.dup << model)
 
         model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
           extend Chainable
@@ -38,11 +38,11 @@ module DataMapper
             private
 
             def set_discriminator_scope_for(model)
-              model.default_scope(#{repository_name.inspect}).update(#{name.inspect} => model.descendants)
+              model.default_scope(#{repository_name.inspect}).update(#{name.inspect} => model.descendants.dup << model)
             end
           end
         RUBY
       end
     end # class Discriminator
-  end # module Types
+  end # module Property
 end # module DataMapper

data/lib/dm-core/property/lookup.rb

@@ -0,0 +1,42 @@
+module DataMapper
+  class Property
+    module Lookup
+
+      protected
+
+      #
+      # Provides transparent access to the Properties defined in
+      # {Property}. It also provides access to the legacy {Types} namespace.
+      #
+      # @param [Symbol] name
+      #   The name of the property to lookup.
+      #
+      # @return [Property, Type]
+      #   The property with the given name.
+      #
+      # @raise [NameError]
+      #   The property could not be found.
+      #
+      # @api private
+      #
+      # @since 1.0.1
+      #
+      def const_missing(name)
+        if const = Property.find_class(name)
+          return const
+        end
+
+        # only check within DataMapper::Types, if it was loaded.
+        if DataMapper.const_defined?(:Types)
+          if DataMapper::Types.const_defined?(name)
+            type = DataMapper::Types.const_get(name)
+
+            return type if type < DataMapper::Type
+          end
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/dm-core/property/object.rb

@@ -27,6 +27,11 @@ module DataMapper
             value
           end
       end
+
+      # @api private
+      def to_child_key
+        self.class
+      end
     end
   end
 end

data/lib/dm-core/property/serial.rb

@@ -3,6 +3,11 @@ module DataMapper
     class Serial < Integer
       serial    true
       min       1
+
+      # @api private
+      def to_child_key
+        Property::Integer
+      end
     end # class Text
-  end # module Types
+  end # module Property
 end # module DataMapper

data/lib/dm-core/query/conditions/comparison.rb

@@ -160,14 +160,14 @@ module DataMapper
         # @return [Set<AbstractComparison>]
         # @api private
         def self.descendants
-          @descendants ||= Set.new
+          @descendants ||= DescendantSet.new
         end
 
         # Registers AbstractComparison subclasses (used in Comparison)
         #
         # @api private
-        def self.inherited(comparison_class)
-          descendants << comparison_class
+        def self.inherited(descendant)
+          descendants << descendant
         end
 
         # Setter/getter: allows subclasses to easily set their slug

data/lib/dm-core/query/conditions/operation.rb

@@ -97,7 +97,7 @@ module DataMapper
         #
         # @api private
         def self.descendants
-          @descendants ||= Set.new
+          @descendants ||= DescendantSet.new
         end
 
         # Hook executed when inheriting from AbstractComparison
@@ -105,8 +105,8 @@ module DataMapper
         # @return [undefined]
         #
         # @api private
-        def self.inherited(operation_class)
-          descendants << operation_class
+        def self.inherited(descendant)
+          descendants << descendant
         end
 
         # Get and set the slug for the operation class

data/lib/dm-core/resource.rb

@@ -756,8 +756,8 @@ module DataMapper
     #   attribute values used in the new instance
     #
     # @api public
-    def initialize(attributes = {}) # :nodoc:
-      self.attributes = attributes || {}
+    def initialize(attributes = nil) # :nodoc:
+      self.attributes = attributes if attributes
     end
 
     # @api private

data/lib/dm-core/resource/state/dirty.rb

@@ -44,9 +44,9 @@ module DataMapper
             if original_attributes[subject].eql?(value)
               original_attributes.delete(subject)
             end
-          else
+          elsif !value.eql?(original = get(subject))
             # track the original value
-            original_attributes[subject] = get(subject)
+            original_attributes[subject] = original
           end
         end
 

data/lib/dm-core/spec/lib/spec_helper.rb

@@ -14,10 +14,10 @@ module DataMapper
     # global model cleanup
     def self.cleanup_models
       descendants = DataMapper::Model.descendants.to_a
-      while model = descendants.shift
-        descendants.concat(model.descendants.to_a - [ model ])
 
+      while model = descendants.shift
         model_name = model.name.to_s.strip
+
         unless model_name.empty? || model_name[0] == ?#
           parts         = model_name.split('::')
           constant_name = parts.pop.to_sym
@@ -31,6 +31,10 @@ module DataMapper
 
         DataMapper::Model.descendants.delete(model)
       end
+
+      unless DataMapper::Model.descendants.empty?
+        raise 'DataMapper::Model.descendants is not empty'
+      end
     end
 
     def self.remove_ivars(object, instance_variables = object.instance_variables)
@@ -42,7 +46,7 @@ module DataMapper
 
         # skip "global" and non-DM objects
         next if object.kind_of?(DataMapper::Logger)                    ||
-                object.kind_of?(DataMapper::Model::DescendantSet)      ||
+                object.kind_of?(DataMapper::DescendantSet)             ||
                 object.kind_of?(DataMapper::Adapters::AbstractAdapter) ||
                 object.class.name[0, 13] == 'DataObjects::'
 
@@ -55,6 +59,10 @@ module DataMapper
         next unless object.instance_variable_defined?(ivar)
 
         value = object.instance_variable_get(ivar)
+
+        # skip descendant sets
+        next if value.kind_of?(DataMapper::DescendantSet)
+
         object.__send__(:remove_instance_variable, ivar) unless object.frozen?
 
         # skip when the value was seen

data/lib/dm-core/spec/setup.rb

@@ -148,8 +148,8 @@ module DataMapper
       private
 
         def infer_adapter_name
-          demodulized = ActiveSupport::Inflector.demodulize(self.class.name.chomp('Adapter'))
-          ActiveSupport::Inflector.underscore(demodulized).freeze
+          demodulized = DataMapper::Inflector.demodulize(self.class.name.chomp('Adapter'))
+          DataMapper::Inflector.underscore(demodulized).freeze
         end
 
       end

data/{spec/public/shared/property_shared_spec.rb → lib/dm-core/spec/shared/public/property_spec.rb}

@@ -43,17 +43,20 @@ share_examples_for 'A public Property' do
 
         describe "auto-generated option setters" do
           before :all do
-            [@type, @subtype].each do |type|
-              type.foo true
-              type.bar 1
-              @property = type.new(@model, @name)
-            end
+            @type.foo true
+            @type.bar 1
+            @property = @type.new(@model, @name)
           end
 
           it "should set the pre-defined option values" do
             @property.options[:foo].should == true
             @property.options[:bar].should == 1
           end
+
+          it "should ask the superclass for the value if unknown" do
+            @subtype.foo.should == true
+            @subtype.bar.should == 1
+          end
         end
       end
     end
@@ -154,23 +157,51 @@ share_examples_for 'A public Property' do
     end
   end
 
-  [:instance_of?, :kind_of?].each do |method|
-    describe "##{method}" do
-      before :all do
-        @property = @type.new(@model, @name)
-      end
+  describe '#instance_of?' do
+    subject { property.instance_of?(klass) }
 
-      describe "when provided Property" do
-        it "should return true" do
-          @property.send(method, DataMapper::Property).should be(true)
-        end
-      end
+    let(:property) { @type.new(@model, @name) }
 
-      describe "when provided property class" do
-        it "should return true" do
-          @property.send(method, @type).should be(true)
-        end
-      end
+    context 'when provided the property class' do
+      let(:klass) { @type }
+
+      it { should be(true) }
+    end
+
+    context 'when provided the property superclass' do
+      let(:klass) { @type.superclass }
+
+      it { should be(false) }
+    end
+
+    context 'when provided the DataMapper::Property class' do
+      let(:klass) { DataMapper::Property }
+
+      it { should be(false) }
+    end
+  end
+
+  describe '#kind_of?' do
+    subject { property.kind_of?(klass) }
+
+    let(:property) { @type.new(@model, @name) }
+
+    context 'when provided the property class' do
+      let(:klass) { @type }
+
+      it { should be(true) }
+    end
+
+    context 'when provided the property superclass' do
+      let(:klass) { @type.superclass }
+
+      it { should be(true) }
+    end
+
+    context 'when provided the DataMapper::Property class' do
+      let(:klass) { DataMapper::Property }
+
+      it { should be(true) }
     end
   end
 end

data/{spec/semipublic/shared/property_shared_spec.rb → lib/dm-core/spec/shared/semipublic/property_spec.rb}

@@ -88,6 +88,28 @@ share_examples_for 'A semipublic Property' do
     end
   end
 
+  describe "#typecast" do
+    describe "when is able to do typecasting on it's own" do
+      it 'delegates all the work to the type' do
+        return_value = mock(@other_value)
+        @property.should_receive(:typecast_to_primitive).with(@invalid_value).and_return(return_value)
+        @property.typecast(@invalid_value)
+      end
+    end
+
+    describe 'when value is nil' do
+      it 'returns value unchanged' do
+        @property.typecast(nil).should be(nil)
+      end
+
+      describe 'when value is a Ruby primitive' do
+        it 'returns value unchanged' do
+          @property.typecast(@value).should == @value
+        end
+      end
+    end
+  end
+
   describe '#valid?' do
     describe 'when provided a valid value' do
       it 'should return true' do
@@ -115,30 +137,4 @@ share_examples_for 'A semipublic Property' do
       end
     end
   end
-
-  describe "#typecast" do
-    describe "when is able to do typecasting on it's own" do
-      it 'delegates all the work to the type' do
-        return_value = mock(@other_value)
-        @property.should_receive(:typecast_to_primitive).with(@invalid_value).and_return(return_value)
-        @property.typecast(@invalid_value)
-      end
-    end
-
-    describe 'when value is nil' do
-      it 'returns value unchanged' do
-        @property.typecast(nil).should be(nil)
-      end
-
-      describe 'when value is a Ruby primitive' do
-        it 'returns value unchanged' do
-          @property.typecast(@value).should == @value
-        end
-    end
-    end
-  end
-
-  describe '#value' do
-    it 'returns value for a core type'
-  end
 end

data/lib/dm-core/support/descendant_set.rb

@@ -0,0 +1,84 @@
+module DataMapper
+  class DescendantSet
+    include Enumerable
+
+    # Initialize a DescendantSet instance
+    #
+    # @param [#to_ary] descendants
+    #   initialize with the descendants
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(descendants = [])
+      @descendants = descendants.to_ary
+    end
+
+    # Copy a DescendantSet instance
+    #
+    # @param [DescendantSet] original
+    #   the original descendants
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize_copy(original)
+      @descendants = @descendants.dup
+    end
+
+    # Add a descendant
+    #
+    # @param [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def <<(descendant)
+      @descendants << descendant
+      self
+    end
+
+    # Remove a descendant
+    #
+    # Also removes from all descendants
+    #
+    # @param [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def delete(descendant)
+      @descendants.delete(descendant)
+      each { |d| d.descendants.delete(descendant) }
+    end
+
+    # Iterate over each descendant
+    #
+    # @yield [descendant]
+    # @yieldparam [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def each
+      @descendants.each do |descendant|
+        yield descendant
+        descendant.descendants.each { |dd| yield dd }
+      end
+      self
+    end
+
+    # Test if there are any descendants
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def empty?
+      @descendants.empty?
+    end
+
+  end # class DescendantSet
+end # module DataMapper