rom 3.3.3 → 4.0.0.beta1

data/lib/rom/relation/class_interface.rb

@@ -1,356 +0,0 @@
-require 'set'
-
-require 'dry/core/inflector'
-require 'dry/core/deprecations'
-require 'dry/core/constants'
-
-require 'rom/auto_curry'
-require 'rom/relation/curried'
-require 'rom/relation/name'
-require 'rom/relation/view_dsl'
-require 'rom/schema'
-
-module ROM
-  class Relation
-    # @api public
-    module ClassInterface
-      extend Dry::Core::Deprecations[:rom]
-
-      include Dry::Core::Constants
-
-      # 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
-
-        if respond_to?(:adapter) && adapter.nil?
-          raise MissingAdapterIdentifierError,
-                "relation class +#{self}+ is missing the adapter identifier"
-        end
-
-        klass.defines :adapter
-
-        # 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
-
-          gateway :default
-
-          dataset default_name
-
-          # skip defining :name option if it's a class that already has this method
-          # which can happen when an adapter's relation class inherits from another
-          # adapter's relation class (ie YAML::Relation < Memory::Relation)
-          unless instance_methods.include?(:name)
-            # Relation's dataset name
-            #
-            # In example a table name in an SQL database
-            #
-            # @return [Symbol]
-            #
-            # @api public
-            option :name, default: -> { Name.new(self.class.register_as, self.class.dataset) }
-          end
-
-          # 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(*args, deprecation: true, &block)
-            if block
-              dataset_proc(block)
-            elsif args.size > 0
-              if deprecation
-                warn("Relation.dataset is deprecated in favor of schema settings\n\n#{caller[0..5].join("\n")}")
-              end
-            end
-            super(*args)
-          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(*args, deprecation: true)
-            if deprecation && args.size > 0
-              warn("Relation.register_as is deprecated in favor of schema settings\n\n#{caller[0..5].join("\n")}")
-            end
-
-            if args.empty?
-              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(*args)
-            end
-          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, as: nil, infer: false, &block)
-        if defined?(@schema)
-          @schema
-        elsif block || infer
-          self.dataset(dataset, deprecation: false) if dataset
-
-          if as
-            self.register_as(as, deprecation: false)
-          else
-            self.register_as(self.dataset, deprecation: false) unless register_as
-          end
-
-          name = Name[register_as, self.dataset]
-          inferrer = infer ? schema_inferrer : nil
-
-          unless schema_class
-            raise MissingSchemaClassError.new(self)
-          end
-
-          dsl = schema_dsl.new(name, schema_class: schema_class, inferrer: inferrer, &block)
-
-          @schema = dsl.call
-        end
-      end
-
-      # Define a relation view with a specific schema
-      #
-      # Explicit relation views allow relation composition with auto-mapping
-      # in repositories. It's useful for cases like defining custom views
-      # for associations where relations (even from different databases) can
-      # be composed together and automatically mapped in memory to structs.
-      #
-      # @overload view(name, schema, &block)
-      #   @example View with the canonical schema
-      #     class Users < ROM::Relation[:sql]
-      #       view(:listing, schema) do
-      #         order(:name)
-      #       end
-      #     end
-      #
-      #   @example View with a projected schema
-      #     class Users < ROM::Relation[:sql]
-      #       view(:listing, schema.project(:id, :name)) do
-      #         order(:name)
-      #       end
-      #     end
-      #
-      # @overload view(name, &block)
-      #   @example View with the canonical schema and arguments
-      #     class Users < ROM::Relation[:sql]
-      #       view(:by_name) do |name|
-      #         where(name: name)
-      #       end
-      #     end
-      #
-      #   @example View with projected schema and arguments
-      #     class Users < ROM::Relation[:sql]
-      #       view(:by_name) do
-      #         schema { project(:id, :name) }
-      #         relation { |name| where(name: name) }
-      #       end
-      #     end
-      #
-      #   @example View with a schema extended with foreign attributes
-      #     class Users < ROM::Relation[:sql]
-      #       view(:index) do
-      #         schema { append(relations[:tasks][:title]) }
-      #         relation { |name| where(name: name) }
-      #       end
-      #     end
-      #
-      # @return [Symbol] view method name
-      #
-      # @api public
-      def view(*args, &block)
-        if args.size == 1 && block.arity > 0
-          raise ArgumentError, "header must be set as second argument"
-        end
-
-        name, new_schema_fn, relation_block =
-          if args.size == 1
-            ViewDSL.new(*args, schema, &block).call
-          else
-            [*args, block]
-          end
-
-        schemas[name] =
-          if args.size == 2
-            schema.project(*args[1])
-          else
-            new_schema_fn
-          end
-
-        if relation_block.arity > 0
-          auto_curry_guard do
-            define_method(name, &relation_block)
-
-            auto_curry(name) do
-              schemas[name].(self)
-            end
-          end
-        else
-          define_method(name) do
-            schemas[name].(instance_exec(&relation_block))
-          end
-        end
-
-        name
-      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
-        Dry::Core::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(1)
-
-        instance_methods - ancestor_methods + auto_curried_methods
-      end
-
-      # @api private
-      def schemas
-        @schemas ||= {}
-      end
-
-      # @api private
-      def default_schema(relation)
-        relation_class = relation.class
-        relation_class.schema || relation_class.schema_class.define(relation_class.default_name)
-      end
-
-      # Hook to finalize a relation after its instance was created
-      #
-      # @api private
-      def finalize(registry, relation)
-        schemas = relation.schemas.reduce({}) do |h, (a, e)|
-          h.update(a => e.is_a?(Proc) ? instance_exec(registry, &e) : e)
-        end
-        relation.schemas.update(schemas)
-        relation
-      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,109 +0,0 @@
-require 'rom/types'
-require 'rom/initializer'
-require 'rom/pipeline'
-require 'rom/relation/name'
-require 'rom/relation/materializable'
-
-module ROM
-  class Relation
-    class Curried
-      extend Initializer
-      include Materializable
-      include Pipeline
-
-      param :relation
-
-      option :name, optional: true, type: Types::Strict::Symbol
-      option :arity, type: Types::Strict::Int, default: -> { -1 }
-      option :curry_args, default: -> { EMPTY_ARRAY }
-
-      # Relation name
-      #
-      # @return [ROM::Relation::Name]
-      #
-      # @api public
-      def name
-        @name ? relation.name.with(@name) : relation.name
-      end
-
-      # Load relation if args match the arity
-      #
-      # @return [Loaded,Curried]
-      #
-      # @api public
-      def call(*args)
-        if arity != -1
-          all_args = curry_args + args
-
-          if all_args.empty?
-            raise ArgumentError, "curried #{relation.class}##{name.to_sym} relation was called without any arguments"
-          end
-
-          if args.empty?
-            self
-          elsif 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)
-        self.class.new(relation, new_opts.empty? ? options : 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,125 +0,0 @@
-require 'dry/core/deprecations'
-
-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
-      extend Dry::Core::Deprecations[:rom]
-
-      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
-
-      # @api public
-      def with_nodes(nodes)
-        self.class.new(root, 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 graph(*others)
-        self.class.new(root, nodes + others)
-      end
-      deprecate :combine, :graph
-
-      # Materialize this relation graph
-      #
-      # @return [Loaded]
-      #
-      # @api public
-      def call(*args)
-        left = root.call(*args)
-
-        right =
-          if left.empty?
-            nodes.map { |node| Loaded.new(node, EMPTY_ARRAY) }
-          else
-            nodes.map { |node| node.call(left) }
-          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