rom 2.0.2 → 3.0.0

data/lib/rom/memory/dataset.rb

@@ -1,5 +1,4 @@
-require 'rom/support/options' # FIXME: this shouldn't be required, fix needed in rom-support
-require 'rom/support/array_dataset'
+require 'rom/array_dataset'
 
 module ROM
   module Memory

data/lib/rom/memory/relation.rb

@@ -1,4 +1,5 @@
 require 'rom/memory/types'
+require 'rom/memory/schema'
 
 module ROM
   module Memory
@@ -14,8 +15,20 @@ module ROM
       include Memory
 
       adapter :memory
+      schema_class Memory::Schema
 
-      forward :take, :join, :project, :restrict, :order
+      forward :take, :join, :restrict, :order
+
+      # Project a relation with provided attribute names
+      #
+      # @param [*Array] names A list with attribute names
+      #
+      # @return [Memory::Relation]
+      #
+      # @api public
+      def project(*names)
+        schema.project(*names).(self)
+      end
 
       # Insert tuples into the relation
       #

data/lib/rom/memory/schema.rb

@@ -0,0 +1,13 @@
+require 'rom/schema'
+
+module ROM
+  module Memory
+    class Schema < ROM::Schema
+      # @see Schema#call
+      # @api public
+      def call(relation)
+        relation.new(relation.dataset.project(*map(&:name)), schema: self)
+      end
+    end
+  end
+end

data/lib/rom/plugin_registry.rb

@@ -1,4 +1,4 @@
-require 'rom/support/registry'
+require 'rom/registry'
 
 module ROM
   # Stores all registered plugins

data/lib/rom/plugins/command/schema.rb

@@ -20,9 +20,9 @@ module ROM
 
               input_handler =
                 if default_input != Hash && relation.schema?
-                  -> tuple { relation.schema_hash[input[tuple]] }
+                  -> tuple { relation.input_schema[input[tuple]] }
                 elsif relation.schema?
-                  relation.schema_hash
+                  relation.input_schema
                 else
                   default_input
                 end

data/lib/rom/plugins/configuration/configuration_dsl.rb

@@ -1,5 +1,5 @@
 require 'rom/configuration_dsl'
-require 'rom/support/deprecations'
+require 'dry/core/deprecations'
 
 module ROM
   module ConfigurationPlugins
@@ -10,7 +10,11 @@ module ROM
 
       # @api private
       def self.apply(configuration, options = {})
-        ROM::Deprecations.announce(:macros, "Calling `use(:macros)` is no longer necessary. Macros are enabled by default.")
+        Dry::Core::Deprecations.announce(
+          :macros,
+          "Calling `use(:macros)` is no longer necessary. Macros are enabled by default.",
+          tag: :rom
+        )
       end
     end
   end

data/lib/rom/plugins/relation/key_inference.rb

@@ -1,3 +1,5 @@
+require 'dry/core/inflector'
+
 module ROM
   module Plugins
     module Relation
@@ -11,7 +13,7 @@ module ROM
         # @api private
         def foreign_key(other = nil)
           if other
-            if schema
+            if schema?
               rel_name = other.respond_to?(:to_sym) ?
                 ROM::Relation::Name[other.to_sym] : other.base_name
 
@@ -24,7 +26,7 @@ module ROM
               relation.foreign_key
             end
           else
-            :"#{Inflector.singularize(name.dataset)}_id"
+            :"#{Dry::Core::Inflector.singularize(name.dataset)}_id"
           end
         end
 

data/lib/rom/plugins/relation/registry_reader.rb

@@ -12,7 +12,11 @@ module ROM
         # @api private
         def self.included(klass)
           super
-          klass.option :__registry__, type: RelationRegistry, default: EMPTY_REGISTRY, reader: true
+          return if klass.instance_methods.include?(:__registry__)
+          klass.option :__registry__,
+                       default: proc { EMPTY_REGISTRY },
+                       reader: true,
+                       optional: true
         end
 
         # @api private

data/lib/rom/registry.rb

@@ -0,0 +1,50 @@
+module ROM
+  # @api private
+  class Registry
+    include Enumerable
+    include Dry::Equalizer(:elements)
+
+    class ElementNotFoundError < KeyError
+      def initialize(key, name)
+        super("#{key.inspect} doesn't exist in #{name} registry")
+      end
+    end
+
+    attr_reader :elements, :name
+
+    def initialize(elements = {}, name = self.class.name)
+      @elements = elements
+      @name = name
+    end
+
+    def each(&block)
+      return to_enum unless block
+      elements.each { |element| yield(element) }
+    end
+
+    def key?(name)
+      !name.nil? && elements.key?(name.to_sym)
+    end
+
+    def fetch(key)
+      raise ArgumentError.new('key cannot be nil') if key.nil?
+
+      elements.fetch(key.to_sym) do
+        return yield if block_given?
+
+        raise ElementNotFoundError.new(key, name)
+      end
+    end
+    alias_method :[], :fetch
+
+    def respond_to_missing?(name, include_private = false)
+      elements.key?(name) || super
+    end
+
+    private
+
+    def method_missing(name, *)
+      elements.fetch(name) { super }
+    end
+  end
+end

data/lib/rom/relation/class_interface.rb

@@ -1,13 +1,21 @@
 require 'set'
 
-require 'rom/support/auto_curry'
+require 'dry/core/inflector'
+require 'dry/core/constants'
+require 'dry/core/class_attributes'
+
+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
+      include Dry::Core::Constants
+
       # Register adapter relation subclasses during setup phase
       #
       # In adition those subclasses are extended with an interface for accessing
@@ -17,14 +25,18 @@ module ROM
       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"
+                "relation class +#{self}+ is missing the adapter identifier"
         end
 
+        klass.extend Dry::Core::ClassAttributes
+        klass.defines :adapter, :schema_class, :schema_inferrer, :schema_dsl
+
+        klass.schema_dsl Schema::DSL
+        klass.schema_class Schema
+        klass.schema_inferrer Schema::DEFAULT_INFERRER
+
         # 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]
@@ -32,22 +44,26 @@ module ROM
         klass.class_eval do
           use :registry_reader
 
-          defines :gateway, :dataset, :dataset_proc, :register_as, :schema_dsl, :schema_inferrer
+          defines :gateway, :dataset, :dataset_proc, :register_as
 
           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
+          # 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, reader: true, optional: true,
+                   default: -> r { Name.new(r.class.register_as, r.class.dataset) }
+          end
 
           # Set dataset name
           #
@@ -95,12 +111,6 @@ module ROM
             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]
@@ -151,21 +161,108 @@ module ROM
       # @param [Boolean] infer Whether to do an automatic schema inferring
       #
       # @api public
-      def schema(dataset = nil, infer: false, &block)
+      def schema(dataset = nil, as: nil, infer: false, &block)
         if defined?(@schema)
           @schema
         elsif block || infer
           self.dataset(dataset) if dataset
-          self.register_as(self.dataset) unless register_as
+
+          if as
+            self.register_as(as)
+          else
+            self.register_as(self.dataset) unless register_as
+          end
 
           name = Name[register_as, self.dataset]
           inferrer = infer ? schema_inferrer : nil
-          dsl = schema_dsl.new(name, inferrer, &block)
+
+          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
+      #
+      # @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
       #
@@ -179,7 +276,7 @@ module ROM
         methods.each do |method|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{method}(*args, &block)
-              __new__(dataset.__send__(:#{method}, *args, &block))
+              new(dataset.__send__(:#{method}, *args, &block))
             end
           RUBY
         end
@@ -203,7 +300,7 @@ module ROM
       # @api private
       def default_name
         return unless name
-        Inflector.underscore(name).tr('/', '_').to_sym
+        Dry::Core::Inflector.underscore(name).tr('/', '_').to_sym
       end
 
       # @api private
@@ -214,16 +311,31 @@ module ROM
       # @api private
       def view_methods
         ancestor_methods = ancestors.reject { |klass| klass == self }
-          .map(&:instance_methods).flatten
+          .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(_container, _relation)
-        # noop
+      def finalize(_container, relation)
+        schemas = relation.schemas.reduce({}) do |h, (a, e)|
+          h.update(a => e.is_a?(Proc) ? instance_exec(&e) : e)
+        end
+        relation.schemas.update(schemas)
+        relation
       end
     end
   end

data/lib/rom/relation/curried.rb

@@ -1,5 +1,5 @@
-require 'rom/support/options'
-
+require 'rom/types'
+require 'rom/initializer'
 require 'rom/pipeline'
 require 'rom/relation/name'
 require 'rom/relation/materializable'
@@ -7,23 +7,23 @@ require 'rom/relation/materializable'
 module ROM
   class Relation
     class Curried
-      include Options
+      extend Initializer
       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
+      param :relation
 
-      attr_reader :name
+      option :name, optional: true, type: Types::Strict::Symbol
+      option :arity, type: Types::Strict::Int, reader: true, default: proc { -1 }
+      option :curry_args, reader: true, default: proc { EMPTY_ARRAY }
 
-      # @api private
-      def initialize(relation, options = EMPTY_HASH)
-        @relation = relation
-        @name = relation.name.with(options[:name])
-        super
+      # Relation name
+      #
+      # @return [ROM::Relation::Name]
+      #
+      # @api public
+      def name
+        @name == Dry::Initializer::UNDEFINED ? relation.name : relation.name.with(@name)
       end
 
       # Load relation if args match the arity
@@ -75,7 +75,7 @@ module ROM
 
       # @api private
       def __new__(relation, new_opts = EMPTY_HASH)
-        Curried.new(relation, options.merge(new_opts))
+        self.class.new(relation, new_opts.empty? ? options : options.merge(new_opts))
       end
 
       # @api private

data/lib/rom/relation/view_dsl.rb

@@ -0,0 +1,31 @@
+module ROM
+  class Relation
+    class ViewDSL
+      attr_reader :name
+
+      attr_reader :relation_block
+
+      attr_reader :new_schema
+
+      def initialize(name, schema, &block)
+        @name = name
+        @schema = schema
+        @new_schema = nil
+        @relation_block = nil
+        instance_eval(&block)
+      end
+
+      def schema(&block)
+        @new_schema = -> { @schema.instance_exec(&block) }
+      end
+
+      def relation(&block)
+        @relation_block = lambda(&block)
+      end
+
+      def call
+        [name, new_schema, relation_block]
+      end
+    end
+  end
+end