rom 2.0.2 → 3.0.0

data/lib/rom/schema.rb

@@ -1,16 +1,43 @@
 require 'dry-equalizer'
 
-require 'rom/support/constants'
+require 'rom/schema/attribute'
 require 'rom/schema/dsl'
 require 'rom/association_set'
 
 module ROM
   # Relation schema
   #
+  # Schemas hold detailed information about relation tuples, including their
+  # primitive types (String, Integer, Hash, etc. or custom classes), as well as
+  # various meta information like primary/foreign key and literally any other
+  # information that a given database adapter may need.
+  #
+  # Adapters can extend this class and it can be used in adapter-specific relations.
+  # In example rom-sql extends schema with Association DSL and many additional
+  # SQL-specific APIs in schema types.
+  #
+  # Schemas are used for projecting canonical relations into other relations and
+  # every relation object maintains its schema. This means that we always have
+  # all information about relation tuples, even when a relation was projected and
+  # diverged from its canonical form.
+  #
+  # Furthermore schema attributes know their source relations, which makes it
+  # possible to merge schemas from multiple relations and maintain information
+  # about the source relations. In example when two relations are joined, their
+  # schemas are merged, and we know which attributes belong to which relation.
+  #
   # @api public
   class Schema
     EMPTY_ASSOCIATION_SET = AssociationSet.new(EMPTY_HASH).freeze
 
+    DEFAULT_INFERRER = proc { [EMPTY_ARRAY, EMPTY_ARRAY].freeze }
+
+    MissingAttributesError = Class.new(StandardError) do
+      def initialize(name, attributes)
+        super("missing attributes in #{name.inspect} schema: #{attributes.map(&:inspect).join(', ')}")
+      end
+    end
+
     include Dry::Equalizer(:name, :attributes, :associations)
     include Enumerable
 
@@ -19,7 +46,7 @@ module ROM
     attr_reader :name
 
     # @!attribute [r] attributes
-    #   @return [Hash] The hash with schema attribute types
+    #   @return [Array] Array with schema attributes
     attr_reader :attributes
 
     # @!attribute [r] associations
@@ -30,43 +57,246 @@ module ROM
     #   @return [#call] An optional inferrer object used in `finalize!`
     attr_reader :inferrer
 
-    # @!attribute [r] primary_key
-    #   @return [Array<Dry::Types::Definition] Primary key array
-    attr_reader :primary_key
+    # @api private
+    attr_reader :options
+
+    # @api private
+    attr_reader :relations
 
-    alias_method :to_h, :attributes
+    alias_method :to_ary, :attributes
+
+    # Define a relation schema from plain rom types
+    #
+    # Resulting schema will decorate plain rom types with adapter-specific types
+    # By default `Schema::Attribute` will be used
+    #
+    # @param [Relation::Name, Symbol] name The schema name, typically ROM::Relation::Name
+    #
+    # @return [Schema]
+    #
+    # @api public
+    def self.define(name, attr_class: Attribute, attributes: EMPTY_ARRAY, associations: EMPTY_ASSOCIATION_SET, inferrer: DEFAULT_INFERRER)
+      new(
+        name,
+        attributes: attributes(attributes, attr_class),
+        associations: associations,
+        inferrer: inferrer,
+        attr_class: attr_class
+      )
+    end
 
     # @api private
-    def initialize(name, attributes, inferrer: nil, associations: EMPTY_ASSOCIATION_SET)
+    def self.attributes(attributes, attr_class)
+      attributes.map { |type| attr_class.new(type) }
+    end
+
+    # @api private
+    def initialize(name, options)
       @name = name
-      @attributes = attributes
-      @associations = associations
-      @inferrer = inferrer
+      @options = options
+      @attributes = options[:attributes] || EMPTY_ARRAY
+      @associations = options[:associations]
+      @inferrer = options[:inferrer] || DEFAULT_INFERRER
+      @relations = options[:relations] || EMPTY_HASH
+    end
+
+    # Abstract method for creating a new relation based on schema definition
+    #
+    # This can be used by views to generate a new relation automatically.
+    # In example a schema can project a relation, join any additional relations
+    # if it uncludes attributes from other relations etc.
+    #
+    # Default implementation is a no-op and it simply returns back untouched relation
+    #
+    # @param [Relation]
+    #
+    # @return [Relation]
+    #
+    # @api public
+    def call(relation)
+      relation
     end
 
     # Iterate over schema's attributes
     #
-    # @yield [Dry::Data::Type]
+    # @yield [Schema::Attribute]
     #
     # @api public
     def each(&block)
-      attributes.each_value(&block)
+      attributes.each(&block)
+    end
+
+    # Check if schema has any attributes
+    #
+    # @return [TrueClass, FalseClass]
+    #
+    # @api public
+    def empty?
+      attributes.size == 0
+    end
+
+    # Coerce schema into a <AttributeName=>Attribute> Hash
+    #
+    # @return [Hash]
+    #
+    # @api public
+    def to_h
+      each_with_object({}) { |attr, h| h[attr.name] = attr }
     end
 
     # Return attribute
     #
+    # @param [Symbol] key The attribute name
+    # @param [Symbol, Relation::Name] src The source relation (for merged schemas)
+    #
+    # @raise KeyError
+    #
+    # @api public
+    def [](key, src = name.to_sym)
+      attr =
+        if count_index[key].equal?(1)
+          name_index[key]
+        else
+          source_index[src][key]
+        end
+
+      unless attr
+        raise(KeyError, "#{key.inspect} attribute doesn't exist in #{src} schema")
+      end
+
+      attr
+    end
+
+    # Project a schema to include only specified attributes
+    #
+    # @param [*Array<Symbol, Schema::Attribute>] names Attribute names
+    #
+    # @return [Schema]
+    #
+    # @api public
+    def project(*names)
+      new(names.map { |name| name.is_a?(Symbol) ? self[name] : name })
+    end
+
+    # Exclude provided attributes from a schema
+    #
+    # @param [*Array] names Attribute names
+    #
+    # @return [Schema]
+    #
+    # @api public
+    def exclude(*names)
+      project(*(map(&:name) - names))
+    end
+
+    # Project a schema with renamed attributes
+    #
+    # @param [Hash] mapping The attribute mappings
+    #
+    # @return [Schema]
+    #
+    # @api public
+    def rename(mapping)
+      new_attributes = map do |attr|
+        alias_name = mapping[attr.name]
+        alias_name ? attr.aliased(alias_name) : attr
+      end
+
+      new(new_attributes)
+    end
+
+    # Project a schema with renamed attributes using provided prefix
+    #
+    # @param [Symbol] prefix The name of the prefix
+    #
+    # @return [Schema]
+    #
+    # @api public
+    def prefix(prefix)
+      new(map { |attr| attr.prefixed(prefix) })
+    end
+
+    # Return new schema with all attributes marked as prefixed and wrapped
+    #
+    # This is useful when relations are joined and the right side should be marked
+    # as wrapped
+    #
+    # @param [Symbol] prefix The prefix used for aliasing wrapped attributes
+    #
+    # @return [Schema]
+    #
     # @api public
-    def [](name)
-      attributes.fetch(name)
+    def wrap(prefix = name.dataset)
+      new(map { |attr| attr.wrapped(prefix) })
     end
 
     # Return FK attribute for a given relation name
     #
-    # @return [Dry::Types::Definition]
+    # @return [Schema::Attribute]
     #
     # @api public
     def foreign_key(relation)
-      detect { |attr| attr.meta[:foreign_key] && attr.meta[:relation] == relation }
+      detect { |attr| attr.foreign_key? && attr.target == relation }
+    end
+
+    # Return primary key attributes
+    #
+    # @return [Array<Schema::Attribute>]
+    #
+    # @api public
+    def primary_key
+      select(&:primary_key?)
+    end
+
+    # Merge with another schema
+    #
+    # @param [Schema] other Other schema
+    #
+    # @return [Schema]
+    #
+    # @api public
+    def merge(other)
+      append(*other)
+    end
+    alias_method :+, :merge
+
+    # Append more attributes to the schema
+    #
+    # This returns a new schema instance
+    #
+    # @param [*Array<Schema::Attribute>]
+    #
+    # @return [Schema]
+    #
+    # @api public
+    def append(*new_attributes)
+      new(attributes + new_attributes)
+    end
+
+    # Return a new schema with uniq attributes
+    #
+    # @param [*Array<Schema::Attribute>]
+    #
+    # @return [Schema]
+    #
+    # @api public
+    def uniq(&block)
+      if block
+        new(attributes.uniq(&block))
+      else
+        new(attributes.uniq(&:name))
+      end
+    end
+
+    # Return if a schema includes an attribute with the given name
+    #
+    # @param [Symbol] name The name of the attribute
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def key?(name)
+      ! attributes.detect { |attr| attr.name == name }.nil?
     end
 
     # This hook is called when relation is being build during container finalization
@@ -77,13 +307,101 @@ module ROM
     # @return [self]
     #
     # @api private
-    def finalize!(gateway = nil, &block)
+    def finalize!(gateway: nil, relations: nil, &block)
       return self if frozen?
 
-      @attributes = inferrer.call(name.dataset, gateway) if inferrer
-      @primary_key = select { |attr| attr.meta[:primary_key] == true }
+      inferred, missing = inferrer.call(name, gateway)
+
+      attr_names = map(&:name)
+      inferred_attrs = self.class.attributes(inferred, attr_class).
+                         reject { |attr| attr_names.include?(attr.name) }
+
+      attributes.concat(inferred_attrs)
+
+      missing_attributes = missing - map(&:name)
+
+      if missing_attributes.size > 0
+        raise MissingAttributesError.new(name, missing_attributes)
+      end
+
       block.call if block
+
+      count_index
+      name_index
+      source_index
+
       freeze
     end
+
+    # Return coercion function using attribute read types
+    #
+    # This is used for `output_schema` in relations
+    #
+    # @return [Dry::Types::Hash]
+    #
+    # @api private
+    def to_output_hash
+      Types::Coercible::Hash.schema(
+        map { |attr| [attr.name, attr.to_read_type] }.to_h
+      )
+    end
+
+    # Return coercion function using attribute types
+    #
+    # This is used for `input_schema` in relations, typically commands use it
+    # for processing input
+    #
+    # @return [Dry::Types::Hash]
+    #
+    # @api private
+    def to_input_hash
+      Types::Coercible::Hash.schema(
+        map { |attr| [attr.name, attr] }.to_h
+      )
+    end
+
+    # Return a new schema with new options
+    #
+    # @example
+    #   schema.with(inferrer: my_inferrer)
+    #
+    # @param [Hash] new_options
+    #
+    # @return [Schema]
+    #
+    # @api public
+    def with(new_options)
+      self.class.new(name, options.merge(new_options))
+    end
+
+    private
+
+    # @api private
+    def count_index
+      @count_index ||= map(&:name).map { |name| [name, count { |attr| attr.name == name }] }.to_h
+    end
+
+    # @api private
+    def name_index
+      @name_index ||= map { |attr| [attr.name, attr] }.to_h
+    end
+
+    # @api private
+    def source_index
+      @source_index ||= select(&:source).
+                          group_by(&:source).
+                          map { |src, grp| [src.to_sym, grp.map { |attr| [attr.name, attr] }.to_h] }.
+                          to_h
+    end
+
+    # @api private
+    def attr_class
+      options.fetch(:attr_class)
+    end
+
+    # @api private
+    def new(attributes)
+      self.class.new(name, options.merge(attributes: attributes))
+    end
   end
 end

data/lib/rom/setup/auto_registration.rb

@@ -1,34 +1,37 @@
 require 'pathname'
 
-require 'rom/support/constants'
-require 'rom/support/inflector'
-require 'rom/support/options'
+require 'dry/core/inflector'
 
+require 'rom/types'
+require 'rom/initializer'
 require 'rom/setup/auto_registration_strategies/no_namespace'
 require 'rom/setup/auto_registration_strategies/with_namespace'
 require 'rom/setup/auto_registration_strategies/custom_namespace'
 
 module ROM
   class AutoRegistration
-    include Options
+    extend Initializer
 
-    option :namespace, reader: true, type: [TrueClass, FalseClass, String], default: true
+    NamespaceType = Types::Strict::Bool | Types::Strict::String
+    PathnameType = Types.Constructor(Pathname, &Kernel.method(:Pathname))
 
-    option :component_dirs, reader: true, type: ::Hash, default: {
+    param :directory, type: PathnameType
+
+    option :namespace, reader: true, type: NamespaceType, default: proc { true }
+
+    option :component_dirs, reader: true, type: Types::Strict::Hash, default: proc { {
       relations: :relations,
       mappers: :mappers,
       commands: :commands
-    }
+    } }
 
-    attr_reader :globs, :directory
-
-    def initialize(directory, options = EMPTY_HASH)
-      super
-      @directory = Pathname(directory)
-      @globs = Hash[component_dirs.map { |component, directory|
-        [component, @directory.join("#{directory}/**/*.rb")]
-      }]
-    end
+    option :globs, reader: true, default: -> r {
+      Hash[
+        component_dirs.map { |component, directory|
+          [component, r.directory.join("#{directory}/**/*.rb")]
+        }
+      ]
+    }
 
     def relations
       load_entities(:relations)
@@ -62,7 +65,7 @@ module ROM
               file: file, directory: directory, entity: component_dirs.fetch(entity)
             ).call
           end
-        Inflector.constantize(klass_name)
+        Dry::Core::Inflector.constantize(klass_name)
       end
     end
   end

data/lib/rom/setup/auto_registration_strategies/base.rb

@@ -1,11 +1,16 @@
+require 'rom/types'
+require 'rom/initializer'
+
 module ROM
   module AutoRegistrationStrategies
     class Base
-      include Options
+      extend Initializer
+
+      PathnameType = Types.Definition(Pathname).constrained(type: Pathname)
 
-      option :file, reader: true, type: String
+      option :file, reader: true, type: Types::Strict::String
 
-      EXTENSION_REGEX = /\.rb$/.freeze
+      EXTENSION_REGEX = /\.rb\z/.freeze
     end
   end
 end

data/lib/rom/setup/auto_registration_strategies/custom_namespace.rb

@@ -1,15 +1,16 @@
 require 'pathname'
 
-require 'rom/support/inflector'
+require 'dry/core/inflector'
+require 'rom/types'
 require 'rom/setup/auto_registration_strategies/base'
 
 module ROM
   module AutoRegistrationStrategies
     class CustomNamespace < Base
-      option :namespace, reader: true, type: String
+      option :namespace, reader: true, type: Types::Strict::String
 
       def call
-        "#{namespace}::#{Inflector.camelize(filename)}"
+        "#{namespace}::#{Dry::Core::Inflector.camelize(filename)}"
       end
 
       private

data/lib/rom/setup/auto_registration_strategies/no_namespace.rb

@@ -1,16 +1,17 @@
 require 'pathname'
 
-require 'rom/support/inflector'
+require 'dry/core/inflector'
+require 'rom/types'
 require 'rom/setup/auto_registration_strategies/base'
 
 module ROM
   module AutoRegistrationStrategies
     class NoNamespace < Base
-      option :directory, reader: true, type: Pathname
-      option :entity, reader: true, type: Symbol
+      option :directory, reader: true, type: PathnameType
+      option :entity, reader: true, type: Types::Strict::Symbol
 
       def call
-        Inflector.camelize(
+        Dry::Core::Inflector.camelize(
           file.sub(/^#{directory}\/#{entity}\//, '').sub(EXTENSION_REGEX, '')
         )
       end

data/lib/rom/setup/auto_registration_strategies/with_namespace.rb

@@ -1,15 +1,15 @@
 require 'pathname'
 
-require 'rom/support/inflector'
+require 'dry/core/inflector'
 require 'rom/setup/auto_registration_strategies/base'
 
 module ROM
   module AutoRegistrationStrategies
     class WithNamespace < Base
-      option :directory, reader: true, type: Pathname
+      option :directory, reader: true, type: PathnameType
 
       def call
-        Inflector.camelize(
+        Dry::Core::Inflector.camelize(
           file.sub(/^#{directory.dirname}\//, '').sub(EXTENSION_REGEX, '')
         )
       end

data/lib/rom/setup/finalize/finalize_commands.rb

@@ -1,4 +1,4 @@
-require 'rom/support/registry'
+require 'rom/registry'
 require 'rom/command_registry'
 
 module ROM

data/lib/rom/setup/finalize/finalize_mappers.rb

@@ -1,4 +1,4 @@
-require 'rom/support/registry'
+require 'rom/registry'
 
 module ROM
   class Finalize

data/lib/rom/setup/finalize/finalize_relations.rb

@@ -50,10 +50,12 @@ module ROM
         gateway = @gateways.fetch(klass.gateway)
         ds_proc = klass.dataset_proc || -> _ { self }
 
-        klass.schema.finalize!(gateway) if klass.schema
+        klass.schema(infer: true) unless klass.schema
+        schema = klass.schema.finalize!(gateway: gateway, relations: registry)
+
         dataset = gateway.dataset(klass.dataset).instance_exec(klass, &ds_proc)
 
-        klass.new(dataset, __registry__: registry)
+        klass.new(dataset, __registry__: registry, schema: schema.with(relations: registry))
       end
     end
   end

data/lib/rom/setup/finalize.rb

@@ -1,7 +1,7 @@
 require 'rom/relation'
 require 'rom/command'
 
-require 'rom/support/registry'
+require 'rom/registry'
 require 'rom/command_registry'
 require 'rom/mapper_registry'
 

data/lib/rom/transaction.rb

@@ -0,0 +1,24 @@
+module ROM
+  # @api private
+  class Transaction
+    # @api private
+    Rollback = Class.new(StandardError)
+
+    # @api private
+    def run(opts = EMPTY_HASH)
+      yield(self)
+    rescue Rollback
+      # noop
+    end
+
+    # Unconditionally roll back the current transaction
+    #
+    # @api public
+    def rollback!
+      raise Rollback
+    end
+
+    # @api private
+    NoOp = Transaction.new.freeze
+  end
+end

data/lib/rom/types.rb

@@ -9,9 +9,17 @@ module ROM
       super
     end
 
+    def self.Definition(primitive)
+      Dry::Types::Definition.new(primitive)
+    end
+
+    def self.Constructor(primitive, &block)
+      Types.Definition(primitive).constructor(&block)
+    end
+
     module Methods
       def ForeignKey(relation, type = Types::Int)
-        type.meta(foreign_key: true, relation: relation)
+        type.meta(foreign_key: true, target: relation)
       end
     end
   end

data/lib/rom/version.rb

@@ -1,3 +1,3 @@
 module ROM
-  VERSION = '2.0.2'.freeze
+  VERSION = '3.0.0'.freeze
 end

data/lib/rom.rb

@@ -1,16 +1,12 @@
 require 'dry-equalizer'
+require 'dry/core/constants'
 
-require 'rom-support'
 require 'rom/version'
 require 'rom/constants'
 
-# internal ROM support lib
-require 'rom/support/inflector'
-require 'rom/support/registry'
-require 'rom/support/options'
-require 'rom/support/class_macros'
-require 'rom/support/class_builder'
-require 'rom/support/inheritance_hook'
+module ROM
+  include Dry::Core::Constants
+end
 
 # core parts
 require 'rom/configuration_plugin'

data/rom.gemspec

@@ -17,10 +17,11 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
   gem.add_runtime_dependency 'dry-equalizer', '~> 0.2'
-  gem.add_runtime_dependency 'dry-types', '~> 0.8'
-  gem.add_runtime_dependency 'rom-support', '~> 2.0'
-  gem.add_runtime_dependency 'rom-mapper', '~> 0.4.0'
+  gem.add_runtime_dependency 'dry-types', '~> 0.9', '>= 0.9.4'
+  gem.add_runtime_dependency 'dry-core', '~> 0.2', '>= 0.2.3'
+  gem.add_runtime_dependency 'dry-initializer', '~> 0.10', '>= 0.10.2'
+  gem.add_runtime_dependency 'rom-mapper', '~> 0.5'
 
   gem.add_development_dependency 'rake', '~> 10.3'
-  gem.add_development_dependency 'rspec', '~> 3.3'
+  gem.add_development_dependency 'rspec', '~> 3.5'
 end