rom 3.3.3 → 4.0.0.beta1

data/lib/rom/relation/loaded.rb

@@ -1,127 +0,0 @@
-module ROM
-  class Relation
-    # Materializes a relation and exposes interface to access the data
-    #
-    # @api public
-    class Loaded
-      include Enumerable
-
-      # Coerce loaded relation to an array
-      #
-      # @return [Array]
-      #
-      # @api public
-      alias_method :to_ary, :to_a
-
-      # Source relation
-      #
-      # @return [Relation]
-      #
-      # @api private
-      attr_reader :source
-
-      # Materialized relation
-      #
-      # @return [Object]
-      #
-      # @api private
-      attr_reader :collection
-
-      # @api private
-      def initialize(source, collection = source.to_a)
-        @source = source
-        @collection = collection
-      end
-
-      # Yield relation tuples
-      #
-      # @yield [Hash]
-      #
-      # @api public
-      def each(&block)
-        return to_enum unless block
-        collection.each { |tuple| yield(tuple) }
-      end
-
-      # Returns a single tuple from the relation if there is one.
-      #
-      # @raise [ROM::TupleCountMismatchError] if the relation contains more than
-      #   one tuple
-      #
-      # @api public
-      def one
-        if collection.count > 1
-          raise(
-            TupleCountMismatchError,
-            'The relation consists of more than one tuple'
-          )
-        else
-          collection.first
-        end
-      end
-
-      # Like [one], but additionally raises an error if the relation is empty.
-      #
-      # @raise [ROM::TupleCountMismatchError] if the relation does not contain
-      #   exactly one tuple
-      #
-      # @api public
-      def one!
-        one || raise(
-          TupleCountMismatchError,
-          'The relation does not contain any tuples'
-        )
-      end
-
-      # Return a list of values under provided key
-      #
-      # @example
-      #   all_users = rom.relations[:users].call
-      #   all_users.pluck(:name)
-      #   # ["Jane", "Joe"]
-      #
-      # @param [Symbol] key The key name
-      #
-      # @return [Array]
-      # @raises KeyError when provided key doesn't exist in any of the tuples
-      #
-      # @api public
-      def pluck(key)
-        map { |tuple| tuple.fetch(key) }
-      end
-
-      # Pluck primary key values
-      #
-      # This method *may not work* with adapters that don't provide relations
-      # that have primary key configured
-      #
-      # @example
-      #   users = rom.relations[:users].call
-      #   users.primary_keys
-      #   # [1, 2, 3]
-      #
-      # @return [Array]
-      #
-      # @api public
-      def primary_keys
-        pluck(source.primary_key)
-      end
-
-      # Return if loaded relation is empty
-      #
-      # @return [TrueClass,FalseClass]
-      #
-      # @api public
-      def empty?
-        collection.empty?
-      end
-
-      # Return a loaded relation with a new collection
-      #
-      # @api public
-      def new(collection)
-        self.class.new(source, collection)
-      end
-    end
-  end
-end

data/lib/rom/relation/materializable.rb

@@ -1,66 +0,0 @@
-module ROM
-  class Relation
-    # Interface for objects that can be materialized into a loaded relation
-    #
-    # @api public
-    module Materializable
-      # @abstract
-      #
-      # @api public
-      def call(*)
-        raise NotImplementedError, "#{self.class}#call must be implemented"
-      end
-
-      # Coerce the relation to an array
-      #
-      # @return [Array]
-      #
-      # @api public
-      def to_a
-        call.to_a
-      end
-      alias_method :to_ary, :to_a
-
-      # Yield relation tuples
-      #
-      # @yield [Hash,Object]
-      #
-      # @api public
-      def each(&block)
-        return to_enum unless block
-        to_a.each { |tuple| yield(tuple) }
-      end
-
-      # Delegate to loaded relation and return one object
-      #
-      # @return [Object]
-      #
-      # @see Loaded#one
-      #
-      # @api public
-      def one
-        call.one
-      end
-
-      # Delegate to loaded relation and return one object
-      #
-      # @return [Object]
-      #
-      # @see Loaded#one
-      #
-      # @api public
-      def one!
-        call.one!
-      end
-
-      # Return first tuple from a relation coerced to an array
-      #
-      # @return [Object]
-      #
-      # @api public
-      def first
-        to_a.first
-      end
-    end
-  end
-end

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/view_dsl.rb

@@ -1,64 +0,0 @@
-module ROM
-  class Relation
-    # ViewDSL is exposed in `Relation.view` method
-    #
-    # This is used to establish pre-defined relation views with explicit schemas.
-    # Such views can be used to compose relations together, even from multiple
-    # adapters.
-    #
-    # @api public
-    class ViewDSL
-      # @!attribute [r] name
-      #   @return [Symbol] The view name (relation method)
-      attr_reader :name
-
-      # @!attribute [r] relation_block
-      #   @return [Proc] The relation block that will be evaluated by the view method
-      attr_reader :relation_block
-
-      # @!attribute [r] new_schema
-      #   @return [Proc] The schema proc returned by the schema DSL
-      attr_reader :new_schema
-
-      # @api private
-      def initialize(name, schema, &block)
-        @name = name
-        @schema = schema
-        @new_schema = nil
-        @relation_block = nil
-        instance_eval(&block)
-      end
-
-      # Define a schema for a relation view
-      #
-      # @return [Proc]
-      #
-      # @see Relation::ClassInterface.view
-      #
-      # @api public
-      def schema(&block)
-        @new_schema = -> relations { @schema.with(relations: relations).instance_exec(&block) }
-      end
-
-      # Define a relation block for a relation view
-      #
-      # @return [Proc]
-      #
-      # @see Relation::ClassInterface.view
-      #
-      # @api public
-      def relation(&block)
-        @relation_block = lambda(&block)
-      end
-
-      # Return procs captured by the DSL
-      #
-      # @return [Array]
-      #
-      # @api private
-      def call
-        [name, new_schema, relation_block]
-      end
-    end
-  end
-end

data/lib/rom/relation.rb

@@ -1,250 +0,0 @@
-require 'dry/core/class_attributes'
-require 'dry/core/deprecations'
-
-require 'rom/initializer'
-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
-  # can forward methods 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.
-  #
-  # Individual adapters sets up their relation classes and provide different APIs
-  # depending on their persistence backend.
-  #
-  # Vanilla Relation class doesn't have APIs that are specific to ROM container setup.
-  # When adapter Relation class inherits from this class, these APIs are added automatically,
-  # so that they can be registered within a container.
-  #
-  # @see ROM::Relation::ClassInterface
-  #
-  # @api public
-  class Relation
-    # Default no-op output schema which is called in `Relation#each`
-    NOOP_OUTPUT_SCHEMA = -> tuple { tuple }.freeze
-
-    extend Initializer
-    extend ClassInterface
-    extend Dry::Core::Deprecations[:rom]
-
-    extend Dry::Core::ClassAttributes
-    defines :schema_class, :schema_inferrer, :schema_dsl
-
-    schema_dsl Schema::DSL
-    schema_class Schema
-    schema_inferrer Schema::DEFAULT_INFERRER
-
-    include Dry::Equalizer(:dataset)
-    include Materializable
-    include Pipeline
-
-    # @!attribute [r] dataset
-    #   @return [Object] dataset used by the relation provided by relation's gateway
-    #   @api public
-    param :dataset
-
-    # @!attribute [r] mappers
-    #   @return [MapperRegistry] an optional mapper registry (empty by default)
-    option :mappers, default: -> { MapperRegistry.new }
-
-    # @!attribute [r] schema
-    #   @return [Schema] relation schema, defaults to class-level canonical
-    #                    schema (if it was defined) and sets an empty one as
-    #                    the fallback
-    #   @api public
-    option :schema, default: -> { self.class.default_schema(self) }
-
-    # @!attribute [r] input_schema
-    #   @return [Object#[]] tuple processing function, uses schema or defaults to Hash[]
-    #   @api private
-    option :input_schema, default: -> { schema? ? schema.to_input_hash : Hash }
-
-    # @!attribute [r] output_schema
-    #   @return [Object#[]] tuple processing function, uses schema or defaults to NOOP_OUTPUT_SCHEMA
-    #   @api private
-    option :output_schema, default: -> {
-      schema.any?(&:read?) ? schema.to_output_hash : NOOP_OUTPUT_SCHEMA
-    }
-
-    # Return schema attribute
-    #
-    # @example accessing canonical attribute
-    #   users[:id]
-    #   # => #<ROM::SQL::Attribute[Integer] primary_key=true name=:id source=ROM::Relation::Name(users)>
-    #
-    # @example accessing joined attribute
-    #   tasks_with_users = tasks.join(users).select_append(tasks[:title])
-    #   tasks_with_users[:title, :tasks]
-    #   # => #<ROM::SQL::Attribute[String] primary_key=false name=:title source=ROM::Relation::Name(tasks)>
-    #
-    # @return [Schema::Attribute]
-    #
-    # @api public
-    def [](name)
-      schema[name]
-    end
-
-    # Yields relation tuples
-    #
-    # Every tuple is processed through Relation#output_schema, it's a no-op by default
-    #
-    # @yield [Hash]
-    #
-    # @return [Enumerator] if block is not provided
-    #
-    # @api public
-    def each(&block)
-      return to_enum unless block
-      dataset.each { |tuple| yield(output_schema[tuple]) }
-    end
-
-    # Composes with other relations
-    #
-    # @param [Array<Relation>] others The other relation(s) to compose with
-    #
-    # @return [Relation::Graph]
-    #
-    # @api public
-    def graph(*others)
-      Graph.build(self, others)
-    end
-    deprecate :combine, :graph
-
-    # 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.empty?
-    end
-
-    # Return a new relation with provided dataset and additional options
-    #
-    # Use this method whenever you need to use dataset API to get a new dataset
-    # and you want to return a relation back. Typically relation API should be
-    # enough though. If you find yourself using this method, it might be worth
-    # to consider reporting an issue that some dataset functionality is not available
-    # through relation API.
-    #
-    # @example with a new dataset
-    #   users.new(users.dataset.some_method)
-    #
-    # @example with a new dataset and options
-    #   users.new(users.dataset.some_method, other: 'options')
-    #
-    # @param [Object] dataset
-    # @param [Hash] new_opts Additional options
-    #
-    # @api public
-    def new(dataset, new_opts = EMPTY_HASH)
-      if new_opts.empty?
-        opts = options
-      elsif new_opts.key?(:schema)
-        opts = options.reject { |k, _| k == :input_schema || k == :output_schema }.merge(new_opts)
-      else
-        opts = options.merge(new_opts)
-      end
-
-      self.class.new(dataset, opts)
-    end
-
-    # Returns a new instance with the same dataset but new options
-    #
-    # @example
-    #   users.with(output_schema: -> tuple { .. })
-    #
-    # @param new_options [Hash]
-    #
-    # @return [Relation]
-    #
-    # @api private
-    def with(new_options)
-      new(dataset, options.merge(new_options))
-    end
-
-    # Return all registered relation schemas
-    #
-    # This holds all schemas defined via `view` DSL
-    #
-    # @return [Hash<Symbol=>Schema>]
-    #
-    # @api public
-    def schemas
-      @schemas ||= self.class.schemas
-    end
-
-    # Return schema's association set (empty by default)
-    #
-    # @return [AssociationSet] Schema's association set (empty by default)
-    #
-    # @api public
-    def associations
-      @associations ||= schema.associations
-    end
-
-    private
-
-    # Hook used by `Pipeline` to get the class that should be used for composition
-    #
-    # @return [Class]
-    #
-    # @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