datamapper-dm-core 0.9.11

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

@@ -0,0 +1,315 @@
+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 in \#{model}"
+              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
+
+          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
+          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
+          )
+        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 object_id kind_of? respond_to? assert_kind_of should should_not instance_variable_set instance_variable_get ].include?(m.to_s) }
+
+        # 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
+            children.first(*args)
+          end
+        end
+
+        def <<(resource)
+          assert_mutable
+          return self if !resource.new_record? && self.include?(resource)
+          children << resource
+          relate_resource(resource)
+          self
+        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
+
+        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
+
+        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
+        end
+
+        def pop
+          assert_mutable
+          orphan_resource(children.pop)
+        end
+
+        def shift
+          assert_mutable
+          orphan_resource(children.shift)
+        end
+
+        def delete(resource)
+          assert_mutable
+          orphan_resource(children.delete(resource))
+        end
+
+        def delete_at(index)
+          assert_mutable
+          orphan_resource(children.delete_at(index))
+        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) }
+
+          # 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 association' if children.frozen?
+        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
+          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)
+          @orphans.delete(resource)
+          resource
+        end
+
+        def orphan_resource(resource)
+          assert_mutable
+          @orphans << resource
+          resource
+        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
+          end
+        end
+
+        def method_missing(method, *args, &block)
+          results = children.send(method, *args, &block)
+          results.equal?(children) ? self : results
+        end
+      end # class Proxy
+    end # module OneToMany
+  end # module Associations
+end # module DataMapper

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

@@ -0,0 +1,61 @@
+module DataMapper
+  module Associations
+    module OneToOne
+      extend Assertions
+
+      # Setup one 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.first
+          end
+
+          def #{name}=(child_resource)
+            #{name}_association.replace(child_resource.nil? ? [] : [ child_resource ])
+          end
+
+          private
+
+          def #{name}_association
+            @#{name}_association ||= begin
+              unless relationship = model.relationships(#{repository_name.inspect})[:#{name}]
+                raise ArgumentError, "Relationship #{name.inspect} does not exist in \#{model}"
+              end
+              association = Associations::OneToMany::Proxy.new(relationship, self)
+              parent_associations << association
+              association
+            end
+          end
+        EOS
+
+        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,
+            :repository_name          => repository_name,
+            :near_relationship_name   => options[:through],
+            :remote_relationship_name => options.fetch(:remote_name, name),
+            :parent_key               => options[:parent_key],
+            :child_key                => options[:child_key]
+          )
+        else
+          Relationship.new(
+            name,
+            repository_name,
+            options.fetch(:class_name, Extlib::Inflection.classify(name)),
+            model,
+            options
+          )
+        end
+      end
+    end # module HasOne
+  end # module Associations
+end # module DataMapper

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

@@ -0,0 +1,229 @@
+module DataMapper
+  module Associations
+    class Relationship
+      include Assertions
+
+      OPTIONS = [ :class_name, :child_key, :parent_key, :min, :max, :through ]
+
+      # @api private
+      attr_reader :name, :options, :query
+
+      # @api private
+      def child_key
+        @child_key ||= begin
+          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
+            end
+          end
+          PropertySet.new(child_key)
+        end
+      end
+
+      # @api private
+      def parent_key
+        @parent_key ||= begin
+          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
+        return @parent_model if model_defined?(@parent_model)
+        @parent_model = @child_model.find_const(@parent_model)
+      rescue NameError
+        raise NameError, "Cannot find the parent_model #{@parent_model} for #{@child_model}"
+      end
+
+      # @api private
+      def child_model
+        return @child_model if model_defined?(@child_model)
+        @child_model = @parent_model.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)
+        parent_value = parent_key.get(parent)
+        bind_values  = [ parent_value ]
+
+        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
+          query_values.reject! { |k| child_identity_map[k] }
+
+          bind_values = query_values unless query_values.empty?
+          query = child_key.zip(bind_values.transpose).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 = {}
+          collection.each do |resource|
+            child_value = child_key.get(resource)
+            parent_obj = parent_identity_map[child_value]
+            grouped_collection[parent_obj] ||= []
+            grouped_collection[parent_obj] << 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 operator != :raw && 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)
+            children.each { |child| parents_children.send(:add, child) }
+
+            if parent_key.get(parent) == parent_value
+              ret = parents_children
+            else
+              association.instance_variable_set(:@children, parents_children)
+            end
+          end
+
+          ret || child_model.send(finder, *(args.dup << @query.merge(options).merge(child_key.zip([ parent_value ]).to_hash)))
+        end
+      end
+
+      # @api private
+      def get_parent(child, parent = nil)
+        child_value = child_key.get(child)
+        return nil if child_value.any? { |v| v.nil? }
+
+        with_repository(parent || parent_model) do
+          parent_identity_map = (parent || parent_model).repository.identity_map(parent_model.base_model)
+          child_identity_map  = child.repository.identity_map(child_model.base_model)
+
+          if parent = parent_identity_map[child_value]
+            return parent
+          end
+
+          children = child_identity_map.values
+          children << child unless child_identity_map[child.key]
+
+          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.zip(bind_values.transpose).to_hash
+          association_accessor = "#{self.name}_association"
+
+          collection = parent_model.send(:all, query)
+          unless collection.empty?
+            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
+      end
+
+      # @api private
+      def with_repository(object = nil)
+        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_args| yield(*block_args) }
+        else
+          repository(@repository_name) { |block_args| yield(*block_args) }
+        end
+      end
+
+      # @api private
+      def attach_parent(child, parent)
+        child_key.set(child, parent && parent_key.get(parent))
+      end
+
+      private
+
+      # +child_model_name and child_properties refers to the FK, parent_model_name
+      # and parent_properties refer to the PK.  For more information:
+      # 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
+
+        unless model_defined?(child_model) || model_defined?(parent_model)
+          raise 'at least one of child_model and parent_model must be a Model object'
+        end
+
+        if child_properties = options[:child_key]
+          assert_kind_of 'options[:child_key]', child_properties, Array
+        end
+
+        if parent_properties = options[:parent_key]
+          assert_kind_of 'options[:parent_key]', parent_properties, Array
+        end
+
+        @name              = name
+        @repository_name   = repository_name
+        @child_model       = child_model
+        @child_properties  = child_properties   # may be nil
+        @query             = options.reject { |k,v| OPTIONS.include?(k) }
+        @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
+end # module DataMapper