rom 2.0.2 → 3.0.0.beta1

data/lib/rom/relation/class_interface.rb

@@ -1,13 +1,20 @@
 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
     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 +24,14 @@ 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
+
         # 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 +39,30 @@ 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,
+                  :schema_dsl, :schema_inferrer
 
           gateway :default
           schema_dsl Schema::DSL
+          schema_class Schema
           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 +110,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]
@@ -160,12 +169,62 @@ module ROM
 
           name = Name[register_as, self.dataset]
           inferrer = infer ? schema_inferrer : nil
-          dsl = schema_dsl.new(name, inferrer, &block)
+          dsl = schema_dsl.new(name, schema_class: schema_class, inferrer: inferrer, &block)
 
           @schema = dsl.call
         end
       end
 
+      # Define a relation view with a specific header
+      #
+      # With headers defined all the mappers will be inferred automatically
+      #
+      # @example
+      #   class Users < ROM::Relation[:sql]
+      #     view(:by_name, [:id, :name]) do |name|
+      #       where(name: name)
+      #     end
+      #
+      #     view(:listing, [:id, :name, :email]) do
+      #       select(:id, :name, :email).order(:name)
+      #     end
+      #   end
+      #
+      # @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
+      end
+
       # Dynamically define a method that will forward to the dataset and wrap
       # response in the relation itself
       #
@@ -179,7 +238,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 +262,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 +273,25 @@ 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
+
       # 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

data/lib/rom/relation.rb

@@ -1,3 +1,4 @@
+require 'rom/initializer'
 require 'rom/relation/class_interface'
 
 require 'rom/pipeline'
@@ -29,17 +30,31 @@ module ROM
   #
   # @api public
   class Relation
+    extend Initializer
     extend ClassInterface
 
-    include Options
     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, reader: true, default: proc { 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, reader: true, optional: true, default: -> relation {
+      relation.class.schema || Schema.define(Dry::Core::Inflector.underscore(relation.class.name || EMPTY_STRING).to_sym)
+    }
+
     # @!attribute [r] schema_hash
     #   @return [Object#[]] tuple processing function, uses schema or defaults to Hash[]
     #   @api private
@@ -47,36 +62,13 @@ module ROM
       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
+    # Return schema attribute
     #
-    # @param dataset [Object]
-    #
-    # @param options [Hash]
-    #   @option :mappers [MapperRegistry]
-    #   @option :schema_hash [#[]]
-    #   @option :associations [AssociationSet]
+    # @return [Schema::Type]
     #
     # @api public
-    def initialize(dataset, options = EMPTY_HASH)
-      @dataset = dataset
-      @schema = self.class.schema
-      super
+    def [](name)
+      schema[name]
     end
 
     # Yields relation tuples
@@ -143,7 +135,17 @@ module ROM
     #
     # @api private
     def schema?
-      ! schema.nil?
+      ! schema.empty?
+    end
+
+    # Return a new relation with provided dataset and additional options
+    #
+    # @param [Object] dataset
+    # @param [Hash] new_opts Additional options
+    #
+    # @api public
+    def new(dataset, new_opts = EMPTY_HASH)
+      self.class.new(dataset, new_opts.empty? ? options : options.merge(new_opts))
     end
 
     # Returns a new instance with the same dataset but new options
@@ -154,16 +156,29 @@ module ROM
     #
     # @api private
     def with(new_options)
-      __new__(dataset, options.merge(new_options))
+      new(dataset, options.merge(new_options))
     end
 
-    private
+    # Return all registered relation schemas
+    #
+    # @return [Hash<Symbol=>Schema>]
+    #
+    # @api public
+    def schemas
+      @schemas ||= self.class.schemas
+    end
 
-    # @api private
-    def __new__(dataset, new_opts = EMPTY_HASH)
-      self.class.new(dataset, options.merge(new_opts))
+    # 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
+
     # @api private
     def composite_class
       Relation::Composite

data/lib/rom/schema/dsl.rb

@@ -13,19 +13,17 @@ module ROM
 
     # @api public
     class DSL < BasicObject
-      attr_reader :name, :attributes, :inferrer
+      attr_reader :relation, :attributes, :inferrer, :schema_class
 
       # @api private
-      def initialize(name, inferrer, &block)
-        @name = name
+      def initialize(relation, schema_class: Schema, inferrer: Schema::DEFAULT_INFERRER, &block)
+        @relation = relation
         @inferrer = inferrer
-        @attributes = nil
+        @schema_class = schema_class
+        @attributes = {}
 
         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
 
@@ -36,7 +34,7 @@ module ROM
       # @api public
       def attribute(name, type)
         @attributes ||= {}
-        @attributes[name] = type.meta(name: name)
+        @attributes[name] = type.meta(name: name, source: relation)
       end
 
       # Specify which key(s) should be the primary key
@@ -51,7 +49,7 @@ module ROM
 
       # @api private
       def call
-        Schema.new(name, attributes, inferrer: inferrer)
+        schema_class.define(relation, attributes: attributes.values, inferrer: inferrer)
       end
     end
   end

data/lib/rom/schema/type.rb

@@ -0,0 +1,115 @@
+require 'delegate'
+require 'dry/equalizer'
+require 'dry/types/decorator'
+
+module ROM
+  class Schema
+    class Type
+      include Dry::Equalizer(:type)
+
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      # @api public
+      def primary_key?
+        meta[:primary_key].equal?(true)
+      end
+
+      # @api public
+      def foreign_key?
+        meta[:foreign_key].equal?(true)
+      end
+
+      # @api public
+      def aliased?
+        !meta[:alias].nil?
+      end
+
+      # @api public
+      def source
+        meta[:source]
+      end
+
+      # @api public
+      def target
+        meta[:target]
+      end
+
+      # @api public
+      def name
+        meta[:name]
+      end
+
+      # @api public
+      def alias
+        meta[:alias]
+      end
+
+      # @api public
+      def aliased(name)
+        meta(alias: name)
+      end
+      alias_method :as, :aliased
+
+      # @api public
+      def prefixed(prefix = source.dataset)
+        aliased(:"#{prefix}_#{name}")
+      end
+
+      # @api public
+      def wrapped?
+        meta[:wrapped].equal?(true)
+      end
+
+      # @api public
+      def wrapped(name = source.dataset)
+        self.class.new(prefixed(name).meta(wrapped: true))
+      end
+
+      # @api public
+      def meta(opts = nil)
+        if opts
+          self.class.new(type.meta(opts))
+        else
+          type.meta
+        end
+      end
+
+      # @api public
+      def inspect
+        %(#<#{self.class}[#{type.name}] #{meta.map { |k, v| "#{k}=#{v.inspect}" }.join(' ')}>)
+      end
+      alias_method :pretty_inspect, :inspect
+
+      # @api public
+      def eql?(other)
+        other.is_a?(self.class) ? super : type.eql?(other)
+      end
+
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        type.respond_to?(name) || super
+      end
+
+      private
+
+      # @api private
+      def method_missing(meth, *args, &block)
+        if type.respond_to?(meth)
+          response = type.__send__(meth, *args, &block)
+
+          if response.is_a?(type.class)
+            self.class.new(type)
+          else
+            response
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end