rom-core 4.0.0.beta2 → 4.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ea3d114fd7800efddd98a8efe19a01586625c9f
-  data.tar.gz: 59a3cc776cfd019cd54583caf4ef8ee759d90f09
+  metadata.gz: c8a152a49542a83c5195f02e61f08823c7207f23
+  data.tar.gz: d4513f31be747f8f01e7c581084782afc3662a6a
 SHA512:
-  metadata.gz: 4349071ed68f65de26faf701b930653f56be802e14f63b82510d04c091ad0a7d0687eb23bb0e6a22b6330d6f83ec32184811701d29cd41934140d10c00ec54e6
-  data.tar.gz: 31885902cc6c78cf78c2f1357ee76edcf082eea550deaa293588029534a68e09d01c6a31ef14bd7e09523ad7678344184b2e3eec8f384a767ff11c94f5948f1f
+  metadata.gz: 652ebe10f678636a8dfe0dd78e1f31fbba58499a9e65eaf1589e46c3abc87e730ee773fdf60435146725e73ca7596e519bc3888dd5498a3d81a90783740a7b40
+  data.tar.gz: 95f2e25a3eac0195a6d9d35697b619b52364255b7fefcbfd1c68a647f9aefecc21a489f9a945346f6834d2936d81235b447451c9131d2b86be40a5c834144e00

data/CHANGELOG.md

@@ -24,7 +24,7 @@ Previous `rom` gem was renamed to `rom-core`
 * Works with MRI >= 2.2
 * [BREAKING] Inferring relations from database schema **has been removed**. You need to define relations explicitly now (solnic)
 * [BREAKING] Relations have `auto_map` **turned on by default**. This means that wraps and graphs return nested data structures automatically (solnic)
-* [BREAKING] `Relation#combine` behavior from previous versions is now provided by `Relation#graph` (solnic)
+* [BREAKING] `Relation#combine` behavior from previous versions is now provided by `Relation#combine_with` (solnic)
 * [BREAKING] `Relation#as` now returns a new relation with aliased name, use `Relation#map_with(*list-of-mapper-ids)` or `Relation#map_to(model)` if you just want to map to custom models (solnic)
 * [BREAKING] `Relation.register_as(:bar)` is removed in favor of `schema(:foo, as: :bar)` (solnic)
 * [BREAKING] `Relation.dataset(:foo)` is removed in favor of `schema(:foo)`. Passing a block still works like before (solnic)
@@ -38,6 +38,7 @@ Previous `rom` gem was renamed to `rom-core`
 
 * [BREAKING] `Relation::Curried#name` was renamed to `Relation::Curried#view` (solnic)
 * [BREAKING] `Association::Name` was removed in favor of using `Relation::Name` (solnic)
+* [BREAKING] `ROM::Schema::Attribute` was renamed to `ROM::Attribute` (solnic)
 * Relations no longer use `method_missing` for accessing other relations from the registry (solnic)
 
 ## Fixed

data/lib/rom/attribute.rb

@@ -0,0 +1,427 @@
+require 'dry/equalizer'
+
+require 'rom/initializer'
+require 'rom/support/memoizable'
+
+module ROM
+  # Schema attributes provide meta information about types and an API
+  # for additional operations. This class can be extended by adapters to provide
+  # database-specific features. In example rom-sql provides SQL::Attribute
+  # with more features like creating SQL expressions for queries.
+  #
+  # Schema attributes are accessible through canonical relation schemas and
+  # instance-level schemas.
+  #
+  # @api public
+  class Attribute
+    include Dry::Equalizer(:type, :options)
+    include Memoizable
+
+    extend Initializer
+
+    # @!attribute [r] type
+    #   @return [Dry::Types::Definition, Dry::Types::Sum, Dry::Types::Constrained]
+    param :type
+
+    # @api private
+    def [](input)
+      type[input]
+    end
+
+    # Return true if this attribute type is a primary key
+    #
+    # @example
+    #   class Users < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :id, Types::Int
+    #       attribute :name, Types::String
+    #
+    #       primary_key :id
+    #     end
+    #   end
+    #
+    #   Users.schema[:id].primary_key?
+    #   # => true
+    #
+    #   Users.schema[:name].primary_key?
+    #   # => false
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @api public
+    def primary_key?
+      meta[:primary_key].equal?(true)
+    end
+
+    # Return true if this attribute type is a foreign key
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :id, Types::Int
+    #       attribute :user_id, Types.ForeignKey(:users)
+    #     end
+    #   end
+    #
+    #   Users.schema[:user_id].foreign_key?
+    #   # => true
+    #
+    #   Users.schema[:id].foreign_key?
+    #   # => false
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @api public
+    def foreign_key?
+      meta[:foreign_key].equal?(true)
+    end
+
+    # Return true if this attribute type is a foreign key
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :user_id, Types::Int.meta(alias: :id)
+    #       attribute :name, Types::String
+    #     end
+    #   end
+    #
+    #   Users.schema[:user_id].aliased?
+    #   # => true
+    #
+    #   Users.schema[:name].aliased?
+    #   # => false
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @api public
+    def aliased?
+      !meta[:alias].nil?
+    end
+
+    # Return source relation of this attribute type
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :id, Types::Int
+    #       attribute :user_id, Types.ForeignKey(:users)
+    #     end
+    #   end
+    #
+    #   Users.schema[:id].source
+    #   # => :tasks
+    #
+    #   Users.schema[:user_id].source
+    #   # => :tasks
+    #
+    # @return [Symbol, Relation::Name]
+    #
+    # @api public
+    def source
+      meta[:source]
+    end
+
+    # Return target relation of this attribute type
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :id, Types::Int
+    #       attribute :user_id, Types.ForeignKey(:users)
+    #     end
+    #   end
+    #
+    #   Users.schema[:id].target
+    #   # => nil
+    #
+    #   Users.schema[:user_id].target
+    #   # => :users
+    #
+    # @return [NilClass, Symbol, Relation::Name]
+    #
+    # @api public
+    def target
+      meta[:target]
+    end
+
+    # Return the canonical name of this attribute name
+    #
+    # This *always* returns the name that is used in the datastore, even when
+    # an attribute is aliased
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :user_id, Types::Int.meta(alias: :id)
+    #       attribute :name, Types::String
+    #     end
+    #   end
+    #
+    #   Users.schema[:id].name
+    #   # => :id
+    #
+    #   Users.schema[:user_id].name
+    #   # => :user_id
+    #
+    # @return [Symbol]
+    #
+    # @api public
+    def name
+      meta[:name]
+    end
+
+    # Return tuple key
+    #
+    # When schemas are projected with aliased attributes, we need a simple access to tuple keys
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :user_id, Types::Int.meta(alias: :id)
+    #       attribute :name, Types::String
+    #     end
+    #   end
+    #
+    #   Users.schema[:id].key
+    #   # :id
+    #
+    #   Users.schema.project(Users.schema[:id].aliased(:user_id)).key
+    #   # :user_id
+    #
+    # @return [Symbol]
+    #
+    # @api public
+    def key
+      meta[:alias] || name
+    end
+
+    # Return attribute's alias
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :user_id, Types::Int.meta(alias: :id)
+    #       attribute :name, Types::String
+    #     end
+    #   end
+    #
+    #   Users.schema[:user_id].alias
+    #   # => :user_id
+    #
+    #   Users.schema[:name].alias
+    #   # => nil
+    #
+    # @return [NilClass,Symbol]
+    #
+    # @api public
+    def alias
+      meta[:alias]
+    end
+
+    # Return new attribute type with provided alias
+    #
+    # @example
+    #   class Tasks < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :user_id, Types::Int
+    #       attribute :name, Types::String
+    #     end
+    #   end
+    #
+    #   aliased_user_id = Users.schema[:user_id].aliased(:id)
+    #
+    #   aliased_user_id.aliased?
+    #   # => true
+    #
+    #   aliased_user_id.name
+    #   # => :user_id
+    #
+    #   aliased_user_id.alias
+    #   # => :id
+    #
+    # @param [Symbol] name The alias
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def aliased(name)
+      meta(alias: name)
+    end
+    alias_method :as, :aliased
+
+    # Return new attribute type with an alias using provided prefix
+    #
+    # @example
+    #   class Users < ROM::Relation[:memory]
+    #     schema do
+    #       attribute :id, Types::Int
+    #       attribute :name, Types::String
+    #     end
+    #   end
+    #
+    #   prefixed_id = Users.schema[:id].prefixed
+    #
+    #   prefixed_id.aliased?
+    #   # => true
+    #
+    #   prefixed_id.name
+    #   # => :id
+    #
+    #   prefixed_id.alias
+    #   # => :users_id
+    #
+    #   prefixed_id = Users.schema[:id].prefixed(:user)
+    #
+    #   prefixed_id.alias
+    #   # => :user_id
+    #
+    # @param [Symbol] prefix The prefix (defaults to source.dataset)
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def prefixed(prefix = source.dataset)
+      aliased(:"#{prefix}_#{name}")
+    end
+
+    # Return if the attribute type is from a wrapped relation
+    #
+    # Wrapped attributes are used when two schemas from different relations
+    # are merged together. This way we can identify them easily and handle
+    # correctly in places like auto-mapping.
+    #
+    # @api public
+    def wrapped?
+      meta[:wrapped].equal?(true)
+    end
+
+    # Return attribute type wrapped for the specified relation name
+    #
+    # @param [Symbol] name The name of the source relation (defaults to source.dataset)
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def wrapped(name = source.dataset)
+      prefixed(name).meta(wrapped: true)
+    end
+
+    # Return attribute type with additional meta information
+    #
+    # Return meta information hash if no opts are provided
+    #
+    # @param [Hash] opts The meta options
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def meta(opts = nil)
+      if opts
+        self.class.new(type.meta(opts))
+      else
+        type.meta
+      end
+    end
+
+    # Return string representation of the attribute type
+    #
+    # @return [String]
+    #
+    # @api public
+    def inspect
+      %(#<#{self.class}[#{type.name}] #{meta.map { |k, v| "#{k}=#{v.inspect}" }.join(' ')}>)
+    end
+    alias_method :pretty_inspect, :inspect
+
+    # Check if the attribute type is equal to another
+    #
+    # @param [Dry::Type, Attribute]
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @api public
+    def eql?(other)
+      other.is_a?(self.class) ? super : type.eql?(other)
+    end
+
+    # Return if this attribute type has additional attribute type for reading
+    # tuple values
+    #
+    # @return [TrueClass, FalseClass]
+    #
+    # @api private
+    def read?
+      ! meta[:read].nil?
+    end
+
+    # Return read type or self
+    #
+    # @return [Attribute]
+    #
+    # @api private
+    def to_read_type
+      read? ? meta[:read] : type
+    end
+
+    # Return nullable attribute
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def optional
+      sum = self.class.new(super, options)
+      read? ? sum.meta(read: meta[:read].optional) : sum
+    end
+
+    # @api private
+    def respond_to_missing?(name, include_private = false)
+      type.respond_to?(name) || super
+    end
+
+    # Return AST for the type
+    #
+    # @return [Array]
+    #
+    # @api public
+    def to_ast
+      [:attribute, [name, type.to_ast(meta: false), meta_ast]]
+    end
+
+    # Return AST for the read type
+    #
+    # @return [Array]
+    #
+    # @api public
+    def to_read_ast
+      [:attribute, [name, to_read_type.to_ast(meta: false), meta_ast]]
+    end
+
+    # @api private
+    def meta_ast
+      meta_keys = %i(wrapped alias primary_key)
+      ast = meta.select { |k, _| meta_keys.include?(k) }
+      ast[:source] = source.to_sym if source
+      ast
+    end
+
+    memoize :to_ast, :to_read_ast, :meta_ast
+
+    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(response, options)
+        else
+          response
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/lib/rom/auto_curry.rb

@@ -20,7 +20,7 @@ module ROM
     end
 
     def auto_curried_methods
-      @__auto_curried_methods__ ||= []
+      @__auto_curried_methods__ ||= Set.new
     end
 
     def auto_curry(name, &block)

data/lib/rom/command.rb

@@ -432,6 +432,15 @@ module ROM
       result.equal?(:many)
     end
 
+    # Check if this command is restrictible through relation
+    #
+    # @return [TrueClass,FalseClass]
+    #
+    # @api private
+    def restrictible?
+      self.class.restrictable.equal?(true)
+    end
+
     private
 
     # Hook called by Pipeline to get composite class for commands

data/lib/rom/command_proxy.rb

@@ -8,17 +8,25 @@ module ROM
   class CommandProxy
     attr_reader :command, :root
 
-    def initialize(command)
+    # @api private
+    def initialize(command, root = Dry::Core::Inflector.singularize(command.name.relation).to_sym)
       @command = command
-      @root = Dry::Core::Inflector.singularize(command.name.relation).to_sym
+      @root = root
     end
 
+    # @api private
     def call(input)
       command.call(root => input)
     end
 
+    # @api private
     def >>(other)
       self.class.new(command >> other)
     end
+
+    # @api private
+    def restrictible?
+      command.restrictible?
+    end
   end
 end

data/lib/rom/constants.rb

@@ -19,12 +19,20 @@ module ROM
   RelationAlreadyDefinedError = Class.new(StandardError)
   MapperAlreadyDefinedError = Class.new(StandardError)
   NoRelationError = Class.new(StandardError)
+  InvalidRelationName = Class.new(StandardError)
   CommandError = Class.new(StandardError)
   KeyMissing = Class.new(ROM::CommandError)
   TupleCountMismatchError = Class.new(CommandError)
   UnknownPluginError = Class.new(StandardError)
   UnsupportedRelationError = Class.new(StandardError)
   MissingAdapterIdentifierError = Class.new(StandardError)
+  AttributeAlreadyDefinedError = Class.new(StandardError)
+
+  class InvalidRelationName < StandardError
+    def initialize(relation)
+      super("Relation name: #{relation} is a protected word, please use another relation name")
+    end
+  end
 
   class ElementNotFoundError < KeyError
     def initialize(key, registry)

data/lib/rom/core.rb

@@ -26,7 +26,6 @@ require 'rom/container'
 require 'rom/create_container'
 
 # register core plugins
-require 'rom/plugins/configuration/configuration_dsl'
 require 'rom/plugins/relation/registry_reader'
 require 'rom/plugins/relation/instrumentation'
 require 'rom/plugins/command/schema'
@@ -37,7 +36,6 @@ module ROM
 
   plugins do
     register :mappers, ROM::Mapper::ConfigurationPlugin, type: :configuration
-    register :macros, ROM::ConfigurationPlugins::ConfigurationDSL, type: :configuration
     register :timestamps, ROM::Plugins::Schema::Timestamps, type: :schema
     register :registry_reader, ROM::Plugins::Relation::RegistryReader, type: :relation
     register :instrumentation, ROM::Plugins::Relation::Instrumentation, type: :relation

data/lib/rom/gateway.rb

@@ -144,17 +144,6 @@ module ROM
       # noop
     end
 
-    # Schema inference hook
-    #
-    # Every gateway that supports schema inference should implement this method
-    #
-    # @return [Array] An array with dataset names
-    #
-    # @api private
-    def schema
-      []
-    end
-
     # Disconnect is optional and it's a no-op by default
     #
     # @api public

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

@@ -19,12 +19,10 @@ module ROM
               default_input = options.fetch(:input, input)
 
               input_handler =
-                if default_input != Hash && relation.schema?
+                if default_input != Hash
                   -> tuple { relation.input_schema[input[tuple]] }
-                elsif relation.schema?
-                  relation.input_schema
                 else
-                  default_input
+                  relation.input_schema
                 end
 
               super(relation, options.merge(input: input_handler))

data/lib/rom/relation/class_interface.rb

@@ -27,6 +27,9 @@ module ROM
       end
 
       DEFAULT_DATASET_PROC = -> * { self }.freeze
+      INVALID_RELATIONS_NAMES = [
+        :relations
+      ].freeze
 
       # Return adapter-specific relation subclass
       #
@@ -93,6 +96,8 @@ module ROM
           ds_name = dataset || schema_opts.fetch(:dataset, default_name.dataset)
           relation = as || schema_opts.fetch(:relation, ds_name)
 
+          raise InvalidRelationName.new(relation) if invalid_relation_name?(relation)
+
           @relation_name = Name[relation, ds_name]
 
           @schema_proc = proc do |*args, &inner_block|
@@ -173,7 +178,7 @@ module ROM
       # @api public
       def view(*args, &block)
         if args.size == 1 && block.arity > 0
-          raise ArgumentError, "header must be set as second argument"
+          raise ArgumentError, "schema attribute names must be provided as the second argument"
         end
 
         name, new_schema_fn, relation_block =
@@ -247,7 +252,7 @@ module ROM
         ancestor_methods = ancestors.reject { |klass| klass == self }
           .map(&:instance_methods).flatten(1)
 
-        instance_methods - ancestor_methods + auto_curried_methods
+        instance_methods - ancestor_methods + auto_curried_methods.to_a
       end
 
       # @api private
@@ -277,6 +282,12 @@ module ROM
       def name
         super || superclass.name
       end
+
+      private
+
+      def invalid_relation_name?(relation)
+        INVALID_RELATIONS_NAMES.include?(relation.to_sym)
+      end
     end
   end
 end

data/lib/rom/relation/combined.rb

@@ -103,13 +103,19 @@ module ROM
       end
 
       # @api public
-      def to_ast
-        [:relation, [name.to_sym, attr_ast + node_ast, meta_ast]]
+      def command(type, *args)
+        if type == :create
+          super
+        else
+          raise NotImplementedError, "#{self.class}#command doesn't work with #{type.inspect} command type yet"
+        end
       end
 
+      private
+
       # @api private
-      def node_ast
-        nodes.map(&:to_ast)
+      def decorate?(other)
+        super || other.is_a?(Wrap)
       end
     end
   end

data/lib/rom/relation/commands.rb

@@ -2,18 +2,38 @@ module ROM
   class Relation
     # Extensions for relation classes which provide access to commands
     #
-    # @api private
+    # @api public
     module Commands
+      # Return a command for the relation
+      #
+      # @example
+      #   users.command(:create)
+      #
+      # @param type [Symbol] The command type (:create, :update or :delete)
+      # @option :mapper [ROM::Mapper] An optional mapper applied to the command result
+      # @option :use [Array<Symbol>] A list of command plugins
+      # @option :result [:one, :many] Whether the command result has one or more rows.
+      #                               :one is default
+      #
+      # @return [ROM::Command]
+      #
       # @api public
       def command(type, mapper: nil, use: EMPTY_ARRAY, **opts)
-        command = commands[type, adapter, to_ast, use, opts]
+        base_command = commands[type, adapter, to_ast, use, opts]
 
-        if mapper
-          command >> mappers[mapper]
-        elsif mappers.any? && !command.is_a?(CommandProxy)
-          mappers.reduce(command) { |a, (_, e)| a >> e }
-        elsif auto_struct? || auto_map?
-          command >> self.mapper
+        command =
+          if mapper
+            base_command >> mappers[mapper]
+          elsif mappers.any? && !base_command.is_a?(CommandProxy)
+            mappers.reduce(base_command) { |a, (_, e)| a >> e }
+          elsif auto_struct? || auto_map?
+            base_command >> self.mapper
+          else
+            base_command
+          end
+
+        if command.restrictible?
+          command.new(self)
         else
           command
         end