ghost_dm-core 1.3.0.beta

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

@@ -0,0 +1,290 @@
+module DataMapper
+  module Associations
+    module ManyToOne #:nodoc:
+      # Relationship class with implementation specific
+      # to n side of 1 to n association
+      class Relationship < Associations::Relationship
+        OPTIONS = superclass::OPTIONS.dup << :required << :key << :unique
+
+        # @api semipublic
+        alias_method :source_repository_name, :child_repository_name
+
+        # @api semipublic
+        alias_method :source_model, :child_model
+
+        # @api semipublic
+        alias_method :target_repository_name, :parent_repository_name
+
+        # @api semipublic
+        alias_method :target_model, :parent_model
+
+        # @api semipublic
+        alias_method :target_key, :parent_key
+
+        # @api semipublic
+        def required?
+          @required
+        end
+
+        # @api semipublic
+        def key?
+          @key
+        end
+
+        # @api semipublic
+        def unique?
+          !!@unique
+        end
+
+        # @deprecated
+        def nullable?
+          raise "#{self.class}#nullable? is deprecated, use #{self.class}#required? instead (#{caller.first})"
+        end
+
+        # Returns a set of keys that identify source model
+        #
+        # @return   [DataMapper::PropertySet]  a set of properties that identify source model
+        # @api private
+        def child_key
+          return @child_key if defined?(@child_key)
+
+          model           = source_model
+          repository_name = source_repository_name || target_repository_name
+          properties      = model.properties(repository_name)
+
+          source_key = target_key.zip(@child_properties || []).map do |target_property, property_name|
+            property_name ||= "#{name}_#{target_property.name}".to_sym
+
+            properties[property_name] || begin
+              # create the property within the correct repository
+              DataMapper.repository(repository_name) do
+                model.property(property_name, target_property.to_child_key, source_key_options(target_property))
+              end
+            end
+          end
+
+          @child_key = properties.class.new(source_key).freeze
+        end
+
+        # @api semipublic
+        alias_method :source_key, :child_key
+
+        # Initialize the foreign key property this "many to one"
+        # relationship uses to persist itself
+        #
+        # @return [self]
+        #
+        # @api public
+        def finalize
+          child_key
+          self
+        end
+
+        # Returns a hash of conditions that scopes query that fetches
+        # target object
+        #
+        # @return [Hash]
+        #   Hash of conditions that scopes query
+        #
+        # @api private
+        def source_scope(source)
+          if source.kind_of?(Resource)
+            Query.target_conditions(source, source_key, target_key)
+          else
+            super
+          end
+        end
+
+        # Returns a Resource 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)
+
+          # If the target key is equal to the model key, we can use the
+          # Model#get so the IdentityMap is used
+          if target_key == target_model.key
+            target = target_model.get(*source_key.get!(source))
+            if query.conditions.matches?(target)
+              target
+            else
+              nil
+            end
+          else
+            target_model.first(query)
+          end
+        end
+
+        # Loads and returns association target (ex.: author) for given source resource
+        # (ex.: article)
+        #
+        # @param  source  [DataMapper::Resource]
+        #   source object (ex.: instance of article)
+        # @param  other_query  [DataMapper::Query]
+        #   Query options
+        #
+        # @api semipublic
+        def get(source, query = nil)
+          lazy_load(source)
+
+          if query
+            collection = get_collection(source)
+            collection.first(query) if collection
+          else
+            get!(source)
+          end
+        end
+
+        def get_collection(source)
+          target = get!(source)
+          target.collection_for_self if target
+        end
+
+        # Sets value of association target (ex.: author) for given source resource
+        # (ex.: article)
+        #
+        # @param source [DataMapper::Resource]
+        #   source object (ex.: instance of article)
+        #
+        # @param target [DataMapper::Resource]
+        #   target object (ex.: instance of author)
+        #
+        # @api semipublic
+        def set(source, target)
+          target = typecast(target)
+          source_key.set(source, target_key.get(target))
+          set!(source, target)
+        end
+
+        # @api semipublic
+        def default_for(source)
+          typecast(super)
+        end
+
+        # 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)
+          source_key_different = source_key_different?(source)
+
+          if (loaded?(source) && !source_key_different) || !valid_source?(source)
+            return
+          end
+
+          # SEL: load all related resources in the source collection
+          if source.saved? && (collection = source.collection).size > 1
+            eager_load(collection)
+          end
+
+          if !loaded?(source) || (source_key_dirty?(source) && source.saved?)
+            set!(source, resource_for(source))
+          elsif loaded?(source) && source_key_different
+            source_key.set(source, target_key.get!(get!(source)))
+          end
+        end
+
+        private
+
+        # Initializes the relationship, always using max cardinality of 1.
+        #
+        # @api semipublic
+        def initialize(name, source_model, target_model, options = {})
+          if options.key?(:nullable)
+            raise ":nullable is deprecated, use :required instead (#{caller[2]})"
+          end
+
+          @required      = options.fetch(:required, true)
+          @key           = options.fetch(:key,      false)
+          @unique        = options.fetch(:unique,   false)
+          target_model ||= DataMapper::Inflector.camelize(name)
+          options        = { :min => @required ? 1 : 0, :max => 1 }.update(options)
+          super
+        end
+
+        # 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
+
+        # @api private
+        def typecast(target)
+          if target.kind_of?(Hash)
+            target_model.new(target)
+          else
+            target
+          end
+        end
+
+        # Returns the inverse relationship class
+        #
+        # @api private
+        def inverse_class
+          OneToMany::Relationship
+        end
+
+        # Returns the inverse relationship name
+        #
+        # @api private
+        def inverse_name
+          name = super
+          return name if name
+
+          name = DataMapper::Inflector.demodulize(source_model.name)
+          name = DataMapper::Inflector.underscore(name)
+          name = DataMapper::Inflector.pluralize(name)
+          name.to_sym
+        end
+
+        # @api private
+        def source_key_options(target_property)
+          DataMapper::Ext::Hash.only(target_property.options, :length, :precision, :scale, :min, :max).update(
+            :index    => name,
+            :required => required?,
+            :key      => key?,
+            :unique   => @unique
+          )
+        end
+
+        # @api private
+        def child_properties
+          source_key.map { |property| property.name }
+        end
+
+        # @api private
+        def source_key_different?(source)
+          source_key.get!(source) != target_key.get!(get!(source))
+        end
+
+        # @api private
+        def source_key_dirty?(source)
+          source.dirty_attributes.keys.any? { |property| source_key.include?(property) }
+        end
+      end # class Relationship
+    end # module ManyToOne
+  end # module Associations
+end # module DataMapper

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

@@ -0,0 +1,348 @@
+module DataMapper
+  module Associations
+    module OneToMany #:nodoc:
+      class Relationship < Associations::Relationship
+        # @api semipublic
+        alias_method :target_repository_name, :child_repository_name
+
+        # @api semipublic
+        alias_method :target_model, :child_model
+
+        # @api semipublic
+        alias_method :source_repository_name, :parent_repository_name
+
+        # @api semipublic
+        alias_method :source_model, :parent_model
+
+        # @api semipublic
+        alias_method :source_key, :parent_key
+
+        # @api semipublic
+        def child_key
+          inverse.child_key
+        end
+
+        # @api semipublic
+        alias_method :target_key, :child_key
+
+        # 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)
+
+          collection = collection_class.new(query)
+          collection.relationship = self
+          collection.source       = source
+
+          # make the collection empty if the source is new
+          collection.replace([]) if source.new?
+
+          collection
+        end
+
+        # Loads and returns association targets (ex.: articles) for given source resource
+        # (ex.: author)
+        #
+        # @api semipublic
+        def get(source, query = nil)
+          lazy_load(source)
+          collection = get_collection(source)
+          query ? collection.all(query) : collection
+        end
+
+        # @api private
+        def get_collection(source)
+          get!(source)
+        end
+
+        # Sets value of association targets (ex.: paragraphs) for given source resource
+        # (ex.: article)
+        #
+        # @api semipublic
+        def set(source, targets)
+          lazy_load(source)
+          get!(source).replace(targets)
+        end
+
+        # @api private
+        def set_collection(source, target)
+          set!(source, target)
+        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)
+          return if loaded?(source)
+
+          # SEL: load all related resources in the source collection
+          if source.saved? && (collection = source.collection).size > 1
+            eager_load(collection)
+          end
+
+          unless loaded?(source)
+            set!(source, collection_for(source))
+          end
+        end
+
+        # initialize the inverse "many to one" relationships explicitly before
+        # initializing other relationships. This makes sure that foreign key
+        # properties always appear in the order they were declared.
+        #
+        # @return [self]
+        #
+        # @api public
+        def finalize
+          child_model.relationships.each do |relationship|
+            # TODO: should this check #inverse?
+            #   relationship.child_key if inverse?(relationship)
+            if relationship.kind_of?(Associations::ManyToOne::Relationship)
+              relationship.finalize
+            end
+          end
+          inverse.finalize
+          self
+        end
+
+        # @api semipublic
+        def default_for(source)
+          collection_for(source).replace(Array(super))
+        end
+
+        private
+
+        # @api semipublic
+        def initialize(name, target_model, source_model, options = {})
+          target_model ||= DataMapper::Inflector.camelize(DataMapper::Inflector.singularize(name.to_s))
+          options        = { :min => 0, :max => source_model.n }.update(options)
+          super
+        end
+
+        # 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)
+          set!(source, collection_for(source, query).set(targets))
+        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 || DataMapper::Inflector.underscore(DataMapper::Inflector.demodulize(source_model.name)).to_sym
+        end
+
+        # @api private
+        def child_properties
+          super || parent_key.map do |parent_property|
+            "#{inverse_name}_#{parent_property.name}".to_sym
+          end
+        end
+      end # class Relationship
+
+      class Collection < DataMapper::Collection
+        # @api private
+        attr_accessor :relationship
+
+        # @api private
+        attr_accessor :source
+
+        # @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
+
+        # @api private
+        def _create(*)
+          assert_source_saved 'The source must be saved before creating a resource'
+          super
+        end
+
+        # @api private
+        def _save(execute_hooks = true)
+          assert_source_saved 'The source must be saved before saving the collection'
+
+          # update removed resources to not reference the source
+          @removed.all? { |resource| resource.destroyed? || resource.__send__(execute_hooks ? :save : :save!) } && super
+        end
+
+        # @api private
+        def lazy_load
+          if source.saved?
+            super
+          end
+        end
+
+        # @api private
+        def new_collection(query, resources = nil, &block)
+          collection = self.class.new(query, &block)
+
+          collection.relationship = relationship
+          collection.source       = source
+
+          resources ||= filter(query) if loaded?
+
+          # set the resources after the relationship and source are set
+          if resources
+            collection.set(resources)
+          end
+
+          collection
+        end
+
+        # @api private
+        def resource_added(resource)
+          resource = initialize_resource(resource)
+          inverse_set(resource, source)
+          super
+        end
+
+        # @api private
+        def resource_removed(resource)
+          inverse_set(resource, nil)
+          super
+        end
+
+        # @api private
+        def inverse_set(source, target)
+          unless source.readonly?
+            relationship.inverse.set(source, target)
+          end
+        end
+
+        # @api private
+        def assert_source_saved(message)
+          unless source.saved?
+            raise UnsavedParentError, message
+          end
+        end
+      end # class Collection
+    end # module OneToMany
+  end # module Associations
+end # module DataMapper