rom 2.0.2 → 4.2.1

data/lib/rom/relation/name.rb

@@ -1,102 +0,0 @@
-require 'dry/equalizer'
-require 'concurrent/map'
-
-module ROM
-  class Relation
-    # Relation name container
-    #
-    # This is a simple struct with two fields.
-    # It handles both relation registration name (i.e. Symbol) and dataset name.
-    # The reason we need it is a simplification of passing around these two objects.
-    # It is quite common to have a dataset named differently from a relation
-    # built on top if you are dealing with a legacy DB and often you need both
-    # to support things such as associations (rom-sql as an example).
-    #
-    # @api private
-    class Name
-      include Dry::Equalizer(:relation, :dataset)
-
-      # Coerce an object to a Name instance
-      #
-      # @return [ROM::Relation::Name]
-      #
-      # @api private
-      def self.[](*args)
-        cache.fetch_or_store(args.hash) do
-          relation, dataset = args
-
-          if relation.is_a?(Name)
-            relation
-          else
-            new(relation, dataset)
-          end
-        end
-      end
-
-      # @api private
-      def self.cache
-        @cache ||= Concurrent::Map.new
-      end
-
-      # Relation registration name
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      attr_reader :relation
-
-      # Underlying dataset name
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      attr_reader :dataset
-
-      # @api private
-      def initialize(relation, dataset = nil)
-        @relation = relation
-        @dataset = dataset || relation
-      end
-
-      # Return relation name
-      #
-      # @return [String]
-      #
-      # @api private
-      def to_s
-        if relation == dataset
-          relation.to_s
-        else
-          "#{relation} on #{dataset}"
-        end
-      end
-
-      # Alias for registration key implicitly called by ROM::Registry
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      def to_sym
-        relation
-      end
-
-      # Return inspected relation
-      #
-      # @return [String]
-      #
-      # @api private
-      def inspect
-        "#{self.class.name}(#{to_s})"
-      end
-
-      # Build a new name. Useful for Curried and other relation proxies
-      #
-      # @return [ROM::Relation::Name]
-      #
-      # @api private
-      def with(relation)
-        self.class[relation, dataset]
-      end
-    end
-  end
-end

data/lib/rom/relation.rb

@@ -1,172 +0,0 @@
-require 'rom/relation/class_interface'
-
-require 'rom/pipeline'
-require 'rom/mapper_registry'
-
-require 'rom/relation/loaded'
-require 'rom/relation/curried'
-require 'rom/relation/composite'
-require 'rom/relation/graph'
-require 'rom/relation/materializable'
-require 'rom/association_set'
-
-require 'rom/types'
-require 'rom/schema'
-
-module ROM
-  # Base relation class
-  #
-  # Relation is a proxy for the dataset object provided by the gateway. It
-  # forwards every method to the dataset, which is why the "native" interface of
-  # the underlying gateway is available in the relation. This interface,
-  # however, is considered private and should not be used outside of the
-  # relation instance.
-  #
-  # ROM builds sub-classes of this class for every relation defined in the
-  # environment for easy inspection and extensibility - every gateway can
-  # provide extensions for those sub-classes but there is always a vanilla
-  # relation instance stored in the schema registry.
-  #
-  # @api public
-  class Relation
-    extend ClassInterface
-
-    include Options
-    include Dry::Equalizer(:dataset)
-    include Materializable
-    include Pipeline
-
-    # @!attribute [r] mappers
-    #   @return [MapperRegistry] an optional mapper registry (empty by default)
-    option :mappers, reader: true, default: proc { MapperRegistry.new }
-
-    # @!attribute [r] schema_hash
-    #   @return [Object#[]] tuple processing function, uses schema or defaults to Hash[]
-    #   @api private
-    option :schema_hash, reader: true, default: -> relation {
-      relation.schema? ? Types::Coercible::Hash.schema(relation.schema.to_h) : Hash
-    }
-
-    # @!attribute [r] associations
-    #   @return [AssociationSet] Schema's association set (empty by default)
-    option :associations, reader: true, default: -> rel {
-      rel.schema? ? rel.schema.associations : Schema::EMPTY_ASSOCIATION_SET
-    }
-
-    # @!attribute [r] dataset
-    #   @return [Object] dataset used by the relation provided by relation's gateway
-    #   @api public
-    attr_reader :dataset
-
-    # @!attribute [r] schema
-    #   @return [Schema] returns relation schema object (if defined)
-    #   @api public
-    attr_reader :schema
-
-    # Initializes a relation object
-    #
-    # @param dataset [Object]
-    #
-    # @param options [Hash]
-    #   @option :mappers [MapperRegistry]
-    #   @option :schema_hash [#[]]
-    #   @option :associations [AssociationSet]
-    #
-    # @api public
-    def initialize(dataset, options = EMPTY_HASH)
-      @dataset = dataset
-      @schema = self.class.schema
-      super
-    end
-
-    # Yields relation tuples
-    #
-    # @yield [Hash]
-    # @return [Enumerator] if block is not provided
-    #
-    # @api public
-    def each(&block)
-      return to_enum unless block
-      dataset.each { |tuple| yield(tuple) }
-    end
-
-    # Composes with other relations
-    #
-    # @param *others [Array<Relation>] The other relation(s) to compose with
-    #
-    # @return [Relation::Graph]
-    #
-    # @api public
-    def combine(*others)
-      Graph.build(self, others)
-    end
-
-    # Loads relation
-    #
-    # @return [Relation::Loaded]
-    #
-    # @api public
-    def call
-      Loaded.new(self)
-    end
-
-    # Materializes a relation into an array
-    #
-    # @return [Array<Hash>]
-    #
-    # @api public
-    def to_a
-      to_enum.to_a
-    end
-
-    # Returns if this relation is curried
-    #
-    # @return [false]
-    #
-    # @api private
-    def curried?
-      false
-    end
-
-    # Returns if this relation is a graph
-    #
-    # @return [false]
-    #
-    # @api private
-    def graph?
-      false
-    end
-
-    # Returns true if a relation has schema defined
-    #
-    # @return [TrueClass, FalseClass]
-    #
-    # @api private
-    def schema?
-      ! schema.nil?
-    end
-
-    # Returns a new instance with the same dataset but new options
-    #
-    # @param new_options [Hash]
-    #
-    # @return [Relation]
-    #
-    # @api private
-    def with(new_options)
-      __new__(dataset, options.merge(new_options))
-    end
-
-    private
-
-    # @api private
-    def __new__(dataset, new_opts = EMPTY_HASH)
-      self.class.new(dataset, options.merge(new_opts))
-    end
-
-    # @api private
-    def composite_class
-      Relation::Composite
-    end
-  end
-end

data/lib/rom/relation_registry.rb

@@ -1,9 +0,0 @@
-module ROM
-  class RelationRegistry < Registry
-    def initialize(elements = {}, name = self.class.name)
-      super
-
-      yield(self, elements) if block_given?
-    end
-  end
-end

data/lib/rom/schema/dsl.rb

@@ -1,58 +0,0 @@
-require 'dry-equalizer'
-require 'rom/types'
-
-module ROM
-  # Relation schema
-  #
-  # @api public
-  class Schema
-    include Dry::Equalizer(:name, :attributes)
-    include Enumerable
-
-    attr_reader :name, :attributes, :inferrer
-
-    # @api public
-    class DSL < BasicObject
-      attr_reader :name, :attributes, :inferrer
-
-      # @api private
-      def initialize(name, inferrer, &block)
-        @name = name
-        @inferrer = inferrer
-        @attributes = nil
-
-        if block
-          instance_exec(&block)
-        elsif inferrer.nil?
-          raise ArgumentError,
-            'You must pass a block to define a schema or set an inferrer for automatic inferring'
-        end
-      end
-
-      # Defines a relation attribute with its type
-      #
-      # @see Relation.schema
-      #
-      # @api public
-      def attribute(name, type)
-        @attributes ||= {}
-        @attributes[name] = type.meta(name: name)
-      end
-
-      # Specify which key(s) should be the primary key
-      #
-      # @api public
-      def primary_key(*names)
-        names.each do |name|
-          attributes[name] = attributes[name].meta(primary_key: true)
-        end
-        self
-      end
-
-      # @api private
-      def call
-        Schema.new(name, attributes, inferrer: inferrer)
-      end
-    end
-  end
-end

data/lib/rom/schema.rb

@@ -1,89 +0,0 @@
-require 'dry-equalizer'
-
-require 'rom/support/constants'
-require 'rom/schema/dsl'
-require 'rom/association_set'
-
-module ROM
-  # Relation schema
-  #
-  # @api public
-  class Schema
-    EMPTY_ASSOCIATION_SET = AssociationSet.new(EMPTY_HASH).freeze
-
-    include Dry::Equalizer(:name, :attributes, :associations)
-    include Enumerable
-
-    # @!attribute [r] name
-    #   @return [Symbol] The name of this schema
-    attr_reader :name
-
-    # @!attribute [r] attributes
-    #   @return [Hash] The hash with schema attribute types
-    attr_reader :attributes
-
-    # @!attribute [r] associations
-    #   @return [AssociationSet] Optional association set (this is adapter-specific)
-    attr_reader :associations
-
-    # @!attribute [r] inferrer
-    #   @return [#call] An optional inferrer object used in `finalize!`
-    attr_reader :inferrer
-
-    # @!attribute [r] primary_key
-    #   @return [Array<Dry::Types::Definition] Primary key array
-    attr_reader :primary_key
-
-    alias_method :to_h, :attributes
-
-    # @api private
-    def initialize(name, attributes, inferrer: nil, associations: EMPTY_ASSOCIATION_SET)
-      @name = name
-      @attributes = attributes
-      @associations = associations
-      @inferrer = inferrer
-    end
-
-    # Iterate over schema's attributes
-    #
-    # @yield [Dry::Data::Type]
-    #
-    # @api public
-    def each(&block)
-      attributes.each_value(&block)
-    end
-
-    # Return attribute
-    #
-    # @api public
-    def [](name)
-      attributes.fetch(name)
-    end
-
-    # Return FK attribute for a given relation name
-    #
-    # @return [Dry::Types::Definition]
-    #
-    # @api public
-    def foreign_key(relation)
-      detect { |attr| attr.meta[:foreign_key] && attr.meta[:relation] == relation }
-    end
-
-    # This hook is called when relation is being build during container finalization
-    #
-    # When block is provided it'll be called just before freezing the instance
-    # so that additional ivars can be set
-    #
-    # @return [self]
-    #
-    # @api private
-    def finalize!(gateway = nil, &block)
-      return self if frozen?
-
-      @attributes = inferrer.call(name.dataset, gateway) if inferrer
-      @primary_key = select { |attr| attr.meta[:primary_key] == true }
-      block.call if block
-      freeze
-    end
-  end
-end

data/lib/rom/setup/auto_registration.rb

@@ -1,69 +0,0 @@
-require 'pathname'
-
-require 'rom/support/constants'
-require 'rom/support/inflector'
-require 'rom/support/options'
-
-require 'rom/setup/auto_registration_strategies/no_namespace'
-require 'rom/setup/auto_registration_strategies/with_namespace'
-require 'rom/setup/auto_registration_strategies/custom_namespace'
-
-module ROM
-  class AutoRegistration
-    include Options
-
-    option :namespace, reader: true, type: [TrueClass, FalseClass, String], default: true
-
-    option :component_dirs, reader: true, type: ::Hash, default: {
-      relations: :relations,
-      mappers: :mappers,
-      commands: :commands
-    }
-
-    attr_reader :globs, :directory
-
-    def initialize(directory, options = EMPTY_HASH)
-      super
-      @directory = Pathname(directory)
-      @globs = Hash[component_dirs.map { |component, directory|
-        [component, @directory.join("#{directory}/**/*.rb")]
-      }]
-    end
-
-    def relations
-      load_entities(:relations)
-    end
-
-    def commands
-      load_entities(:commands)
-    end
-
-    def mappers
-      load_entities(:mappers)
-    end
-
-    private
-
-    def load_entities(entity)
-      Dir[globs[entity]].map do |file|
-        require file
-        klass_name =
-          case namespace
-          when String
-            AutoRegistrationStrategies::CustomNamespace.new(
-              namespace: namespace, file: file
-            ).call
-          when TrueClass
-            AutoRegistrationStrategies::WithNamespace.new(
-              file: file, directory: directory
-            ).call
-          when FalseClass
-            AutoRegistrationStrategies::NoNamespace.new(
-              file: file, directory: directory, entity: component_dirs.fetch(entity)
-            ).call
-          end
-        Inflector.constantize(klass_name)
-      end
-    end
-  end
-end

data/lib/rom/setup/auto_registration_strategies/base.rb

@@ -1,11 +0,0 @@
-module ROM
-  module AutoRegistrationStrategies
-    class Base
-      include Options
-
-      option :file, reader: true, type: String
-
-      EXTENSION_REGEX = /\.rb$/.freeze
-    end
-  end
-end

data/lib/rom/setup/auto_registration_strategies/custom_namespace.rb

@@ -1,22 +0,0 @@
-require 'pathname'
-
-require 'rom/support/inflector'
-require 'rom/setup/auto_registration_strategies/base'
-
-module ROM
-  module AutoRegistrationStrategies
-    class CustomNamespace < Base
-      option :namespace, reader: true, type: String
-
-      def call
-        "#{namespace}::#{Inflector.camelize(filename)}"
-      end
-
-      private
-
-      def filename
-        Pathname(file).basename('.rb')
-      end
-    end
-  end
-end

data/lib/rom/setup/auto_registration_strategies/no_namespace.rb

@@ -1,19 +0,0 @@
-require 'pathname'
-
-require 'rom/support/inflector'
-require 'rom/setup/auto_registration_strategies/base'
-
-module ROM
-  module AutoRegistrationStrategies
-    class NoNamespace < Base
-      option :directory, reader: true, type: Pathname
-      option :entity, reader: true, type: Symbol
-
-      def call
-        Inflector.camelize(
-          file.sub(/^#{directory}\/#{entity}\//, '').sub(EXTENSION_REGEX, '')
-        )
-      end
-    end
-  end
-end

data/lib/rom/setup/auto_registration_strategies/with_namespace.rb

@@ -1,18 +0,0 @@
-require 'pathname'
-
-require 'rom/support/inflector'
-require 'rom/setup/auto_registration_strategies/base'
-
-module ROM
-  module AutoRegistrationStrategies
-    class WithNamespace < Base
-      option :directory, reader: true, type: Pathname
-
-      def call
-        Inflector.camelize(
-          file.sub(/^#{directory.dirname}\//, '').sub(EXTENSION_REGEX, '')
-        )
-      end
-    end
-  end
-end

data/lib/rom/setup/finalize/finalize_commands.rb

@@ -1,47 +0,0 @@
-require 'rom/support/registry'
-require 'rom/command_registry'
-
-module ROM
-  class Finalize
-    class FinalizeCommands
-      # Build command registry hash for provided relations
-      #
-      # @param [RelationRegistry] relations registry
-      # @param [Hash] gateways
-      # @param [Array] command_classes a list of command subclasses
-      #
-      # @api private
-      def initialize(relations, gateways, command_classes)
-        @relations = relations
-        @gateways = gateways
-        @command_classes = command_classes
-      end
-
-      # @return [Hash]
-      #
-      # @api private
-      def run!
-        registry = @command_classes.each_with_object({}) do |klass, h|
-          rel_name = klass.relation
-          next unless rel_name
-
-          relation = @relations[rel_name]
-          name = klass.register_as || klass.default_name
-
-          gateway = @gateways[relation.class.gateway]
-          gateway.extend_command_class(klass, relation.dataset)
-
-          klass.extend_for_relation(relation) if klass.restrictable
-
-          (h[rel_name] ||= {})[name] = klass.build(relation)
-        end
-
-        commands = registry.each_with_object({}) do |(name, rel_commands), h|
-          h[name] = CommandRegistry.new(name, rel_commands)
-        end
-
-        Registry.new(commands)
-      end
-    end
-  end
-end

data/lib/rom/setup/finalize/finalize_mappers.rb

@@ -1,36 +0,0 @@
-require 'rom/support/registry'
-
-module ROM
-  class Finalize
-    class FinalizeMappers
-      # @api private
-      def initialize(mapper_classes, mapper_objects)
-        @mapper_classes = mapper_classes
-        @mapper_objects = mapper_objects
-      end
-
-      # @api private
-      def run!
-        registry = @mapper_classes.each_with_object({}) do |klass, h|
-          name = klass.register_as || klass.relation
-          (h[klass.base_relation] ||= {})[name] = klass.build
-        end
-
-        registry_hash = registry.each_with_object({}).each { |(relation, mappers), h|
-          h[relation] = MapperRegistry.new(mappers)
-        }
-
-        @mapper_objects.each do |relation, mappers|
-          if registry_hash.key?(relation)
-            mappers_registry = registry_hash[relation]
-            mappers.each { |name, mapper| mappers_registry[name] = mapper }
-          else
-            registry_hash[relation] = MapperRegistry.new(mappers)
-          end
-        end
-
-        Registry.new(registry_hash)
-      end
-    end
-  end
-end