dm-core 0.9.11 → 0.10.0

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

@@ -1,107 +1,254 @@
 module DataMapper
   module Associations
-    module ManyToOne
-      extend Assertions
-
-      # Setup many to one relationship between two models
-      # -
-      # @api private
-      def self.setup(name, model, options = {})
-        assert_kind_of 'name',    name,    Symbol
-        assert_kind_of 'model',   model,   Model
-        assert_kind_of 'options', options, Hash
-
-        repository_name = model.repository.name
-
-        model.class_eval <<-EOS, __FILE__, __LINE__
-          def #{name}
-            #{name}_association.nil? ? nil : #{name}_association
-          end
+    module ManyToOne #:nodoc:
+      # Relationship class with implementation specific
+      # to n side of 1 to n association
+      class Relationship < Associations::Relationship
+        OPTIONS = superclass::OPTIONS.dup << :nullable
+
+        # TODO: document
+        # @api semipublic
+        alias source_repository_name child_repository_name
+
+        # TODO: document
+        # @api semipublic
+        alias source_model child_model
+
+        # TODO: document
+        # @api semipublic
+        alias target_repository_name parent_repository_name
+
+        # TODO: document
+        # @api semipublic
+        alias target_model parent_model
+
+        # TODO: document
+        # @api semipublic
+        alias target_key parent_key
+
+        # TODO: document
+        # @api semipublic
+        def nullable?
+          @nullable
+        end
 
-          def #{name}=(parent)
-            #{name}_association.replace(parent)
-          end
+        # Returns a set of keys that identify child model
+        #
+        # @return   [DataMapper::PropertySet]  a set of properties that identify child model
+        # @api private
+        def child_key
+          return @child_key if defined?(@child_key)
+
+          repository_name = child_repository_name || parent_repository_name
+          properties      = child_model.properties(repository_name)
 
-          private
+          child_key = parent_key.zip(@child_properties || []).map do |parent_property, property_name|
+            property_name ||= "#{name}_#{parent_property.name}".to_sym
 
-          def #{name}_association
-            @#{name}_association ||= begin
-              unless relationship = model.relationships(#{repository_name.inspect})[:#{name}]
-                raise ArgumentError, "Relationship #{name.inspect} does not exist in \#{model}"
+            properties[property_name] || begin
+              # create the property within the correct repository
+              DataMapper.repository(repository_name) do
+                type = parent_property.send(parent_property.type == DataMapper::Types::Boolean ? :type : :primitive)
+                child_model.property(property_name, type, child_key_options(parent_property))
               end
-              association = Proxy.new(relationship, self)
-              child_associations << association
-              association
             end
           end
-        EOS
-
-        model.relationships(repository_name)[name] = Relationship.new(
-          name,
-          repository_name,
-          model,
-          options.fetch(:class_name, Extlib::Inflection.classify(name)),
-          options
-        )
-      end
-
-      class Proxy
-        include Assertions
 
-        instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ object_id kind_of? respond_to? assert_kind_of should should_not instance_variable_set instance_variable_get ].include?(m.to_s) }
+          @child_key = properties.class.new(child_key).freeze
+        end
 
-        def replace(parent)
-          @parent = parent
-          @relationship.attach_parent(@child, @parent)
-          self
+        # TODO: document
+        # @api semipublic
+        alias source_key child_key
+
+        # Returns a Resoruce for this relationship with a given source
+        #
+        # @param [Resource] source
+        #   A Resource to scope the collection with
+        # @param [Query] other_query (optional)
+        #   A Query to further scope the collection with
+        #
+        # @return [Resource]
+        #   The resource scoped to the relationship, source and query
+        #
+        # @api private
+        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)
         end
 
-        def save
-          return false if @parent.nil?
-          return true  unless parent.new_record?
+        # Loads and returns association target (ex.: author) for given source resource
+        # (ex.: article)
+        #
+        # @param  source  [DataMapper::Resource]
+        #   Child object (ex.: instance of article)
+        # @param  other_query  [DataMapper::Query]
+        #   Query options
+        #
+        # @api semipublic
+        def get(source, other_query = nil)
+          assert_kind_of 'source', source, source_model
+
+          lazy_load(source) unless loaded?(source)
+
+          resource = get!(source)
+          if other_query.nil? || query_for(source, other_query).conditions.matches?(resource)
+            resource
+          end
+        end
 
-          @relationship.with_repository(parent) do
-            result = parent.save
-            @relationship.child_key.set(@child, @relationship.parent_key.get(parent)) if result
-            result
+        # Sets value of association target (ex.: author) for given source resource
+        # (ex.: article)
+        #
+        # @param source [DataMapper::Resource]
+        #   Child object (ex.: instance of article)
+        #
+        # @param source [DataMapper::Resource]
+        #   Parent object (ex.: instance of author)
+        #
+        # @api semipublic
+        def set(source, target)
+          assert_kind_of 'source', source, source_model
+          assert_kind_of 'target', target, target_model, Hash, NilClass
+
+          if target.kind_of?(Hash)
+            target = target_model.new(target)
           end
+
+          source_key.set(source, target.nil? ? [] : target_key.get(target))
+          set!(source, target)
         end
 
-        def reload
-          @parent = nil
-          self
+        # TODO: document
+        # @api private
+        def inherited_by(model)
+          model.relationships(source_repository_name)[name] ||
+            self.class.new(name, model, parent_model_name, options_with_inverse)
+        end
+
+        private
+
+        # Initializes the relationship, always using max cardinality of 1.
+        #
+        # @api semipublic
+        def initialize(name, source_model, target_model, options = {})
+          @nullable      = options.fetch(:nullable, false)
+          target_model ||= Extlib::Inflection.camelize(name)
+          options        = { :min => @nullable ? 0 : 1, :max => 1 }.update(options)
+          super
         end
 
-        def kind_of?(klass)
-          super || parent.kind_of?(klass)
+        # Dynamically defines reader method for source side of association
+        # (for instance, method article for model Paragraph)
+        #
+        # @api semipublic
+        def create_reader
+          return if source_model.resource_method_defined?(name.to_s)
+
+          source_model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            public  # TODO: make this configurable
+
+            # FIXME: if the writer is used, caching nil in the ivar
+            # and then the FK(s) are set, the cache in the writer should
+            # be cleared.
+
+            def #{name}(query = nil)                          # def article(query = nil)
+              relationships[#{name.inspect}].get(self, query) #   relationships["article"].get(self, query)
+            end                                               # end
+          RUBY
         end
 
-        def respond_to?(method, include_private = false)
-          super || parent.respond_to?(method, include_private)
+        # Dynamically defines writer method for source side of association
+        # (for instance, method article= for model Paragraph)
+        #
+        # @api semipublic
+        def create_writer
+          writer_name = "#{name}="
+
+          return if source_model.resource_method_defined?(writer_name)
+
+          source_model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            public  # TODO: make this configurable
+            def #{writer_name}(target)                         # def article=(target)
+              relationships[#{name.inspect}].set(self, target) #   relationships["article"].set(self, target)
+            end                                                # end
+          RUBY
         end
 
-        def instance_variable_get(variable)
-          super || parent.instance_variable_get(variable)
+        # Loads association target and sets resulting value on
+        # given source resource
+        #
+        # @param [Resource] source
+        #   the source resource for the association
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def lazy_load(source)
+          return unless source_key.get(source).all?
+
+          # SEL: load all related resources in the source collection
+          if source.saved? && source.collection.size > 1
+            eager_load(source.collection)
+          end
+
+          unless loaded?(source)
+            set!(source, resource_for(source))
+          end
         end
 
-        private
+        # Sets the association targets in the resource
+        #
+        # @param [Resource] source
+        #   the source to set
+        # @param [Array(Resource)] targets
+        #   the target resource for the association
+        # @param [Query, Hash] query
+        #   not used
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def eager_load_targets(source, targets, query)
+          set(source, targets.first)
+        end
 
-        def initialize(relationship, child)
-          assert_kind_of 'relationship', relationship, Relationship
-          assert_kind_of 'child',        child,        Resource
+        # Returns the inverse relationship class
+        #
+        # @api private
+        def inverse_class
+          OneToMany::Relationship
+        end
 
-          @relationship = relationship
-          @child        = child
+        # Returns the inverse relationship name
+        #
+        # @api private
+        def inverse_name
+          super || Extlib::Inflection.underscore(Extlib::Inflection.demodulize(source_model.name)).pluralize.to_sym
         end
 
-        def parent
-          @parent ||= @relationship.get_parent(@child)
+        # TODO: document
+        # @api private
+        def child_key_options(parent_property)
+          options = parent_property.options.only(:length, :precision, :scale).update(:index => name, :nullable => nullable?)
+
+          if parent_property.primitive == Integer && parent_property.min && parent_property.max
+            options.update(:min => parent_property.min, :max => parent_property.max)
+          end
+
+          options
         end
 
-        def method_missing(method, *args, &block)
-          parent.__send__(method, *args, &block)
+        # TODO: document
+        # @api private
+        def child_properties
+          child_key.map { |property| property.name }
         end
-      end # class Proxy
+      end # class Relationship
     end # module ManyToOne
   end # module Associations
 end # module DataMapper

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

@@ -1,315 +1,379 @@
 module DataMapper
   module Associations
-    module OneToMany
-      extend Assertions
-
-      # Setup one to many relationship between two models
-      # -
-      # @api private
-      def self.setup(name, model, options = {})
-        assert_kind_of 'name',    name,    Symbol
-        assert_kind_of 'model',   model,   Model
-        assert_kind_of 'options', options, Hash
-
-        repository_name = model.repository.name
-
-        model.class_eval <<-EOS, __FILE__, __LINE__
-          def #{name}(query = {})
-            #{name}_association.all(query)
-          end
+    module OneToMany #:nodoc:
+      class Relationship < Associations::Relationship
+        # TODO: document
+        # @api semipublic
+        alias target_repository_name child_repository_name
 
-          def #{name}=(children)
-            #{name}_association.replace(children)
-          end
+        # TODO: document
+        # @api semipublic
+        alias target_model child_model
 
-          private
-
-          def #{name}_association
-            @#{name}_association ||= begin
-              unless relationship = model.relationships(#{repository_name.inspect})[#{name.inspect}]
-                raise ArgumentError, "Relationship #{name.inspect} does not exist in \#{model}"
-              end
-              association = Proxy.new(relationship, self)
-              parent_associations << association
-              association
-            end
-          end
-        EOS
+        # TODO: document
+        # @api semipublic
+        alias source_repository_name parent_repository_name
 
-        model.relationships(repository_name)[name] = if options.has_key?(:through)
-          opts = options.dup
+        # TODO: document
+        # @api semipublic
+        alias source_model parent_model
 
-          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
+        # TODO: document
+        # @api semipublic
+        alias source_key parent_key
 
-          opts[:child_model]            ||= opts.delete(:class_name)  || Extlib::Inflection.classify(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
-          opts[:parent_key]               =   opts[:parent_key]
-          opts[:child_key]                =   opts[:child_key]
-
-          RelationshipChain.new( opts )
-        else
-          Relationship.new(
-            name,
-            repository_name,
-            options.fetch(:class_name, Extlib::Inflection.classify(name)),
-            model,
-            options
-          )
+        # TODO: document
+        # @api semipublic
+        def child_key
+          inverse.child_key
         end
-      end
 
-      # TODO: look at making this inherit from Collection.  The API is
-      # almost identical, and it would make more sense for the
-      # relationship.get_children method to return a Proxy than a
-      # Collection that is wrapped in a Proxy.
-      class Proxy
-        include Assertions
+        # TODO: document
+        # @api semipublic
+        alias target_key child_key
 
-        instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ class object_id kind_of? respond_to? assert_kind_of should should_not instance_variable_set instance_variable_get ].include?(m.to_s) }
+        # Returns a Collection for this relationship with a given source
+        #
+        # @param [Resource] source
+        #   A Resource to scope the collection with
+        # @param [Query] other_query (optional)
+        #   A Query to further scope the collection with
+        #
+        # @return [Collection]
+        #   The collection scoped to the relationship, source and query
+        #
+        # @api private
+        def collection_for(source, other_query = nil)
+          query = query_for(source, other_query)
 
-        # FIXME: remove when RelationshipChain#get_children can return a Collection
-        def all(query = {})
-          query.empty? ? self : @relationship.get_children(@parent, query)
-        end
+          collection = collection_class.new(query)
+          collection.relationship = self
+          collection.source       = source
 
-        # FIXME: remove when RelationshipChain#get_children can return a Collection
-        def first(*args)
-          if args.last.respond_to?(:merge)
-            query = args.pop
-            @relationship.get_children(@parent, query, :first, *args)
-          else
-            children.first(*args)
-          end
-        end
+          # make the collection empty if the source is not saved
+          collection.replace([]) unless source.saved?
 
-        def <<(resource)
-          assert_mutable
-          return self if !resource.new_record? && self.include?(resource)
-          children << resource
-          relate_resource(resource)
-          self
+          collection
         end
 
-        def push(*resources)
-          assert_mutable
-          resources.reject! { |resource| !resource.new_record? && self.include?(resource) }
-          children.push(*resources)
-          resources.each { |resource| relate_resource(resource) }
-          self
-        end
+        # Loads and returns association targets (ex.: articles) for given source resource
+        # (ex.: author)
+        #
+        # @api semipublic
+        def get(source, other_query = nil)
+          assert_kind_of 'source', source, source_model
 
-        def unshift(*resources)
-          assert_mutable
-          resources.reject! { |resource| !resource.new_record? && self.include?(resource) }
-          children.unshift(*resources)
-          resources.each { |resource| relate_resource(resource) }
-          self
-        end
+          lazy_load(source) unless loaded?(source)
 
-        def replace(other)
-          assert_mutable
-          each { |resource| orphan_resource(resource) }
-          other = other.map { |resource| resource.kind_of?(Hash) ? new_child(resource) : resource }
-          children.replace(other)
-          other.each { |resource| relate_resource(resource) }
-          self
+          collection = get!(source)
+          other_query.nil? ? collection : collection.all(other_query)
         end
 
-        def pop
-          assert_mutable
-          orphan_resource(children.pop)
-        end
+        # Sets value of association targets (ex.: paragraphs) for given source resource
+        # (ex.: article)
+        #
+        # @api semipublic
+        def set(source, targets)
+          assert_kind_of 'source',  source,  source_model
+          assert_kind_of 'targets', targets, Array
 
-        def shift
-          assert_mutable
-          orphan_resource(children.shift)
-        end
+          lazy_load(source) unless loaded?(source)
 
-        def delete(resource)
-          assert_mutable
-          orphan_resource(children.delete(resource))
+          get!(source).replace(targets)
         end
 
-        def delete_at(index)
-          assert_mutable
-          orphan_resource(children.delete_at(index))
+        # TODO: document
+        # @api private
+        def inherited_by(model)
+          model.relationships(source_repository_name)[name] ||
+            self.class.new(name, child_model_name, model, options_with_inverse)
         end
 
-        def clear
-          assert_mutable
-          each { |resource| orphan_resource(resource) }
-          children.clear
-          self
-        end
-
-        def build(attributes = {})
-          assert_mutable
-          attributes = default_attributes.merge(attributes)
-          resource = children.respond_to?(:build) ? children.build(attributes) : new_child(attributes)
-          resource
-        end
-
-        def new(attributes = {})
-          assert_mutable
-          raise UnsavedParentError, 'You cannot intialize until the parent is saved' if @parent.new_record?
-          attributes = default_attributes.merge(attributes)
-          resource = children.respond_to?(:new) ? children.new(attributes) : @relationship.child_model.new(attributes)
-          self << resource
-          resource
-        end
-
-        def create(attributes = {})
-          assert_mutable
-          raise UnsavedParentError, 'You cannot create until the parent is saved' if @parent.new_record?
-          attributes = default_attributes.merge(attributes)
-          resource = children.respond_to?(:create) ? children.create(attributes) : @relationship.child_model.create(attributes)
-          self << resource
-          resource
-        end
-
-        def update(attributes = {})
-          assert_mutable
-          raise UnsavedParentError, 'You cannot mass-update until the parent is saved' if @parent.new_record?
-          children.update(attributes)
-        end
-
-        def update!(attributes = {})
-          assert_mutable
-          raise UnsavedParentError, 'You cannot mass-update without validations until the parent is saved' if @parent.new_record?
-          children.update!(attributes)
-        end
-
-        def destroy
-          assert_mutable
-          raise UnsavedParentError, 'You cannot mass-delete until the parent is saved' if @parent.new_record?
-          children.destroy
-        end
-
-        def destroy!
-          assert_mutable
-          raise UnsavedParentError, 'You cannot mass-delete without validations until the parent is saved' if @parent.new_record?
-          children.destroy!
-        end
-
-        def reload
-          @children = nil
-          self
-        end
-
-        def save
-          return true if children.frozen?
-
-          # save every resource in the collection
-          each { |resource| save_resource(resource) }
+        private
 
-          # save orphan resources
-          @orphans.each do |resource|
-            begin
-              save_resource(resource, nil)
-            rescue
-              children << resource unless children.frozen? || children.include?(resource)
-              raise
-            end
+        # TODO: document
+        # @api semipublic
+        def initialize(name, target_model, source_model, options = {})
+          target_model ||= Extlib::Inflection.camelize(name.to_s.singular)
+          options        = { :min => 0, :max => source_model.n }.update(options)
+          super
+        end
+
+        # Dynamically defines reader method for source side of association
+        # (for instance, method paragraphs for model Article)
+        #
+        # @api semipublic
+        def create_reader
+          return if source_model.resource_method_defined?(name.to_s)
+
+          source_model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}(query = nil)                           # def paragraphs(query = nil)
+              relationships[#{name.inspect}].get(self, query)  #   relationships[:paragraphs].get(self, query)
+            end                                                # end
+          RUBY
+        end
+
+        # Dynamically defines reader method for source side of association
+        # (for instance, method paragraphs= for model Article)
+        #
+        # @api semipublic
+        def create_writer
+          writer_name = "#{name}="
+
+          return if source_model.resource_method_defined?(writer_name)
+
+          source_model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{writer_name}(targets)                          # def paragraphs=(targets)
+              relationships[#{name.inspect}].set(self, targets)  #   relationships[:paragraphs].set(self, targets)
+            end                                                  # end
+          RUBY
+        end
+
+        # Loads association targets and sets resulting value on
+        # given source resource
+        #
+        # @param [Resource] source
+        #   the source resource for the association
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def lazy_load(source)
+          # SEL: load all related resources in the source collection
+          if source.saved? && source.collection.size > 1
+            eager_load(source.collection)
           end
 
-          # FIXME: remove when RelationshipChain#get_children can return a Collection
-          # place the children into a Collection if not already
-          if children.kind_of?(Array) && !children.frozen?
-            @children = @relationship.get_children(@parent).replace(children)
+          unless loaded?(source)
+            set!(source, collection_for(source))
           end
-
-          true
         end
 
-        def kind_of?(klass)
-          super || children.kind_of?(klass)
+        # Sets the association targets in the resource
+        #
+        # @param [Resource] source
+        #   the source to set
+        # @param [Array<Resource>] targets
+        #   the target collection for the association
+        # @param [Query, Hash] query
+        #   the query to scope the association with
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def eager_load_targets(source, targets, query)
+          # TODO: figure out an alternative approach to using a
+          # private method call collection_replace
+          association = collection_for(source, query)
+          association.send(:collection_replace, targets)
+          set!(source, association)
+        end
+
+        # Returns collection class used by this type of
+        # relationship
+        #
+        # @api private
+        def collection_class
+          OneToMany::Collection
+        end
+
+        # Returns the inverse relationship class
+        #
+        # @api private
+        def inverse_class
+          ManyToOne::Relationship
+        end
+
+        # Returns the inverse relationship name
+        #
+        # @api private
+        def inverse_name
+          super || Extlib::Inflection.underscore(Extlib::Inflection.demodulize(source_model.name)).to_sym
+        end
+
+        # TODO: document
+        # @api private
+        def child_properties
+          super || parent_key.map do |parent_property|
+            "#{inverse_name}_#{parent_property.name}".to_sym
+          end
         end
-
-        def respond_to?(method, include_private = false)
-          super || children.respond_to?(method, include_private)
+      end # class Relationship
+
+      class Collection < DataMapper::Collection
+        # TODO: document
+        # @api private
+        attr_accessor :relationship
+
+        # TODO: document
+        # @api private
+        attr_accessor :source
+
+        # TODO: document
+        # @api public
+        def reload(*)
+          assert_source_saved 'The source must be saved before reloading the collection'
+          super
+        end
+
+        # Replace the Resources within the 1:m Collection
+        #
+        # @param [Enumerable] other
+        #   List of other Resources to replace with
+        #
+        # @return [Collection]
+        #   self
+        #
+        # @api public
+        def replace(*)
+          lazy_load  # lazy load so that targets are always orphaned
+          super
+        end
+
+        # Removes all Resources from the 1:m Collection
+        #
+        # This should remove and orphan each Resource from the 1:m Collection.
+        #
+        # @return [Collection]
+        #   self
+        #
+        # @api public
+        def clear
+          lazy_load  # lazy load so that targets are always orphaned
+          super
+        end
+
+        # Update every Resource in the 1:m Collection
+        #
+        # @param [Hash] attributes
+        #   attributes to update with
+        #
+        # @return [Boolean]
+        #   true if the resources were successfully updated
+        #
+        # @api public
+        def update(*)
+          assert_source_saved 'The source must be saved before mass-updating the collection'
+          super
+        end
+
+        # Update every Resource in the 1:m Collection, bypassing validation
+        #
+        # @param [Hash] attributes
+        #   attributes to update
+        #
+        # @return [Boolean]
+        #   true if the resources were successfully updated
+        #
+        # @api public
+        def update!(*)
+          assert_source_saved 'The source must be saved before mass-updating the collection'
+          super
+        end
+
+        # Remove every Resource in the 1:m Collection from the repository
+        #
+        # This performs a deletion of each Resource in the Collection from
+        # the repository and clears the Collection.
+        #
+        # @return [Boolean]
+        #   true if the resources were successfully destroyed
+        #
+        # @api public
+        def destroy
+          assert_source_saved 'The source must be saved before mass-deleting the collection'
+          super
+        end
+
+        # Remove every Resource in the 1:m Collection from the repository, bypassing validation
+        #
+        # This performs a deletion of each Resource in the Collection from
+        # the repository and clears the Collection while skipping
+        # validation.
+        #
+        # @return [Boolean]
+        #   true if the resources were successfully destroyed
+        #
+        # @api public
+        def destroy!
+          assert_source_saved 'The source must be saved before mass-deleting the collection'
+          super
         end
 
         private
 
-        def initialize(relationship, parent)
-          assert_kind_of 'relationship', relationship, Relationship
-          assert_kind_of 'parent',       parent,       Resource
-
-          @relationship = relationship
-          @parent       = parent
-          @orphans      = []
+        # TODO: document
+        # @api private
+        def _create(*)
+          assert_source_saved 'The source must be saved before creating a resource'
+          super
         end
 
-        def children
-          @children ||= @relationship.get_children(@parent)
-        end
+        # TODO: document
+        # @api private
+        def _save(safe)
+          assert_source_saved 'The source must be saved before saving the collection'
 
-        def assert_mutable
-          raise ImmutableAssociationError, 'You can not modify this association' if children.frozen?
+          # update removed resources to not reference the source
+          @removed.all? { |resource| resource.send(safe ? :save : :save!) } && super
         end
 
-        def default_attributes
-          default_attributes = {}
-
-          @relationship.query.each do |attribute, value|
-            next if Query::OPTIONS.include?(attribute) || attribute.kind_of?(Query::Operator)
-            default_attributes[attribute] = value
+        # TODO: document
+        # @api private
+        def lazy_load
+          if source.saved?
+            super
           end
+        end
 
-          @relationship.child_key.zip(@relationship.parent_key.get(@parent)) do |property,value|
-            default_attributes[property.name] = value
-          end
+        # TODO: document
+        # @api private
+        def new_collection(query, resources = nil, &block)
+          collection = self.class.new(query, &block)
 
-          default_attributes
-        end
+          collection.relationship = relationship
+          collection.source       = source
 
-        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)
+          resources ||= filter(query) if loaded?
+
+          # set the resources after the relationship and source are set
+          if resources
+            collection.send(:collection_replace, resources)
           end
-        end
 
-        def new_child(attributes)
-          @relationship.child_model.new(default_attributes.merge(attributes))
+          collection
         end
 
-        def relate_resource(resource)
-          assert_mutable
-          add_default_association_values(resource)
-          @orphans.delete(resource)
-          resource
+        # TODO: document
+        # @api private
+        def resource_added(resource)
+          inverse_set(resource, source)
+          super
         end
 
-        def orphan_resource(resource)
-          assert_mutable
-          @orphans << resource
-          resource
+        # TODO: document
+        # @api private
+        def resource_removed(resource)
+          inverse_set(resource, nil)
+          super
         end
 
-        def save_resource(resource, parent = @parent)
-          @relationship.with_repository(resource) do |r|
-            if parent.nil? && resource.model.respond_to?(:many_to_many)
-              resource.destroy
-            else
-              @relationship.attach_parent(resource, parent)
-              resource.save
-            end
+        # TODO: document
+        # @api private
+        def inverse_set(source, target)
+          unless source.frozen?
+            relationship.inverse.set(source, target)
           end
         end
 
-        def method_missing(method, *args, &block)
-          results = children.send(method, *args, &block)
-          results.equal?(children) ? self : results
+        # TODO: document
+        # @api private
+        def assert_source_saved(message)
+          unless source.saved?
+            raise UnsavedParentError, message
+          end
         end
-      end # class Proxy
+      end # class Collection
     end # module OneToMany
   end # module Associations
 end # module DataMapper