dm-core 0.9.2 → 0.9.3

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

@@ -1,4 +1,4 @@
-gem 'do_mysql', '=0.9.2'
+gem 'do_mysql', '=0.9.3'
 require 'do_mysql'
 
 module DataMapper

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

@@ -1,4 +1,4 @@
-gem 'do_postgres', '=0.9.2'
+gem 'do_postgres', '=0.9.3'
 require 'do_postgres'
 
 module DataMapper

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

@@ -1,4 +1,4 @@
-gem 'do_sqlite3', '=0.9.2'
+gem 'do_sqlite3', '=0.9.3'
 require 'do_sqlite3'
 
 module DataMapper
@@ -41,7 +41,7 @@ module DataMapper
         end
 
         module SQL
-          private
+#          private  ## This cannot be private for current migrations
 
           # TODO: move to dm-more/dm-migrations
           def supports_serial?

data/lib/dm-core/associations.rb

@@ -17,6 +17,32 @@ module DataMapper
     class UnsavedParentError < RuntimeError
     end
 
+    # Returns all relationships that are many-to-one for this model.
+    #
+    # Used to find the relationships that require properties in any Repository.
+    #
+    # Example:
+    # class Plur
+    #   include DataMapper::Resource
+    #   def self.default_repository_name
+    #     :plur_db
+    #   end
+    #   repository(:plupp_db) do
+    #     has 1, :plupp
+    #   end
+    # end
+    #
+    # This resource has a many-to-one to the Plupp resource residing in the :plupp_db repository,
+    # but the Plur resource needs the plupp_id property no matter what repository itself lives in,
+    # ie we need to create that property when we migrate etc.
+    #
+    # Used in DataMapper::Model.properties_with_subclasses
+    #
+    # @api private
+    def many_to_one_relationships
+      @relationships.values.collect do |rels| rels.values end.flatten.select do |relationship| relationship.child_model == self end
+    end
+
     def relationships(repository_name = default_repository_name)
       @relationships ||= Hash.new { |h,k| h[k] = k == Repository.default_name ? {} : h[Repository.default_name].dup }
       @relationships[repository_name]

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

@@ -28,7 +28,7 @@ module DataMapper
           def #{name}_association
             @#{name}_association ||= begin
               unless relationship = model.relationships(#{repository_name.inspect})[#{name.inspect}]
-                raise ArgumentError, 'Relationship #{name.inspect} does not exist'
+                raise ArgumentError, "Relationship #{name.inspect} does not exist in \#{model}"
               end
               association = Proxy.new(relationship, self)
               parent_associations << association
@@ -40,14 +40,14 @@ module DataMapper
         opts = options.dup
         opts.delete(:through)
         opts[:child_model]              ||= opts.delete(:class_name)  || Extlib::Inflection.classify(name)
-        opts[:parent_model]             =   model.name
+        opts[:parent_model]             =   model
         opts[:repository_name]          =   repository_name
         opts[:remote_relationship_name] ||= opts.delete(:remote_name) || name
         opts[:parent_key]               =   opts[:parent_key]
         opts[:child_key]                =   opts[:child_key]
         opts[:mutable]                  =   true
 
-        names        = [ opts[:child_model], opts[:parent_model] ].sort
+        names        = [ opts[:child_model], opts[:parent_model].name ].sort
         model_name   = names.join
         storage_name = Extlib::Inflection.tableize(Extlib::Inflection.pluralize(names[0]) + names[1])
 
@@ -77,39 +77,50 @@ module DataMapper
       end
 
       class Proxy < DataMapper::Associations::OneToMany::Proxy
-
-        def <<(resource)
-          resource.save if resource.new_record?
-          through = @relationship.child_model.new
-          @relationship.child_key.each_with_index do |key, index|
-            through.send("#{key.name}=", @relationship.parent_key.key[index].get(@parent))
-          end
-          remote_relationship.child_key.each_with_index do |key, index|
-            through.send("#{key.name}=", remote_relationship.parent_key.key[index].get(resource))
-          end
-          near_model << through
-          super
-        end
-
         def delete(resource)
-          through = near_model.get(*(@parent.key + resource.key))
-          near_model.delete(through)
+          through = near_association.get(*(@parent.key + resource.key))
+          near_association.delete(through)
           orphan_resource(super)
         end
 
         def clear
-          near_model.clear
+          near_association.clear
           super
         end
 
         def destroy
-          near_model.destroy
+          near_association.destroy
           super
         end
 
         def save
         end
 
+        private
+
+        def new_child(attributes)
+          remote_relationship.parent_model.new(attributes)
+        end
+
+        def relate_resource(resource)
+          assert_mutable
+          add_default_association_values(resource)
+          @orphans.delete(resource)
+
+          # TODO: fix this so it does not automatically save on append, if possible
+          resource.save if resource.new_record?
+          through_resource = @relationship.child_model.new
+          @relationship.child_key.zip(@relationship.parent_key) do |child_key,parent_key|
+            through_resource.send("#{child_key.name}=", parent_key.get(@parent))
+          end
+          remote_relationship.child_key.zip(remote_relationship.parent_key) do |child_key,parent_key|
+            through_resource.send("#{child_key.name}=", parent_key.get(resource))
+          end
+          near_association << through_resource
+
+          resource
+        end
+
         def orphan_resource(resource)
           assert_mutable
           @orphans << resource
@@ -119,14 +130,12 @@ module DataMapper
         def assert_mutable
         end
 
-        private
-
         def remote_relationship
           @remote_relationship ||= @relationship.send(:remote_relationship)
         end
 
-        def near_model
-          @near_model ||= @parent.send(near_relationship_name)
+        def near_association
+          @near_association ||= @parent.send(near_relationship_name)
         end
 
         def near_relationship_name

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

@@ -27,7 +27,7 @@ module DataMapper
           def #{name}_association
             @#{name}_association ||= begin
               unless relationship = model.relationships(#{repository_name.inspect})[:#{name}]
-                raise ArgumentError, 'Relationship #{name.inspect} does not exist'
+                raise ArgumentError, "Relationship #{name.inspect} does not exist in \#{model}"
               end
               association = Proxy.new(relationship, self)
               child_associations << association
@@ -39,7 +39,7 @@ module DataMapper
         model.relationships(repository_name)[name] = Relationship.new(
           name,
           repository_name,
-          model.name,
+          model,
           options.fetch(:class_name, Extlib::Inflection.classify(name)),
           options
         )
@@ -48,7 +48,7 @@ module DataMapper
       class Proxy
         include Assertions
 
-        instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ class kind_of? respond_to? assert_kind_of should should_not ].include?(m) }
+        instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ class kind_of? respond_to? assert_kind_of should should_not instance_variable_set instance_variable_get ].include?(m) }
 
         def replace(parent)
           @parent = parent
@@ -60,7 +60,7 @@ module DataMapper
           return false if @parent.nil?
           return true  unless parent.new_record?
 
-          DataMapper.repository(@relationship.repository_name) do
+          @relationship.with_repository(parent) do
             parent.save
           end
         end

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

@@ -1,5 +1,3 @@
-require 'forwardable'
-
 module DataMapper
   module Associations
     module OneToMany
@@ -29,7 +27,7 @@ module DataMapper
           def #{name}_association
             @#{name}_association ||= begin
               unless relationship = model.relationships(#{repository_name.inspect})[#{name.inspect}]
-                raise ArgumentError, 'Relationship #{name.inspect} does not exist'
+                raise ArgumentError, "Relationship #{name.inspect} does not exist in \#{model}"
               end
               association = Proxy.new(relationship, self)
               parent_associations << association
@@ -41,8 +39,14 @@ module DataMapper
         model.relationships(repository_name)[name] = if options.has_key?(:through)
           opts = options.dup
 
+          if opts.key?(:class_name) && !opts.key?(:child_key)
+            warn(<<-EOS.margin)
+              You have specified #{model.base_model.name}.has(#{name.inspect}) with :class_name => #{opts[:class_name].inspect}. You probably also want to specify the :child_key option.
+            EOS
+          end
+
           opts[:child_model]            ||= opts.delete(:class_name)  || Extlib::Inflection.classify(name)
-          opts[:parent_model]             =   model.name
+          opts[:parent_model]             =   model
           opts[:repository_name]          =   repository_name
           opts[:near_relationship_name]   =   opts.delete(:through)
           opts[:remote_relationship_name] ||= opts.delete(:remote_name) || name
@@ -52,10 +56,10 @@ module DataMapper
           RelationshipChain.new( opts )
         else
           Relationship.new(
-            Extlib::Inflection.underscore(Extlib::Inflection.demodulize(model.name)).to_sym,
+            name,
             repository_name,
             options.fetch(:class_name, Extlib::Inflection.classify(name)),
-            model.name,
+            model,
             options
           )
         end
@@ -68,7 +72,7 @@ module DataMapper
       class Proxy
         include Assertions
 
-        instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ class kind_of? respond_to? assert_kind_of should should_not ].include?(m) }
+        instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ class kind_of? respond_to? assert_kind_of should should_not instance_variable_set instance_variable_get ].include?(m) }
 
         # FIXME: remove when RelationshipChain#get_children can return a Collection
         def all(query = {})
@@ -87,6 +91,7 @@ module DataMapper
 
         def <<(resource)
           assert_mutable
+          return self if !resource.new_record? && self.include?(resource)
           super
           relate_resource(resource)
           self
@@ -94,6 +99,7 @@ module DataMapper
 
         def push(*resources)
           assert_mutable
+          resources.reject { |resource| !resource.new_record? && self.include?(resource) }
           super
           resources.each { |resource| relate_resource(resource) }
           self
@@ -101,6 +107,7 @@ module DataMapper
 
         def unshift(*resources)
           assert_mutable
+          resources.reject { |resource| !resource.new_record? && self.include?(resource) }
           super
           resources.each { |resource| relate_resource(resource) }
           self
@@ -109,7 +116,7 @@ module DataMapper
         def replace(other)
           assert_mutable
           each { |resource| orphan_resource(resource) }
-          other = other.map { |resource| Hash === resource ? @relationship.child_model.new(resource) : resource }
+          other = other.map { |resource| resource.kind_of?(Hash) ? new_child(resource) : resource }
           super
           other.each { |resource| relate_resource(resource) }
           self
@@ -142,10 +149,21 @@ module DataMapper
           self
         end
 
+        def build(attributes = {})
+          assert_mutable
+          attributes = default_attributes.merge(attributes)
+          resource = children.respond_to?(:build) ? super(attributes) : new_child(attributes)
+          self << resource
+          resource
+        end
+
         def create(attributes = {})
           assert_mutable
           raise UnsavedParentError, 'You cannot create until the parent is saved' if @parent.new_record?
-          super
+          attributes = default_attributes.merge(attributes)
+          resource = children.respond_to?(:create) ? super(attributes) : @relationship.child_model.create(attributes)
+          self << resource
+          resource
         end
 
         def update(attributes = {})
@@ -229,15 +247,32 @@ module DataMapper
           raise ImmutableAssociationError, 'You can not modify this assocation' if children.frozen?
         end
 
-        def add_default_association_values(resource)
-          return if respond_to?(:default_attributes)
+        def default_attributes
+          default_attributes = {}
 
           @relationship.query.each do |attribute, value|
-            next if Query::OPTIONS.include?(attribute) || attribute.kind_of?(Query::Operator) || resource.attribute_loaded?(attribute)
+            next if Query::OPTIONS.include?(attribute) || attribute.kind_of?(Query::Operator)
+            default_attributes[attribute] = value
+          end
+
+          @relationship.child_key.zip(@relationship.parent_key.get(@parent)) do |property,value|
+            default_attributes[property.name] = value
+          end
+
+          default_attributes
+        end
+
+        def add_default_association_values(resource)
+          default_attributes.each do |attribute, value|
+            next if !resource.respond_to?("#{attribute}=") || resource.attribute_loaded?(attribute)
             resource.send("#{attribute}=", value)
           end
         end
 
+        def new_child(attributes)
+          @relationship.child_model.new(default_attributes.merge(attributes))
+        end
+
         def relate_resource(resource)
           assert_mutable
           add_default_association_values(resource)
@@ -252,7 +287,7 @@ module DataMapper
         end
 
         def save_resource(resource, parent = @parent)
-          DataMapper.repository(@relationship.repository_name) do
+          @relationship.with_repository(resource) do |r|
             if parent.nil? && resource.model.respond_to?(:many_to_many)
               resource.destroy
             else

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

@@ -27,7 +27,7 @@ module DataMapper
           def #{name}_association
             @#{name}_association ||= begin
               unless relationship = model.relationships(#{repository_name.inspect})[:#{name}]
-                raise ArgumentError, 'Relationship #{name.inspect} does not exist'
+                raise ArgumentError, "Relationship #{name.inspect} does not exist in \#{model}"
               end
               association = Associations::OneToMany::Proxy.new(relationship, self)
               parent_associations << association
@@ -39,7 +39,7 @@ module DataMapper
         model.relationships(repository_name)[name] = if options.has_key?(:through)
           RelationshipChain.new(
             :child_model              => options.fetch(:class_name, Extlib::Inflection.classify(name)),
-            :parent_model             => model.name,
+            :parent_model             => model,
             :repository_name          => repository_name,
             :near_relationship_name   => options[:through],
             :remote_relationship_name => options.fetch(:remote_name, name),
@@ -48,10 +48,10 @@ module DataMapper
           )
         else
           Relationship.new(
-            Extlib::Inflection.underscore(Extlib::Inflection.demodulize(model.name)).to_sym,
+            name,
             repository_name,
             options.fetch(:class_name, Extlib::Inflection.classify(name)),
-            model.name,
+            model,
             options
           )
         end

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

@@ -5,75 +5,166 @@ module DataMapper
 
       OPTIONS = [ :class_name, :child_key, :parent_key, :min, :max, :through ]
 
-      attr_reader :name, :repository_name, :options, :query
+      # @api private
+      attr_reader :name, :options, :query
 
+      # @api private
       def child_key
         @child_key ||= begin
-          model_properties = child_model.properties(repository_name)
-
-          child_key = parent_key.zip(@child_properties || []).map do |parent_property,property_name|
-            # TODO: use something similar to DM::NamingConventions to determine the property name
-            property_name ||= "#{name}_#{parent_property.name}".to_sym
-
-            model_properties[property_name] || DataMapper.repository(repository_name) do
-              attributes = {}
-
-              [ :length, :precision, :scale ].each do |attribute|
-                attributes[attribute] = parent_property.send(attribute)
-              end
-
-              # NOTE: hack to make each many to many child_key a true key,
-              # until I can figure out a better place for this check
-              if child_model.respond_to?(:many_to_many)
-                attributes[:key] = true
+          child_key = nil
+          child_model.repository.scope do |r|
+            model_properties = child_model.properties(r.name)
+
+            child_key = parent_key.zip(@child_properties || []).map do |parent_property,property_name|
+              # TODO: use something similar to DM::NamingConventions to determine the property name
+              parent_name = Extlib::Inflection.underscore(Extlib::Inflection.demodulize(parent_model.base_model.name))
+              property_name ||= "#{parent_name}_#{parent_property.name}".to_sym
+
+              if model_properties.has_property?(property_name)
+                model_properties[property_name]
+              else
+                options = {}
+
+                [ :length, :precision, :scale ].each do |option|
+                  options[option] = parent_property.send(option)
+                end
+
+                # NOTE: hack to make each many to many child_key a true key,
+                # until I can figure out a better place for this check
+                if child_model.respond_to?(:many_to_many)
+                  options[:key] = true
+                end
+
+                child_model.property(property_name, parent_property.primitive, options)
               end
-
-              child_model.property(property_name, parent_property.primitive, attributes)
             end
           end
           PropertySet.new(child_key)
         end
       end
 
+      # @api private
       def parent_key
         @parent_key ||= begin
-          parent_key = if @parent_properties
-            parent_model.properties(repository_name).slice(*@parent_properties)
-          else
-            parent_model.key(repository_name)
+          parent_key = nil
+          parent_model.repository.scope do |r|
+            parent_key = if @parent_properties
+              parent_model.properties(r.name).slice(*@parent_properties)
+            else
+              parent_model.key
+            end
           end
-
           PropertySet.new(parent_key)
         end
       end
 
+      # @api private
       def parent_model
-        Class === @parent_model ? @parent_model : self.class.find_const(@parent_model)
+        Class === @parent_model ? @parent_model : (Class === @child_model ? @child_model.find_const(@parent_model) : Object.find_const(@parent_model))
+      rescue NameError
+        raise NameError, "Cannot find the parent_model #{@parent_model} for #{@child_model}"
       end
 
+      # @api private
       def child_model
-        Class === @child_model ? @child_model : self.class.find_const(@child_model)
+        Class === @child_model ? @child_model : (Class === @parent_model ? @parent_model.find_const(@child_model) : Object.find_const(@child_model))
+      rescue NameError
+        raise NameError, "Cannot find the child_model #{@child_model} for #{@parent_model}"
       end
 
       # @api private
       def get_children(parent, options = {}, finder = :all, *args)
-        bind_values = parent_key.get(parent)
-        return [] if bind_values.any? { |bind_value| bind_value.nil? }
-        query = child_key.to_query(bind_values)
+        bind_values   = parent_key.get(parent)
+        parent_values = bind_values.dup
+
+        with_repository(child_model) do |r|
+          parent_identity_map = parent.repository.identity_map(parent_model)
+          child_identity_map  = r.identity_map(child_model)
+
+          query_values = parent_identity_map.keys.flatten
+          query_values.reject! { |k| child_identity_map[[k]] }
+
+          bind_values = query_values unless query_values.empty?
+          query = child_key.map { |k| [ k, bind_values ] }.to_hash
+
+          collection = child_model.send(finder, *(args.dup << @query.merge(options).merge(query)))
+          return collection unless collection.kind_of?(Collection) && collection.any?
+
+          grouped_collection = Hash.new { |h,k| h[k] = [] }
+          collection.each do |resource|
+            grouped_collection[get_parent(resource, parent)] << resource
+          end
+
+          association_accessor = "#{self.name}_association"
+
+          ret = nil
+          grouped_collection.each do |parent, children|
+            association = parent.send(association_accessor)
+
+            query = collection.query.dup
+            query.conditions.map! do |operator, property, bind_value|
+              if child_key.has_property?(property.name)
+                bind_value = *children.map { |child| property.get(child) }.uniq
+              end
+              [ operator, property, bind_value ]
+            end
+
+            parents_children = Collection.new(query) do |collection|
+              children.each { |child| collection.send(:add, child) }
+            end
+
+            if parent_key.get(parent) == parent_values
+              ret = parents_children
+            else
+              association.instance_variable_set(:@children, parents_children)
+            end
+          end
 
-        DataMapper.repository(repository_name) do
-          child_model.send(finder, *(args << @query.merge(options).merge(query)))
+          ret || child_model.send(finder, *(args.dup << @query.merge(options).merge(child_key.zip(parent_values).to_hash)))
         end
       end
 
       # @api private
-      def get_parent(child)
-        bind_values = child_key.get(child)
-        return nil if bind_values.any? { |bind_value| bind_value.nil? }
-        query = parent_key.to_query(bind_values)
+      def get_parent(child, parent = nil)
+        child_value = child_key.get(child)
+        return nil unless child_value.nitems == child_value.size
+
+        with_repository(parent || parent_model) do
+          parent_identity_map = (parent || parent_model).repository.identity_map(parent_model)
+          child_identity_map  = child.repository.identity_map(child_model)
+
+          if parent = parent_identity_map[child_value]
+            return parent
+          end
+
+          children = child_identity_map.values
+
+          bind_values = *children.map { |c| child_key.get(c) }.uniq
+          query_values = bind_values.reject { |k| parent_identity_map[[k]] }
+
+          bind_values = query_values unless query_values.empty?
+          query = parent_key.map { |k| [ k, bind_values ] }.to_hash
 
-        DataMapper.repository(repository_name) do
-          parent_model.first(@query.merge(query))
+          association_accessor = "#{self.name}_association"
+
+          collection = parent_model.send(:all, query)
+          collection.send(:lazy_load)
+          children.each do |c|
+            c.send(association_accessor).instance_variable_set(:@parent, collection.get(*child_key.get(c)))
+          end
+          child.send(association_accessor).instance_variable_get(:@parent)
+        end
+      end
+
+      # @api private
+      def with_repository(object = nil, &block)
+        other_model = object.model == child_model ? parent_model : child_model if object.respond_to?(:model)
+        other_model = object       == child_model ? parent_model : child_model if object.kind_of?(DataMapper::Resource)
+
+        if other_model && other_model.repository == object.repository && object.repository.name != @repository_name
+          object.repository.scope(&block)
+        else
+          repository(@repository_name, &block)
         end
       end
 
@@ -89,10 +180,10 @@ module DataMapper
       # http://edocs.bea.com/kodo/docs41/full/html/jdo_overview_mapping_join.html
       # I wash my hands of it!
       def initialize(name, repository_name, child_model, parent_model, options = {})
-        assert_kind_of 'name',              name,              Symbol
-        assert_kind_of 'repository_name',   repository_name,   Symbol
-        assert_kind_of 'child_model',  child_model,  String, Class
-        assert_kind_of 'parent_model', parent_model, String, Class
+        assert_kind_of 'name',            name,            Symbol
+        assert_kind_of 'repository_name', repository_name, Symbol
+        assert_kind_of 'child_model',     child_model,     String, Class
+        assert_kind_of 'parent_model',    parent_model,    String, Class
 
         if child_properties = options[:child_key]
           assert_kind_of 'options[:child_key]', child_properties, Array
@@ -110,6 +201,17 @@ module DataMapper
         @parent_model      = parent_model
         @parent_properties = parent_properties  # may be nil
         @options           = options
+
+        # attempt to load the child_key if the parent and child model constants are defined
+        if model_defined?(@child_model) && model_defined?(@parent_model)
+          child_key
+        end
+      end
+
+      # @api private
+      def model_defined?(model)
+        # TODO: figure out other ways to see if the model is loaded
+        model.kind_of?(Class)
       end
     end # class Relationship
   end # module Associations