rom 2.0.2 → 3.0.0.beta1

data/lib/rom/schema.rb

@@ -1,6 +1,6 @@
 require 'dry-equalizer'
 
-require 'rom/support/constants'
+require 'rom/schema/type'
 require 'rom/schema/dsl'
 require 'rom/association_set'
 
@@ -10,6 +10,13 @@ module ROM
   # @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 +26,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,34 +37,146 @@ 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_ary, :attributes
 
-    alias_method :to_h, :attributes
+    # @api public
+    def self.define(name, type_class: Type, attributes: EMPTY_ARRAY, associations: EMPTY_ASSOCIATION_SET, inferrer: DEFAULT_INFERRER)
+      new(
+        name,
+        attributes: attributes(attributes, type_class),
+        associations: associations,
+        inferrer: inferrer,
+        type_class: type_class
+      )
+    end
+
+    # @api private
+    def self.attributes(attributes, type_class)
+      attributes.map { |type| type_class.new(type) }
+    end
 
     # @api private
-    def initialize(name, attributes, inferrer: nil, associations: EMPTY_ASSOCIATION_SET)
+    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::Type]
     #
     # @api public
     def each(&block)
-      attributes.each_value(&block)
+      attributes.each(&block)
+    end
+
+    # @api public
+    def empty?
+      attributes.size == 0
+    end
+
+    # @api public
+    def to_h
+      each_with_object({}) { |attr, h| h[attr.name] = attr }
     end
 
     # Return attribute
     #
     # @api public
-    def [](name)
-      attributes.fetch(name)
+    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] 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
+
+    # @api public
+    def wrap(prefix = name.dataset)
+      new(map { |attr| attr.wrapped(prefix) })
     end
 
     # Return FK attribute for a given relation name
@@ -66,7 +185,39 @@ module ROM
     #
     # @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::Type>]
+    #
+    # @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)
+      new(attributes + other.attributes)
+    end
+    alias_method :+, :merge
+
+    # 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 +228,62 @@ 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, type_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
+
+      options[:relations] = @relations = relations
+
       block.call if block
+
+      count_index
+      name_index
+      source_index
+
       freeze
     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 type_class
+      options.fetch(:type_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,7 +50,9 @@ 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
+        klass.schema.finalize!(gateway: gateway, relations: registry)
+
         dataset = gateway.dataset(klass.dataset).instance_exec(klass, &ds_proc)
 
         klass.new(dataset, __registry__: registry)

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.beta1'.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

@@ -18,9 +18,10 @@ 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-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.0.beta'
 
   gem.add_development_dependency 'rake', '~> 10.3'
-  gem.add_development_dependency 'rspec', '~> 3.3'
+  gem.add_development_dependency 'rspec', '~> 3.5'
 end

data/spec/integration/command_registry_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'ROM::CommandRegistry' do
+RSpec.describe 'ROM::CommandRegistry' do
   include_context 'container'
 
   let(:users) { container.command(:users) }
@@ -11,7 +11,6 @@ describe 'ROM::CommandRegistry' do
     configuration.register_command(Class.new(ROM::Commands::Create[:memory]) do
       register_as :create
       relation :users
-      validator proc { |input| raise(ROM::CommandError) unless input[:name] }
     end)
   end
 
@@ -41,18 +40,6 @@ describe 'ROM::CommandRegistry' do
       expect(result).to match_array([{ name: 'Jane' }])
     end
 
-    it 'returns a failure result object on failed execution' do
-      result = users.try { users.create.call({}) }
-
-      expect(result.value).to be(nil)
-    end
-
-    it 'returns a failure result on unsuccessful curried-command execution' do
-      result = users.try { users.create.curry({}) }
-
-      expect(result.value).to be(nil)
-    end
-
     it 'allows checking if a command is available using respond_to?' do
       expect(users).to respond_to(:create)
     end

data/spec/integration/commands/create_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'dry-struct'
 
-describe 'Commands / Create' do
+RSpec.describe 'Commands / Create' do
   include_context 'container'
   include_context 'users and tasks'
 
@@ -9,18 +9,6 @@ describe 'Commands / Create' do
   let(:tasks) { container.commands.tasks }
 
   before do
-    module Test
-      UserValidator = Class.new do
-        ValidationError = Class.new(ROM::CommandError)
-
-        def self.call(params)
-          unless params[:name] && params[:email]
-            raise ValidationError, ":name and :email are required"
-          end
-        end
-      end
-    end
-
     configuration.relation(:users)
     configuration.relation(:tasks)
 
@@ -28,16 +16,16 @@ describe 'Commands / Create' do
       relation :users
       register_as :create
       result :one
-      validator Test::UserValidator
     end
 
     class Test::CreateTask < ROM::Commands::Create[:memory]
       relation :tasks
       register_as :create
       result :one
+      before :associate
 
-      def execute(task, user)
-        super(task.merge(name: user.to_h[:name]))
+      def associate(task, user)
+        task.merge(name: user.to_h[:name])
       end
     end
 
@@ -89,14 +77,6 @@ describe 'Commands / Create' do
     expect(result.value).to eql(name: 'Piotr', title: 'Finish command-api')
   end
 
-  it 'returns validation object with errors on failed validation' do
-    result = users.try { users.create.call(name: 'Piotr') }
-
-    expect(result.error).to be_instance_of(Test::ValidationError)
-    expect(result.error.message).to eql(":name and :email are required")
-    expect(container.relations.users.count).to be(2)
-  end
-
   describe '"result" option' do
     it 'returns a single tuple when set to :one' do
       configuration.commands(:users) do
@@ -122,7 +102,7 @@ describe 'Commands / Create' do
           end
         end
         container
-      }.to raise_error(ROM::Options::InvalidOptionValueError)
+      }.to raise_error(Dry::Types::ConstraintError)
     end
   end
 

data/spec/integration/commands/delete_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Commands / Delete' do
+RSpec.describe 'Commands / Delete' do
   include_context 'container'
   include_context 'users and tasks'