rom 5.2.4 → 6.0.0.alpha1

data/lib/rom/associations/many_to_many.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "rom/types"
+require "rom/associations/abstract"
+
+module ROM
+  module Associations
+    # Abstract many-to-many association type
+    #
+    # @api public
+    class ManyToMany < Abstract
+      # @!attribute [r] join_relation
+      #   @return [Relation] Intermediate join relation
+      attr_reader :join_relation
+
+      # @api private
+      def initialize(*)
+        super
+        @join_relation = relations[through]
+      end
+      ruby2_keywords(:initialize) if respond_to?(:ruby2_keywords, true)
+
+      # Adapters should implement this method
+      #
+      # @abstract
+      #
+      # @api public
+      def call(*)
+        raise NotImplementedError
+      end
+
+      # Return configured or inferred FK name
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      def foreign_key
+        definition.foreign_key || join_relation.foreign_key(source.name)
+      end
+
+      # Return join-relation name
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      def through
+        definition.through
+      end
+
+      # Return parent's relation combine keys
+      #
+      # @return [Hash<Symbol=>Symbol>]
+      #
+      # @api private
+      def parent_combine_keys
+        target.associations[source.name].combine_keys.to_a.flatten(1)
+      end
+
+      # Associate child tuples with the provided parent
+      #
+      # @param [Array<Hash>] children An array with child tuples
+      # @param [Array,Hash] parent An array with parent tuples or a single tuple
+      #
+      # @return [Array<Hash>]
+      #
+      # @api private
+      def associate(children, parent)
+        ((spk, sfk), (tfk, tpk)) = join_key_map
+
+        case parent
+        when Array
+          parent.map { |p| associate(children, p) }.flatten(1)
+        else
+          children.map { |tuple|
+            {sfk => tuple.fetch(spk), tfk => parent.fetch(tpk)}
+          }
+        end
+      end
+
+      protected
+
+      # Primary key name on the source side
+      #
+      # @return [Symbol]
+      #
+      # @api protected
+      def source_key
+        source.primary_key
+      end
+
+      # Foreign key name on the target side
+      #
+      # @return [Symbol]
+      #
+      # @api protected
+      def target_key
+        foreign_key
+      end
+
+      # Return association for many-to-many-through
+      #
+      # @return [Association]
+      #
+      # @api protected
+      def join_assoc
+        if join_relation.associations.key?(through.assoc_name)
+          join_relation.associations[through.assoc_name]
+        else
+          join_relation.associations[through.target]
+        end
+      end
+
+      # Return a [pk, fk] mapping for source/target relations
+      #
+      # @return [Array<Symbol>]
+      #
+      # @api protected
+      def join_key_map
+        left = super
+        right = join_assoc.join_key_map
+
+        [left, right]
+      end
+
+      memoize :foreign_key, :join_assoc, :join_key_map
+    end
+  end
+end

data/lib/rom/associations/many_to_one.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "rom/associations/abstract"
+
+module ROM
+  module Associations
+    # Abstract many-to-one association type
+    #
+    # @api public
+    class ManyToOne < Abstract
+      # Adapters must implement this method
+      #
+      # @abstract
+      #
+      # @api public
+      def call(*)
+        raise NotImplementedError
+      end
+
+      # Return configured or inferred FK name
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      def foreign_key
+        definition.foreign_key || source.foreign_key(target.name)
+      end
+
+      # Associate child with a parent
+      #
+      # @param [Hash] child The child tuple
+      # @param [Hash] parent The parent tuple
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def associate(child, parent)
+        fk, pk = join_key_map
+        child.merge(fk => parent.fetch(pk))
+      end
+
+      protected
+
+      # Return foreign key on the source side
+      #
+      # @return [Symbol]
+      #
+      # @api protected
+      def source_key
+        foreign_key
+      end
+
+      # Return primary key on the target side
+      #
+      # @return [Symbol]
+      #
+      # @api protected
+      def target_key
+        target.schema.primary_key_name
+      end
+
+      memoize :foreign_key
+    end
+  end
+end

data/lib/rom/associations/one_to_many.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "rom/associations/abstract"
+
+module ROM
+  module Associations
+    # Abstract one-to-many association
+    #
+    # @api public
+    class OneToMany < Abstract
+      # Adapters must implement this method
+      #
+      # @abstract
+      #
+      # @api public
+      def call(*)
+        raise NotImplementedError
+      end
+
+      # Return configured or inferred FK name
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      def foreign_key
+        definition.foreign_key || target.foreign_key(source.name)
+      end
+
+      # Associate child tuple with a parent
+      #
+      # @param [Hash] child The child tuple
+      # @param [Hash] parent The parent tuple
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def associate(child, parent)
+        pk, fk = join_key_map
+        child.merge(fk => parent.fetch(pk))
+      end
+
+      protected
+
+      # Return primary key on the source side
+      #
+      # @return [Symbol]
+      #
+      # @api protected
+      def source_key
+        source.schema.primary_key_name
+      end
+
+      # Return foreign key name on the target side
+      #
+      # @return [Symbol]
+      #
+      # @api protected
+      def target_key
+        foreign_key
+      end
+
+      memoize :foreign_key
+    end
+  end
+end

data/lib/rom/associations/one_to_one.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rom/associations/one_to_many"
+
+module ROM
+  module Associations
+    # Abstract one-to-one association type
+    #
+    # @api public
+    class OneToOne < OneToMany
+    end
+  end
+end

data/lib/rom/associations/one_to_one_through.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rom/associations/many_to_many"
+
+module ROM
+  module Associations
+    # Abstract one-to-one-through association type
+    #
+    # @api public
+    class OneToOneThrough < ManyToMany
+    end
+  end
+end

data/lib/rom/associations/through_identifier.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "rom/support/inflector"
+
+module ROM
+  module Associations
+    # @api private
+    class ThroughIdentifier
+      # @api private
+      attr_reader :source
+
+      # @api private
+      attr_reader :target
+
+      # @api private
+      attr_reader :assoc_name
+
+      # @api private
+      def self.[](source, target, assoc_name = nil, inflector: Inflector)
+        new(source, target, assoc_name || default_assoc_name(target, inflector: inflector))
+      end
+
+      # @api private
+      def self.default_assoc_name(relation, inflector:)
+        inflector.singularize(relation).to_sym
+      end
+
+      # @api private
+      def initialize(source, target, assoc_name)
+        @source = source
+        @target = target
+        @assoc_name = assoc_name
+      end
+
+      # @api private
+      def to_sym
+        source
+      end
+    end
+  end
+end