dm-core 0.9.2

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

@@ -0,0 +1,138 @@
+require File.join(File.dirname(__FILE__), "one_to_many")
+module DataMapper
+  module Associations
+    module ManyToMany
+      extend Assertions
+
+      # Setup many 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
+
+          def #{name}=(children)
+            #{name}_association.replace(children)
+          end
+
+          private
+
+          def #{name}_association
+            @#{name}_association ||= begin
+              unless relationship = model.relationships(#{repository_name.inspect})[#{name.inspect}]
+                raise ArgumentError, 'Relationship #{name.inspect} does not exist'
+              end
+              association = Proxy.new(relationship, self)
+              parent_associations << association
+              association
+            end
+          end
+        EOS
+
+        opts = options.dup
+        opts.delete(:through)
+        opts[:child_model]              ||= opts.delete(:class_name)  || Extlib::Inflection.classify(name)
+        opts[:parent_model]             =   model.name
+        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
+        model_name   = names.join
+        storage_name = Extlib::Inflection.tableize(Extlib::Inflection.pluralize(names[0]) + names[1])
+
+        opts[:near_relationship_name] = Extlib::Inflection.tableize(model_name).to_sym
+
+        model.has(model.n, opts[:near_relationship_name])
+
+        relationship = model.relationships(repository_name)[name] = RelationshipChain.new(opts)
+
+        unless Object.const_defined?(model_name)
+          model = DataMapper::Model.new(storage_name)
+
+          model.class_eval <<-EOS, __FILE__, __LINE__
+            def self.name; #{model_name.inspect} end
+            def self.default_repository_name; #{repository_name.inspect} end
+            def self.many_to_many; true end
+          EOS
+
+          names.each do |n|
+            model.belongs_to(Extlib::Inflection.underscore(n).to_sym)
+          end
+
+          Object.const_set(model_name, model)
+        end
+
+        relationship
+      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)
+          orphan_resource(super)
+        end
+
+        def clear
+          near_model.clear
+          super
+        end
+
+        def destroy
+          near_model.destroy
+          super
+        end
+
+        def save
+        end
+
+        def orphan_resource(resource)
+          assert_mutable
+          @orphans << resource
+          resource
+        end
+
+        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)
+        end
+
+        def near_relationship_name
+          @near_relationship_name ||= @relationship.send(:instance_variable_get, :@near_relationship_name)
+        end
+      end # class Proxy
+    end # module ManyToMany
+  end # module Associations
+end # module DataMapper

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

@@ -0,0 +1,101 @@
+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
+
+          def #{name}=(parent)
+            #{name}_association.replace(parent)
+          end
+
+          private
+
+          def #{name}_association
+            @#{name}_association ||= begin
+              unless relationship = model.relationships(#{repository_name.inspect})[:#{name}]
+                raise ArgumentError, 'Relationship #{name.inspect} does not exist'
+              end
+              association = Proxy.new(relationship, self)
+              child_associations << association
+              association
+            end
+          end
+        EOS
+
+        model.relationships(repository_name)[name] = Relationship.new(
+          name,
+          repository_name,
+          model.name,
+          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__ class kind_of? respond_to? assert_kind_of should should_not ].include?(m) }
+
+        def replace(parent)
+          @parent = parent
+          @relationship.attach_parent(@child, @parent)
+          self
+        end
+
+        def save
+          return false if @parent.nil?
+          return true  unless parent.new_record?
+
+          DataMapper.repository(@relationship.repository_name) do
+            parent.save
+          end
+        end
+
+        def reload
+          @parent = nil
+          self
+        end
+
+        def kind_of?(klass)
+          super || parent.kind_of?(klass)
+        end
+
+        def respond_to?(method, include_private = false)
+          super || parent.respond_to?(method, include_private)
+        end
+
+        private
+
+        def initialize(relationship, child)
+          assert_kind_of 'relationship', relationship, Relationship
+          assert_kind_of 'child',        child,        Resource
+
+          @relationship = relationship
+          @child        = child
+        end
+
+        def parent
+          @parent ||= @relationship.get_parent(@child)
+        end
+
+        def method_missing(method, *args, &block)
+          parent.__send__(method, *args, &block)
+        end
+      end # class Proxy
+    end # module ManyToOne
+  end # module Associations
+end # module DataMapper

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

@@ -0,0 +1,275 @@
+require 'forwardable'
+
+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
+
+          def #{name}=(children)
+            #{name}_association.replace(children)
+          end
+
+          private
+
+          def #{name}_association
+            @#{name}_association ||= begin
+              unless relationship = model.relationships(#{repository_name.inspect})[#{name.inspect}]
+                raise ArgumentError, 'Relationship #{name.inspect} does not exist'
+              end
+              association = Proxy.new(relationship, self)
+              parent_associations << association
+              association
+            end
+          end
+        EOS
+
+        model.relationships(repository_name)[name] = if options.has_key?(:through)
+          opts = options.dup
+
+          opts[:child_model]            ||= opts.delete(:class_name)  || Extlib::Inflection.classify(name)
+          opts[:parent_model]             =   model.name
+          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(
+            Extlib::Inflection.underscore(Extlib::Inflection.demodulize(model.name)).to_sym,
+            repository_name,
+            options.fetch(:class_name, Extlib::Inflection.classify(name)),
+            model.name,
+            options
+          )
+        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
+
+        instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ class kind_of? respond_to? assert_kind_of should should_not ].include?(m) }
+
+        # FIXME: remove when RelationshipChain#get_children can return a Collection
+        def all(query = {})
+          query.empty? ? self : @relationship.get_children(@parent, query)
+        end
+
+        # 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
+            super
+          end
+        end
+
+        def <<(resource)
+          assert_mutable
+          super
+          relate_resource(resource)
+          self
+        end
+
+        def push(*resources)
+          assert_mutable
+          super
+          resources.each { |resource| relate_resource(resource) }
+          self
+        end
+
+        def unshift(*resources)
+          assert_mutable
+          super
+          resources.each { |resource| relate_resource(resource) }
+          self
+        end
+
+        def replace(other)
+          assert_mutable
+          each { |resource| orphan_resource(resource) }
+          other = other.map { |resource| Hash === resource ? @relationship.child_model.new(resource) : resource }
+          super
+          other.each { |resource| relate_resource(resource) }
+          self
+        end
+
+        def pop
+          assert_mutable
+          orphan_resource(super)
+        end
+
+        def shift
+          assert_mutable
+          orphan_resource(super)
+        end
+
+        def delete(resource, &block)
+          assert_mutable
+          orphan_resource(super)
+        end
+
+        def delete_at(index)
+          assert_mutable
+          orphan_resource(super)
+        end
+
+        def clear
+          assert_mutable
+          each { |resource| orphan_resource(resource) }
+          super
+          self
+        end
+
+        def create(attributes = {})
+          assert_mutable
+          raise UnsavedParentError, 'You cannot create until the parent is saved' if @parent.new_record?
+          super
+        end
+
+        def update(attributes = {})
+          assert_mutable
+          raise UnsavedParentError, 'You cannot mass-update until the parent is saved' if @parent.new_record?
+          super
+        end
+
+        def update!(attributes = {})
+          assert_mutable
+          raise UnsavedParentError, 'You cannot mass-update without validations until the parent is saved' if @parent.new_record?
+          super
+        end
+
+        def destroy
+          assert_mutable
+          raise UnsavedParentError, 'You cannot mass-delete until the parent is saved' if @parent.new_record?
+          super
+        end
+
+        def destroy!
+          assert_mutable
+          raise UnsavedParentError, 'You cannot mass-delete without validations until the parent is saved' if @parent.new_record?
+          super
+        end
+
+        def reload
+          @children = nil
+          self
+        end
+
+        def save
+          assert_mutable
+
+          # save every resource in the collection
+          each { |resource| save_resource(resource) }
+
+          # save orphan resources
+          @orphans.each do |resource|
+            begin
+              save_resource(resource, nil)
+            rescue
+              children << resource unless children.frozen? || children.include?(resource)
+              raise
+            end
+          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)
+          end
+
+          true
+        end
+
+        def kind_of?(klass)
+          super || children.kind_of?(klass)
+        end
+
+        def respond_to?(method, include_private = false)
+          super || children.respond_to?(method, include_private)
+        end
+
+        private
+
+        def initialize(relationship, parent)
+          assert_kind_of 'relationship', relationship, Relationship
+          assert_kind_of 'parent',       parent,       Resource
+
+          @relationship = relationship
+          @parent       = parent
+          @orphans      = []
+        end
+
+        def children
+          @children ||= @relationship.get_children(@parent)
+        end
+
+        def assert_mutable
+          raise ImmutableAssociationError, 'You can not modify this assocation' if children.frozen?
+        end
+
+        def add_default_association_values(resource)
+          return if respond_to?(:default_attributes)
+
+          @relationship.query.each do |attribute, value|
+            next if Query::OPTIONS.include?(attribute) || attribute.kind_of?(Query::Operator) || resource.attribute_loaded?(attribute)
+            resource.send("#{attribute}=", value)
+          end
+        end
+
+        def relate_resource(resource)
+          assert_mutable
+          add_default_association_values(resource)
+          @orphans.delete(resource)
+          resource
+        end
+
+        def orphan_resource(resource)
+          assert_mutable
+          @orphans << resource
+          resource
+        end
+
+        def save_resource(resource, parent = @parent)
+          DataMapper.repository(@relationship.repository_name) do
+            if parent.nil? && resource.model.respond_to?(:many_to_many)
+              resource.destroy
+            else
+              @relationship.attach_parent(resource, parent)
+              resource.save
+            end
+          end
+        end
+
+        def method_missing(method, *args, &block)
+          results = children.__send__(method, *args, &block) if children.respond_to?(method)
+
+          return self if LazyArray::RETURN_SELF.include?(method) && results.kind_of?(Array)
+
+          results
+        end
+      end # class Proxy
+    end # module OneToMany
+  end # module Associations
+end # module DataMapper