dm-core 1.0.2 → 1.1.0.rc1

data/lib/dm-core.rb

@@ -81,13 +81,6 @@ require 'dm-core/support/subject'
 
 require 'dm-core/collection'
 
-require 'dm-core/type'
-require 'dm-core/types/boolean'
-require 'dm-core/types/discriminator'
-require 'dm-core/types/text'
-require 'dm-core/types/object'
-require 'dm-core/types/serial'
-
 require 'dm-core/property'
 require 'dm-core/property/object'
 require 'dm-core/property/string'
@@ -321,11 +314,12 @@ module DataMapper
   end
 
   private
+
   # @api private
   def self.finalize_model(model)
     name            = model.name
     repository_name = model.repository_name
-    relationships   = model.relationships(repository_name).values
+    relationships   = model.relationships(repository_name)
 
     if name.to_s.strip.empty?
       raise IncompleteModelError, "#{model.inspect} must have a name"
@@ -336,15 +330,31 @@ module DataMapper
       raise IncompleteModelError, "#{name} must have at least one property or many to one relationship to be valid"
     end
 
-    # initialize join models and target keys
+    # Initialize all foreign key properties established by relationships
     relationships.each do |relationship|
-      relationship.child_key
-      relationship.through if relationship.respond_to?(:through)
-      relationship.via     if relationship.respond_to?(:via)
+      if relationship.kind_of?(Associations::ManyToOne::Relationship)
+        # Initialize the foreign key property this "many to one"
+        # relationship uses to persist itself
+        relationship.child_key
+      elsif relationship.kind_of?(Associations::ManyToMany::Relationship)
+        # Initialize the chain for "many to many" relationships
+        relationship.through
+        relationship.via
+      else
+        # If this is a "one to one" or "one to many" relationship, initialize
+        # the inverse "many to one" relationships explicitly before initializing
+        # other relationships. This makes sure that foreign key properties always
+        # appear in the order they were declared.
+        relationship.child_model.relationships.each do |remote_relationship|
+          if remote_relationship.kind_of?(Associations::ManyToOne::Relationship)
+            remote_relationship.child_key
+          end
+        end
+      end
     end
 
     if model.key(repository_name).empty?
       raise IncompleteModelError, "#{name} must have a key to be valid"
     end
   end
-end
+end # module DataMapper

data/lib/dm-core/adapters/abstract_adapter.rb

@@ -178,7 +178,7 @@ module DataMapper
       #
       # @param [Resource] resource
       #   the resource to set the serial property in
-      # @param [Integer] id
+      # @param [Integer] next_id
       #   the identifier to set in the resource
       #
       # @return [undefined]

data/lib/dm-core/associations/many_to_many.rb

@@ -161,7 +161,7 @@ module DataMapper
           if namespace.const_defined?(name)
             namespace.const_get(name)
           else
-            model = Model.new do
+            Model.new(name, namespace) do
               # all properties added to the anonymous through model are keys
               def property(name, type, options = {})
                 options[:key] = true
@@ -169,8 +169,6 @@ module DataMapper
                 super
               end
             end
-
-            namespace.const_set(name, model)
           end
         end
 

data/lib/dm-core/associations/many_to_one.rb

@@ -31,36 +31,34 @@ module DataMapper
           @key
         end
 
-        # @api private
+        # @deprecated
         def nullable?
-          klass = self.class
-          warn "#{klass}#nullable? is deprecated, use #{klass}#required? instead (#{caller[0]})"
-          !required?
+          raise "#{self.class}#nullable? is deprecated, use #{self.class}#required? instead (#{caller.first})"
         end
 
-        # Returns a set of keys that identify child model
+        # Returns a set of keys that identify source model
         #
-        # @return   [DataMapper::PropertySet]  a set of properties that identify child model
+        # @return   [DataMapper::PropertySet]  a set of properties that identify source model
         # @api private
         def child_key
           return @child_key if defined?(@child_key)
 
-          model           = child_model
-          repository_name = child_repository_name || parent_repository_name
+          model           = source_model
+          repository_name = source_repository_name || target_repository_name
           properties      = model.properties(repository_name)
 
-          child_key = parent_key.zip(@child_properties || []).map do |parent_property, property_name|
-            property_name ||= "#{name}_#{parent_property.name}".to_sym
+          source_key = target_key.zip(@child_properties || []).map do |target_property, property_name|
+            property_name ||= "#{name}_#{target_property.name}".to_sym
 
             properties[property_name] || begin
               # create the property within the correct repository
               DataMapper.repository(repository_name) do
-                model.property(property_name, parent_property.to_child_key, child_key_options(parent_property))
+                model.property(property_name, target_property.to_child_key, source_key_options(target_property))
               end
             end
           end
 
-          @child_key = properties.class.new(child_key).freeze
+          @child_key = properties.class.new(source_key).freeze
         end
 
         # @api semipublic
@@ -95,17 +93,25 @@ module DataMapper
         def resource_for(source, other_query = nil)
           query = query_for(source, other_query)
 
-          # TODO: lookup the resource in the Identity Map, and make sure
-          # it matches the query criteria, otherwise perform the query
-
-          target_model.first(query)
+          # If the target key is equal to the model key, we can use the
+          # Model#get so the IdentityMap is used
+          if target_key == target_model.key
+            target = target_model.get(*source_key.get!(source))
+            if query.conditions.matches?(target)
+              target
+            else
+              nil
+            end
+          else
+            target_model.first(query)
+          end
         end
 
         # Loads and returns association target (ex.: author) for given source resource
         # (ex.: article)
         #
         # @param  source  [DataMapper::Resource]
-        #   Child object (ex.: instance of article)
+        #   source object (ex.: instance of article)
         # @param  other_query  [DataMapper::Query]
         #   Query options
         #
@@ -117,18 +123,18 @@ module DataMapper
         end
 
         def get_collection(source)
-          resource = get!(source)
-          resource.collection_for_self if resource
+          target = get!(source)
+          target.collection_for_self if target
         end
 
         # Sets value of association target (ex.: author) for given source resource
         # (ex.: article)
         #
         # @param source [DataMapper::Resource]
-        #   Child object (ex.: instance of article)
+        #   source object (ex.: instance of article)
         #
-        # @param source [DataMapper::Resource]
-        #   Parent object (ex.: instance of author)
+        # @param target [DataMapper::Resource]
+        #   target object (ex.: instance of author)
         #
         # @api semipublic
         def set(source, target)
@@ -152,16 +158,21 @@ module DataMapper
         #
         # @api private
         def lazy_load(source)
-          return if loaded?(source) || !valid_source?(source)
+          source_key_different = source_key_different?(source)
+
+          if (loaded?(source) && !source_key_different) || !valid_source?(source)
+            return
+          end
 
           # SEL: load all related resources in the source collection
-          collection = source.collection
-          if source.saved? && collection.size > 1
+          if source.saved? && (collection = source.collection).size > 1
             eager_load(collection)
           end
 
-          unless loaded?(source)
+          if !loaded?(source) || (source_key_dirty?(source) && source.saved?)
             set!(source, resource_for(source))
+          elsif loaded?(source) && source_key_different
+            source_key.set(source, target_key.get!(get!(source)))
           end
         end
 
@@ -172,10 +183,7 @@ module DataMapper
         # @api semipublic
         def initialize(name, source_model, target_model, options = {})
           if options.key?(:nullable)
-            nullable_options = options.only(:nullable)
-            required_options = { :required => !options.delete(:nullable) }
-            warn "#{nullable_options.inspect} is deprecated, use #{required_options.inspect} instead (#{caller[2]})"
-            options.update(required_options)
+            raise ":nullable is deprecated, use :required instead (#{caller[2]})"
           end
 
           @required      = options.fetch(:required, true)
@@ -225,16 +233,16 @@ module DataMapper
         end
 
         # @api private
-        def child_key_options(parent_property)
-          options = parent_property.options.only(:length, :precision, :scale).update(
+        def source_key_options(target_property)
+          options = target_property.options.only(:length, :precision, :scale).update(
             :index    => name,
             :required => required?,
             :key      => key?
           )
 
-          if parent_property.primitive == Integer
-            min = parent_property.min
-            max = parent_property.max
+          if target_property.primitive == Integer
+            min = target_property.min
+            max = target_property.max
 
             options.update(:min => min, :max => max) if min && max
           end
@@ -244,7 +252,17 @@ module DataMapper
 
         # @api private
         def child_properties
-          child_key.map { |property| property.name }
+          source_key.map { |property| property.name }
+        end
+
+        # @api private
+        def source_key_different?(source)
+          source_key.get!(source) != target_key.get!(get!(source))
+        end
+
+        # @api private
+        def source_key_dirty?(source)
+          source.dirty_attributes.keys.any? { |property| source_key.include?(property) }
         end
       end # class Relationship
     end # module ManyToOne

data/lib/dm-core/associations/one_to_many.rb

@@ -91,8 +91,7 @@ module DataMapper
           return if loaded?(source)
 
           # SEL: load all related resources in the source collection
-          collection = source.collection
-          if source.saved? && collection.size > 1
+          if source.saved? && (collection = source.collection).size > 1
             eager_load(collection)
           end
 

data/lib/dm-core/associations/relationship.rb

@@ -388,7 +388,7 @@ module DataMapper
           return @inverse
         end
 
-        relationships = target_model.relationships(relative_target_repository_name).values
+        relationships = target_model.relationships(relative_target_repository_name)
 
         @inverse = relationships.detect { |relationship| inverse?(relationship) } ||
           invert
@@ -414,7 +414,16 @@ module DataMapper
 
       # @api private
       def hash
-        source_model.hash ^ name.hash
+        name.hash                   ^
+        child_repository_name.hash  ^
+        parent_repository_name.hash ^
+        child_model.hash            ^
+        parent_model.hash           ^
+        child_properties.hash       ^
+        parent_properties.hash      ^
+        min.hash                    ^
+        max.hash                    ^
+        query.hash
       end
 
       private

data/lib/dm-core/collection.rb

@@ -17,10 +17,6 @@ module DataMapper
   # A Collection is typically returned by the Model#all
   # method.
   class Collection < LazyArray
-    extend Deprecate
-
-    deprecate :add,   :<<
-    deprecate :build, :new
 
     # Returns the Query the Collection is scoped with
     #
@@ -170,7 +166,7 @@ module DataMapper
         @identity_map[key]
       else
         # current query is all inclusive, lookup using normal approach
-        first(model.key_conditions(repository, key))
+        first(model.key_conditions(repository, key).update(:order => nil))
       end
     end
 
@@ -941,7 +937,7 @@ module DataMapper
     #
     # @api public
     def respond_to?(method, include_private = false)
-      super || model.respond_to?(method) || relationships.key?(method)
+      super || model.respond_to?(method) || relationships.named?(method)
     end
 
     # Checks if all the resources have no changes to save
@@ -1265,7 +1261,7 @@ module DataMapper
           subject = condition.subject
           next unless model_properties.include?(subject) || (condition.relationship? && subject.source_model == model)
 
-          default_attributes[subject] = condition.value
+          default_attributes[subject] = condition.loaded_value
         end
       end
 

data/lib/dm-core/core_ext/symbol.rb

@@ -2,7 +2,7 @@ class Symbol
   (DataMapper::Query::Conditions::Comparison.slugs | [ :not, :asc, :desc ]).each do |sym|
     class_eval <<-RUBY, __FILE__, __LINE__ + 1
       def #{sym}
-        #{"warn \"explicit use of '#{sym}' operator is deprecated (#{caller[0]})\"" if sym == :eql || sym == :in}
+        #{"raise \"explicit use of '#{sym}' operator is deprecated (#{caller.first})\"" if sym == :eql || sym == :in}
         DataMapper::Query::Operator.new(self, #{sym.inspect})
       end
     RUBY

data/lib/dm-core/identity_map.rb

@@ -3,10 +3,5 @@ module DataMapper
   # Tracks objects to help ensure that each object gets loaded only once.
   # See: http://www.martinfowler.com/eaaCatalog/identityMap.html
   class IdentityMap < Hash
-    extend Deprecate
-
-    deprecate :get, :[]
-    deprecate :set, :[]=
-
   end # class IdentityMap
 end # module DataMapper

data/lib/dm-core/model.rb

@@ -9,37 +9,28 @@ module DataMapper
 
     include Enumerable
 
-    # Creates a new Model class with default_storage_name +storage_name+
+    # Creates a new Model class with its constant already set
     #
     # If a block is passed, it will be eval'd in the context of the new Model
     #
+    # @param [#to_s] name
+    #   the name of the new model
+    # @param [Object] namespace
+    #   the namespace that will hold the new model
     # @param [Proc] block
     #   a block that will be eval'd in the context of the new Model class
     #
     # @return [Model]
     #   the newly created Model class
     #
-    # @api semipublic
-    def self.new(storage_name = nil, &block)
-      model = Class.new
+    # @api private
+    def self.new(name = nil, namespace = Object, &block)
+      model = name ? namespace.const_set(name, Class.new) : Class.new
 
       model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
         include DataMapper::Resource
-
-        def self.name
-          to_s
-        end
       RUBY
 
-      if storage_name
-        warn "Passing in +storage_name+ to #{name}.new is deprecated (#{caller[0]})"
-        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def self.default_storage_name
-            #{DataMapper::Inflector.classify(storage_name).inspect}.freeze
-          end
-        RUBY
-      end
-
       model.instance_eval(&block) if block
       model
     end
@@ -275,7 +266,7 @@ module DataMapper
       repository = self.repository
       key        = self.key(repository.name).typecast(key)
 
-      repository.identity_map(self)[key] || first(key_conditions(repository, key))
+      repository.identity_map(self)[key] || first(key_conditions(repository, key).update(:order => nil))
     end
 
     # Grab a single record just like #get, but raise an ObjectNotFoundError
@@ -716,8 +707,7 @@ module DataMapper
     # @api private
     def const_missing(name)
       if name == :DM
-        warn "#{name} prefix deprecated and no longer necessary (#{caller[0]})"
-        self
+        raise "#{name} prefix deprecated and no longer necessary (#{caller.first})"
       elsif name == :Resource
         Resource
       else
@@ -789,7 +779,7 @@ module DataMapper
 
       # initialize join models and target keys
       @relationships.values.each do |relationships|
-        relationships.values.each do |relationship|
+        relationships.each do |relationship|
           relationship.child_key
           relationship.through if relationship.respond_to?(:through)
           relationship.via     if relationship.respond_to?(:via)

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

@@ -1,6 +1,3 @@
-# TODO: move paranoid property concerns to a ParanoidModel that is mixed
-# into Model when a Paranoid property is used
-
 # TODO: update Model#respond_to? to return true if method_method missing
 # would handle the message
 
@@ -14,18 +11,16 @@ module DataMapper
       def self.extended(model)
         model.instance_variable_set(:@properties,               {})
         model.instance_variable_set(:@field_naming_conventions, {})
-        model.instance_variable_set(:@paranoid_properties,      {})
       end
 
       chainable do
         def inherited(model)
           model.instance_variable_set(:@properties,               {})
           model.instance_variable_set(:@field_naming_conventions, @field_naming_conventions.dup)
-          model.instance_variable_set(:@paranoid_properties,      @paranoid_properties.dup)
 
           @properties.each do |repository_name, properties|
             model_properties = model.properties(repository_name)
-            properties.each { |property| model_properties[property.name] ||= property }
+            properties.each { |property| model_properties << property }
           end
 
           super
@@ -36,8 +31,8 @@ module DataMapper
       #
       # @param [Symbol] name
       #   the name for which to call this property
-      # @param [Type] type
-      #   the type to define this property ass
+      # @param [Class] type
+      #   the ruby type to define this property as
       # @param [Hash(Symbol => String)] options
       #   a hash of available options
       #
@@ -48,25 +43,19 @@ module DataMapper
       #
       # @api public
       def property(name, type, options = {})
-        caller_method = caller[2]
-
         if TrueClass == type
-          warn "#{type} is deprecated, use Boolean instead at #{caller_method}"
-          type = DataMapper::Property::Boolean
+          raise "#{type} is deprecated, use Boolean instead at #{caller[2]}"
         elsif BigDecimal == type
-          warn "#{type} is deprecated, use Decimal instead at #{caller_method}"
-          type = DataMapper::Property::Decimal
+          raise "#{type} is deprecated, use Decimal instead at #{caller[2]}"
         end
 
         # if the type can be found within Property then
         # use that class rather than the primitive
-        klass = DataMapper::Property.determine_class(type)
-
-        unless klass
+        unless klass = DataMapper::Property.determine_class(type)
           raise ArgumentError, "+type+ was #{type.inspect}, which is not a supported type"
         end
 
-        property = klass.new(self, name, options, type < DataMapper::Type ? type : nil)
+        property = klass.new(self, name, options)
 
         repository_name = self.repository_name
         properties      = properties(repository_name)
@@ -76,11 +65,11 @@ module DataMapper
         # Add property to the other mappings as well if this is for the default
         # repository.
         if repository_name == default_repository_name
-          @properties.except(repository_name).each do |repository_name, properties|
+          @properties.except(default_repository_name).each do |other_repository_name, properties|
             next if properties.named?(name)
 
             # make sure the property is created within the correct repository scope
-            DataMapper.repository(repository_name) do
+            DataMapper.repository(other_repository_name) do
               properties << klass.new(self, name, options, type)
             end
           end
@@ -95,7 +84,7 @@ module DataMapper
           context = :default if context == true
 
           Array(context).each do |context|
-            properties.lazy_context(context) << self
+            properties.lazy_context(context) << property
           end
         end
 
@@ -103,7 +92,7 @@ module DataMapper
         # added after the child classes' properties have been copied from
         # the parent
         descendants.each do |descendant|
-          descendant.properties(repository_name)[name] ||= property
+          descendant.properties(repository_name) << property
         end
 
         create_reader_for(property)
@@ -120,7 +109,7 @@ module DataMapper
       #   The name of the repository to use. Uses the default Repository
       #   if none is specified.
       #
-      # @return [Array]
+      # @return [PropertySet]
       #   A list of Properties defined on this Model in the given Repository
       #
       # @api public
@@ -177,23 +166,13 @@ module DataMapper
 
         descendants.each do |model|
           model.properties(repository_name).each do |property|
-            properties[property.name] ||= property
+            properties << property
           end
         end
 
         properties
       end
 
-      # @api private
-      def paranoid_properties
-        @paranoid_properties
-      end
-
-      # @api private
-      def set_paranoid_property(name, &block)
-        paranoid_properties[name] = block
-      end
-
       # @api private
       def key_conditions(repository, key)
         self.key(repository.name).zip(key.nil? ? [] : key).to_hash
@@ -201,6 +180,20 @@ module DataMapper
 
       private
 
+      # Defines the anonymous module that is used to add properties.
+      # Using a single module here prevents having a very large number
+      # of anonymous modules, where each property has their own module.
+      # @api private
+      def property_module
+        @property_module ||= begin
+          mod = Module.new
+          class_eval do
+            include mod
+          end
+          mod
+        end
+      end
+
       # defines the reader method for the property
       #
       # @api private
@@ -208,27 +201,22 @@ module DataMapper
         name                   = property.name.to_s
         reader_visibility      = property.reader_visibility
         instance_variable_name = property.instance_variable_name
-
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          chainable do
-            #{reader_visibility}
-            def #{name}
-              return #{instance_variable_name} if defined?(#{instance_variable_name})
-              property = properties[#{name.inspect}]
-              #{instance_variable_name} = property ? persisted_state.get(property) : nil
-            end
+        property_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          #{reader_visibility}
+          def #{name}
+            return #{instance_variable_name} if defined?(#{instance_variable_name})
+            property = properties[#{name.inspect}]
+            #{instance_variable_name} = property ? persisted_state.get(property) : nil
           end
         RUBY
 
         boolean_reader_name = "#{name}?"
 
         if property.kind_of?(DataMapper::Property::Boolean)
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            chainable do
-              #{reader_visibility}
-              def #{boolean_reader_name}
-                #{name}
-              end
+          property_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            #{reader_visibility}
+            def #{boolean_reader_name}
+              #{name}
             end
           RUBY
         end
@@ -242,15 +230,12 @@ module DataMapper
         writer_visibility = property.writer_visibility
 
         writer_name = "#{name}="
-
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          chainable do
-            #{writer_visibility}
-            def #{writer_name}(value)
-              property = properties[#{name.inspect}]
-              self.persisted_state = persisted_state.set(property, value)
-              persisted_state.get(property)
-            end
+        property_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          #{writer_visibility}
+          def #{writer_name}(value)
+            property = properties[#{name.inspect}]
+            self.persisted_state = persisted_state.set(property, value)
+            persisted_state.get(property)
           end
         RUBY
       end