rom 2.0.2 → 4.2.1

data/lib/rom/relation/class_interface.rb

@@ -1,230 +0,0 @@
-require 'set'
-
-require 'rom/support/auto_curry'
-require 'rom/relation/curried'
-require 'rom/relation/name'
-require 'rom/schema'
-
-module ROM
-  class Relation
-    module ClassInterface
-      # Register adapter relation subclasses during setup phase
-      #
-      # In adition those subclasses are extended with an interface for accessing
-      # relation registry and to define `register_as` setting
-      #
-      # @api private
-      def inherited(klass)
-        super
-
-        klass.extend ClassMacros
-        klass.defines :adapter
-
-        if respond_to?(:adapter) && adapter.nil?
-          raise MissingAdapterIdentifierError,
-            "relation class +#{self}+ is missing the adapter identifier"
-        end
-
-        # Extend with functionality required by adapters *only* if this is a direct
-        # descendant of an adapter-specific relation subclass
-        return unless respond_to?(:adapter) && klass.superclass == ROM::Relation[adapter]
-
-        klass.class_eval do
-          use :registry_reader
-
-          defines :gateway, :dataset, :dataset_proc, :register_as, :schema_dsl, :schema_inferrer
-
-          gateway :default
-          schema_dsl Schema::DSL
-          schema_inferrer nil
-
-          dataset default_name
-
-          # Relation's dataset name
-          #
-          # In example a table name in an SQL database
-          #
-          # @return [Symbol]
-          #
-          # @api public
-          attr_reader :name
-
-          # Set dataset name
-          #
-          # If a block is passed it will be evaluated in the context of the dataset
-          # to define the default dataset which will be injected into a relation
-          # when setting up relation registry
-          #
-          # @example
-          #   class Relations::Users < ROM::Relation[:memory]
-          #     dataset :users
-          #   end
-          #
-          #   class Users < ROM::Relation[:memory]
-          #     dataset { sort_by(:id) }
-          #   end
-          #
-          # @param [Symbol] value The name of the dataset
-          #
-          # @api public
-          def self.dataset(value = Undefined, &block)
-            dataset_proc(block) if block
-            super
-          end
-
-          # Set or get name under which a relation will be registered
-          #
-          # This defaults to `dataset` or `default_name` for descendant relations
-          #
-          # @return [Symbol]
-          #
-          # @api public
-          def self.register_as(value = Undefined)
-            if value == Undefined
-              return @register_as if defined?(@register_as)
-
-              super_val = super()
-
-              if superclass == ROM::Relation[adapter]
-                super_val || dataset
-              else
-                super_val == dataset ? default_name : super_val
-              end
-            else
-              super
-            end
-          end
-
-          # @api private
-          def initialize(dataset, options = EMPTY_HASH)
-            @name = Name.new(self.class.register_as, self.class.dataset)
-            super
-          end
-
-          # Return name of the source gateway of this relation
-          #
-          # @return [Symbol]
-          #
-          # @api private
-          def gateway
-            self.class.gateway
-          end
-        end
-
-        klass.extend(AutoCurry)
-      end
-
-      # Return adapter-specific relation subclass
-      #
-      # @example
-      #   ROM::Relation[:memory]
-      #   # => ROM::Memory::Relation
-      #
-      # @return [Class]
-      #
-      # @api public
-      def [](adapter)
-        ROM.adapters.fetch(adapter).const_get(:Relation)
-      rescue KeyError
-        raise AdapterNotPresentError.new(adapter, :relation)
-      end
-
-      # Specify canonical schema for a relation
-      #
-      # With a schema defined commands will set up a type-safe input handler
-      # automatically
-      #
-      # @example
-      #   class Users < ROM::Relation[:sql]
-      #     schema do
-      #       attribute :id, Types::Serial
-      #       attribute :name, Types::String
-      #     end
-      #   end
-      #
-      #   # access schema
-      #   Users.schema
-      #
-      # @return [Schema]
-      #
-      # @param [Symbol] dataset An optional dataset name
-      # @param [Boolean] infer Whether to do an automatic schema inferring
-      #
-      # @api public
-      def schema(dataset = nil, infer: false, &block)
-        if defined?(@schema)
-          @schema
-        elsif block || infer
-          self.dataset(dataset) if dataset
-          self.register_as(self.dataset) unless register_as
-
-          name = Name[register_as, self.dataset]
-          inferrer = infer ? schema_inferrer : nil
-          dsl = schema_dsl.new(name, inferrer, &block)
-
-          @schema = dsl.call
-        end
-      end
-
-      # Dynamically define a method that will forward to the dataset and wrap
-      # response in the relation itself
-      #
-      # @example
-      #   class SomeAdapterRelation < ROM::Relation
-      #     forward :super_query
-      #   end
-      #
-      # @api public
-      def forward(*methods)
-        methods.each do |method|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method}(*args, &block)
-              __new__(dataset.__send__(:#{method}, *args, &block))
-            end
-          RUBY
-        end
-      end
-
-      # Include a registered plugin in this relation class
-      #
-      # @param [Symbol] plugin
-      # @param [Hash] options
-      # @option options [Symbol] :adapter (:default) first adapter to check for plugin
-      #
-      # @api public
-      def use(plugin, _options = EMPTY_HASH)
-        ROM.plugin_registry.relations.fetch(plugin, adapter).apply_to(self)
-      end
-
-      # Return default relation name used for `register_as` setting
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      def default_name
-        return unless name
-        Inflector.underscore(name).tr('/', '_').to_sym
-      end
-
-      # @api private
-      def curried
-        Curried
-      end
-
-      # @api private
-      def view_methods
-        ancestor_methods = ancestors.reject { |klass| klass == self }
-          .map(&:instance_methods).flatten
-
-        instance_methods - ancestor_methods + auto_curried_methods
-      end
-
-      # Hook to finalize a relation after its instance was created
-      #
-      # @api private
-      def finalize(_container, _relation)
-        # noop
-      end
-    end
-  end
-end

data/lib/rom/relation/composite.rb

@@ -1,46 +0,0 @@
-require 'rom/relation/loaded'
-require 'rom/relation/materializable'
-require 'rom/pipeline'
-
-module ROM
-  class Relation
-    # Left-to-right relation composition used for data-pipelining
-    #
-    # @api public
-    class Composite < Pipeline::Composite
-      include Materializable
-
-      # Call the pipeline by passing results from left to right
-      #
-      # Optional args are passed to the left object
-      #
-      # @return [Loaded]
-      #
-      # @api public
-      def call(*args)
-        relation = left.call(*args)
-        response = right.call(relation)
-
-        if response.is_a?(Loaded)
-          response
-        elsif relation.is_a?(Loaded)
-          relation.new(response)
-        else
-          Loaded.new(relation, response)
-        end
-      end
-      alias_method :[], :call
-
-      private
-
-      # @api private
-      #
-      # @see Pipeline::Proxy#decorate?
-      #
-      # @api private
-      def decorate?(response)
-        super || response.is_a?(Graph)
-      end
-    end
-  end
-end

data/lib/rom/relation/curried.rb

@@ -1,104 +0,0 @@
-require 'rom/support/options'
-
-require 'rom/pipeline'
-require 'rom/relation/name'
-require 'rom/relation/materializable'
-
-module ROM
-  class Relation
-    class Curried
-      include Options
-      include Materializable
-      include Pipeline
-
-      option :name, type: Symbol
-      option :arity, type: Integer, reader: true, default: -1
-      option :curry_args, type: Array, reader: true, default: EMPTY_ARRAY
-
-      attr_reader :relation
-
-      attr_reader :name
-
-      # @api private
-      def initialize(relation, options = EMPTY_HASH)
-        @relation = relation
-        @name = relation.name.with(options[:name])
-        super
-      end
-
-      # Load relation if args match the arity
-      #
-      # @return [Loaded,Lazy,Curried]
-      # @see Lazy#call
-      #
-      # @api public
-      def call(*args)
-        if arity != -1
-          all_args = curry_args + args
-
-          if arity == all_args.size
-            Loaded.new(relation.__send__(name.relation, *all_args))
-          else
-            __new__(relation, curry_args: all_args)
-          end
-        else
-          super
-        end
-      end
-      alias_method :[], :call
-
-      # @api public
-      def to_a
-        raise(
-          ArgumentError,
-          "#{relation.class}##{name.relation} arity is #{arity} " \
-          "(#{curry_args.size} args given)"
-        )
-      end
-      alias_method :to_ary, :to_a
-
-      # Return if this lazy relation is curried
-      #
-      # @return [true]
-      #
-      # @api private
-      def curried?
-        true
-      end
-
-      # @api private
-      def respond_to_missing?(name, include_private = false)
-        super || relation.respond_to?(name, include_private)
-      end
-
-      private
-
-      # @api private
-      def __new__(relation, new_opts = EMPTY_HASH)
-        Curried.new(relation, options.merge(new_opts))
-      end
-
-      # @api private
-      def composite_class
-        Relation::Composite
-      end
-
-      # @api private
-      def method_missing(meth, *args, &block)
-        if relation.respond_to?(meth)
-          response = relation.__send__(meth, *args, &block)
-
-          super if response.is_a?(self.class)
-
-          if response.is_a?(Relation) || response.is_a?(Graph)
-            __new__(response)
-          else
-            response
-          end
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/rom/relation/graph.rb

@@ -1,115 +0,0 @@
-require 'rom/relation/loaded'
-require 'rom/relation/composite'
-require 'rom/relation/materializable'
-require 'rom/pipeline'
-
-module ROM
-  class Relation
-    # Compose relations using join-keys
-    #
-    # @example
-    #   class Users < ROM::Relation[:memory]
-    #   end
-    #
-    #   class Tasks < ROM::Relation[:memory]
-    #     def for_users(users)
-    #       restrict(user: users.map { |user| user[:name] })
-    #     end
-    #   end
-    #
-    #   rom.relations[:users] << { name: 'Jane' }
-    #   rom.relations[:tasks] << { user: 'Jane', title: 'Do something' }
-    #
-    #   rom.relation(:users).combine(rom.relation(:tasks).for_users)
-    #
-    # @api public
-    class Graph
-      include Materializable
-      include Pipeline
-      include Pipeline::Proxy
-
-      # Root aka parent relation
-      #
-      # @return [Relation::Lazy]
-      #
-      # @api private
-      attr_reader :root
-
-      # Child relation nodes
-      #
-      # @return [Array<Relation::Lazy>]
-      #
-      # @api private
-      attr_reader :nodes
-
-      alias_method :left, :root
-      alias_method :right, :nodes
-
-      # @api private
-      def self.build(root, nodes)
-        if nodes.any? { |node| node.instance_of?(Composite) }
-          raise UnsupportedRelationError,
-            "Combining with composite relations is not supported"
-        else
-          new(root, nodes)
-        end
-      end
-
-      # @api private
-      def initialize(root, nodes)
-        @root = root
-        @nodes = nodes
-      end
-
-      # Return if this is a graph relation
-      #
-      # @return [true]
-      #
-      # @api private
-      def graph?
-        true
-      end
-
-      # Combine this graph with more nodes
-      #
-      # @param [Array<Relation::Lazy>]
-      #
-      # @return [Graph]
-      #
-      # @api public
-      def combine(*others)
-        self.class.new(root, nodes + others)
-      end
-
-      # Materialize this relation graph
-      #
-      # @return [Loaded]
-      #
-      # @api public
-      def call(*args)
-        left = root.call(*args)
-
-        right =
-          if left.count > 0
-            nodes.map { |node| node.call(left) }
-          else
-            nodes.map { |node| Loaded.new(node, []) }
-          end
-
-        Loaded.new(self, [left, right])
-      end
-
-      private
-
-      # @api private
-      def decorate?(other)
-        super || other.is_a?(Curried)
-      end
-
-      # @api private
-      def composite_class
-        Relation::Composite
-      end
-    end
-  end
-end

data/lib/rom/relation/loaded.rb

@@ -1,118 +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 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