sbf-dm-core 1.3.0.beta

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

@@ -0,0 +1,282 @@
+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.is_a?(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))
+            target if query.conditions.matches?(target)
+          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  query  [DataMapper::Query]
+        #   Query options
+        #
+        # @api semipublic
+        def get(source, query = nil)
+          lazy_load(source)
+
+          if query
+            collection = get_collection(source)
+            collection&.first(query)
+          else
+            get!(source)
+          end
+        end
+
+        def get_collection(source)
+          target = get!(source)
+          target&.collection_for_self
+        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)
+
+          return if (loaded?(source) && !source_key_different) || !valid_source?(source)
+
+          # 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
+
+        # Initializes the relationship, always using max cardinality of 1.
+        #
+        # @api semipublic
+        private def initialize(name, source_model, target_model, options = {})
+          raise ":nullable is deprecated, use :required instead (#{caller[2]})" if options.key?(:nullable)
+
+          @required      = options.fetch(:required, true)
+          @key           = options.fetch(:key,      false)
+          @unique        = options.fetch(:unique,   false)
+          @unique_index  = options.fetch(:unique_index, @unique)
+          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
+        private def eager_load_targets(source, targets, _query)
+          set(source, targets.first)
+        end
+
+        # @api private
+        private def typecast(target)
+          if target.is_a?(Hash)
+            target_model&.new(target)
+          else
+            target
+          end
+        end
+
+        # Returns the inverse relationship class
+        #
+        # @api private
+        private def inverse_class
+          OneToMany::Relationship
+        end
+
+        # Returns the inverse relationship name
+        #
+        # @api private
+        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
+        private def source_key_options(target_property)
+          DataMapper::Ext::Hash.only(target_property.options, :length, :precision, :scale).update(
+            index: name,
+            required: required?,
+            key: key?,
+            unique: @unique,
+            unique_index: @unique_index
+          )
+        end
+
+        # @api private
+        private def child_properties
+          source_key.map(&:name)
+        end
+
+        # @api private
+        private def source_key_different?(source)
+          source_key.get!(source) != target_key.get!(get!(source))
+        end
+
+        # @api private
+        private def source_key_dirty?(source)
+          source.dirty_attributes.keys.any? { |property| source_key.include?(property) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,332 @@
+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
+
+          set!(source, collection_for(source)) unless loaded?(source)
+        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)
+            relationship.finalize if relationship.is_a?(Associations::ManyToOne::Relationship)
+          end
+          inverse.finalize
+          self
+        end
+
+        # @api semipublic
+        def default_for(source)
+          collection_for(source).replace(Array(super))
+        end
+
+        # @api semipublic
+        private 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
+        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
+        private def collection_class
+          OneToMany::Collection
+        end
+
+        # Returns the inverse relationship class
+        #
+        # @api private
+        private def inverse_class
+          ManyToOne::Relationship
+        end
+
+        # Returns the inverse relationship name
+        #
+        # @api private
+        private def inverse_name
+          super || DataMapper::Inflector.underscore(DataMapper::Inflector.demodulize(source_model&.name)).to_sym
+        end
+
+        # @api private
+        private def child_properties
+          super || parent_key.map do |parent_property|
+            "#{inverse_name}_#{parent_property.name}".to_sym
+          end
+        end
+      end
+
+      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] *
+        #   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 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 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
+
+        # @api private
+        private def _create(*)
+          assert_source_saved 'The source must be saved before creating a resource'
+          super
+        end
+
+        # @api private
+        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
+        private def lazy_load
+          super if source.saved?
+        end
+
+        # @api private
+        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
+          collection.set(resources) if resources
+
+          collection
+        end
+
+        # @api private
+        private def resource_added(resource)
+          resource = initialize_resource(resource)
+          inverse_set(resource, source)
+          super
+        end
+
+        # @api private
+        private def resource_removed(resource)
+          inverse_set(resource, nil)
+          super
+        end
+
+        # @api private
+        private def inverse_set(source, target)
+          relationship.inverse.set(source, target) unless source.readonly?
+        end
+
+        # @api private
+        private def assert_source_saved(message)
+          raise UnsavedParentError, message unless source.saved?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module DataMapper
+  module Associations
+    module OneToOne # :nodoc:
+      class Relationship < Associations::Relationship
+        %w(public protected private).map do |visibility|
+          methods = superclass.send("#{visibility}_instance_methods", false) |
+                    DataMapper::Subject.send("#{visibility}_instance_methods", false)
+
+          methods.each do |method|
+            undef_method method.to_sym unless method.to_s == 'initialize'
+          end
+        end
+
+        # Loads (if necessary) and returns association target
+        # for given source
+        #
+        # @api semipublic
+        def get(source, query = nil)
+          relationship.get(source, query).first
+        end
+
+        # Get the resource directly
+        #
+        # @api semipublic
+        def get!(source)
+          collection = relationship.get!(source)
+          collection&.first
+        end
+
+        # Sets and returns association target
+        # for given source
+        #
+        # @api semipublic
+        def set(source, target)
+          relationship.set(source, [target].compact).first
+        end
+
+        # Sets the resource directly
+        #
+        # @api semipublic
+        def set!(source, target)
+          set(source, target)
+        end
+
+        # @api semipublic
+        def default_for(source)
+          relationship.default_for(source).first
+        end
+
+        # @api public
+        def kind_of?(klass)
+          super || relationship.is_a?(klass)
+        end
+
+        # @api public
+        def instance_of?(klass)
+          super || relationship.instance_of?(klass)
+        end
+
+        # @api public
+        def respond_to?(method, include_private = false)
+          super || relationship.respond_to?(method, include_private)
+        end
+
+        attr_reader :relationship
+
+        # Initializes the relationship. Always assumes target model class is
+        # a camel cased association name.
+        #
+        # @api semipublic
+        private def initialize(name, target_model, source_model, options = {})
+          klass = options.key?(:through) ? ManyToMany::Relationship : OneToMany::Relationship
+          target_model ||= DataMapper::Inflector.camelize(name).freeze
+          @relationship = klass.new(name, target_model, source_model, options)
+        end
+
+        # @api private
+        private def method_missing(method, *args, &block)
+          relationship.send(method, *args, &block)
+        end
+      end
+    end
+  end
+end