rom 3.0.0.beta3 → 3.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98cf29125e7e877f9eadf9603755d7bacf9603af
-  data.tar.gz: 596ae65060eb04d7f52be2406908a4541b758c6e
+  metadata.gz: 3b8faaf70d24fe2d5212f777e8023dfc4b6a2e34
+  data.tar.gz: 4fe312831401a4a99c9837ef1948af386b558762
 SHA512:
-  metadata.gz: 8cf082f7aa10bc96e0b186f8bf42b6d64fa3a703780cf763292f2393374009a5a26f5387b4b0df2381371d82cf49bdb210438c07fb0b9303a72d5065e3952fd8
-  data.tar.gz: 864cd037917d3df2ded0efca14a7a27aa53023ce296532df70aa28f7cb5ad1b917b41b6ada18e6be6ec566f321cd6d4920d9f954096330e07e11ab89539f40b4
+  metadata.gz: e46223303dd3c701780526df9184c5c2c03cec5aee5a5cc3d3ba64ebd6e962619c2b04af8c309db4410d19bbf999e41c2ef813a667bccd5d5c8c468d69ff9fef
+  data.tar.gz: 09b1af7a72438045fc804872a8cfa63ac8d9c2c3add1123a71f6e6117d7f61c65e005c241e35757a25b3d2ec19b877f97516ba6bae74b973083e5f013d2bb21f

data/.travis.yml

@@ -5,20 +5,17 @@ cache: bundler
 bundler_args: --without sql benchmarks console tools
 script: "bundle exec rake ci"
 after_success:
-  - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
+  - '[ "${TRAVIS_JOB_NUMBER#*.}" = "1" ] && [ "$TRAVIS_BRANCH" = "master" ] && bundle exec codeclimate-test-reporter'
 rvm:
-  - 2.2.6
-  - 2.3.3
   - 2.4.0
+  - 2.3
+  - 2.2
   - rbx-3
-  - jruby-9.1.5.0
+  - jruby
 env:
   global:
     - JRUBY_OPTS='--dev -J-Xmx1024M'
     - COVERAGE='true'
-matrix:
-  allow_failures:
-    - rvm: rbx-3
 notifications:
   webhooks:
     urls:

data/.yardopts

@@ -0,0 +1,2 @@
+--query '@api.text != "private"'
+--embed-mixins

data/Gemfile

@@ -2,6 +2,8 @@ source 'https://rubygems.org'
 
 gemspec
 
+gem 'rom-mapper', git: 'https://github.com/rom-rb/rom-mapper.git', branch: 'master'
+
 group :console do
   gem 'pry'
   gem 'pg', platforms: [:mri]

data/Rakefile

@@ -11,7 +11,7 @@ task :"spec:isolation" do
   end
 end
 
-if RUBY_ENGINE == 'jruby'
+if RUBY_ENGINE != 'ruby'
   desc "Run CI tasks"
   task ci: [:spec, :lint]
 else

data/lib/rom/command.rb

@@ -31,7 +31,7 @@ module ROM
     extend Dry::Core::ClassAttributes
     extend ClassInterface
 
-    defines :adapter, :relation, :result, :input, :register_as, :restrictable, :before, :after
+    defines :adapter, :relation, :result, :input, :register_as, :restrictable
 
     # @attr_reader [Relation] relation The command's relation
     param :relation

data/lib/rom/commands/class_interface.rb

@@ -7,6 +7,15 @@ module ROM
   # @private
   class Command
     module ClassInterface
+      # This hook sets up default class state
+      #
+      # @api private
+      def inherited(klass)
+        super
+        klass.instance_variable_set(:'@before', before ? before.dup : [])
+        klass.instance_variable_set(:'@after', before ? after.dup : [])
+      end
+
       # Return adapter specific sub-class based on the adapter identifier
       #
       # This is a syntax sugar to make things consistent
@@ -106,6 +115,110 @@ module ROM
         include(relation_methods_mod(relation.class))
       end
 
+      # Set before-execute hooks
+      #
+      # @overload before(hook)
+      #   Set an before hook as a method name
+      #
+      #   @example
+      #     class CreateUser < ROM::Commands::Create[:sql]
+      #       relation :users
+      #       register_as :create
+      #
+      #       before :my_hook
+      #
+      #       def my_hook(tuple, *)
+      #         puts "hook called#
+      #       end
+      #     end
+      #
+      # @overload before(hook_opts)
+      #   Set an before hook as a method name with arguments
+      #
+      #   @example
+      #     class CreateUser < ROM::Commands::Create[:sql]
+      #       relation :users
+      #       register_as :create
+      #
+      #       before my_hook: { arg1: 1, arg1: 2 }
+      #
+      #       def my_hook(tuple, arg1:, arg2:)
+      #         puts "hook called with args: #{arg1} and #{arg2}"
+      #       end
+      #     end
+      #
+      #   @param [Hash<Symbol=>Hash>] hook Options with method name and pre-set args
+      #
+      # @return [Array<Hash, Symbol>] A list of all configured before hooks
+      #
+      # @api public
+      def before(*hooks)
+        if hooks.size > 0
+          set_hooks(:before, hooks)
+        else
+          @before
+        end
+      end
+
+      # Set after-execute hooks
+      #
+      # @overload after(hook)
+      #   Set an after hook as a method name
+      #
+      #   @example
+      #     class CreateUser < ROM::Commands::Create[:sql]
+      #       relation :users
+      #       register_as :create
+      #
+      #       after :my_hook
+      #
+      #       def my_hook(tuple, *)
+      #         puts "hook called#
+      #       end
+      #     end
+      #
+      # @overload after(hook_opts)
+      #   Set an after hook as a method name with arguments
+      #
+      #   @example
+      #     class CreateUser < ROM::Commands::Create[:sql]
+      #       relation :users
+      #       register_as :create
+      #
+      #       after my_hook: { arg1: 1, arg1: 2 }
+      #
+      #       def my_hook(tuple, arg1:, arg2:)
+      #         puts "hook called with args: #{arg1} and #{arg2}"
+      #       end
+      #     end
+      #
+      #   @param [Hash<Symbol=>Hash>] hook Options with method name and pre-set args
+      #
+      # @return [Array<Hash, Symbol>] A list of all configured after hooks
+      #
+      # @api public
+      def after(*hooks)
+        if hooks.size > 0
+          set_hooks(:after, hooks)
+        else
+          @after
+        end
+      end
+
+      # Set new or more hooks
+      #
+      # @api private
+      def set_hooks(type, hooks)
+        ivar = :"@#{type}"
+        value = instance_variable_get(ivar)
+
+        if value.empty?
+          instance_variable_set(ivar, hooks)
+        else
+          value.concat(hooks)
+        end
+      end
+
       # Return default name of the command class based on its name
       #
       # During setup phase this is used by defalut as `register_as` option

data/lib/rom/configuration.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 require 'rom/environment'
 require 'rom/setup'
 require 'rom/configuration_dsl'

data/lib/rom/relation/class_interface.rb

@@ -12,6 +12,7 @@ require 'rom/schema'
 
 module ROM
   class Relation
+    # @api public
     module ClassInterface
       include Dry::Core::Constants
 
@@ -185,20 +186,45 @@ module ROM
         end
       end
 
-      # Define a relation view with a specific header
+      # Define a relation view with a specific schema
       #
-      # With headers defined all the mappers will be inferred automatically
+      # 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.
       #
-      # @example
-      #   class Users < ROM::Relation[:sql]
-      #     view(:by_name, [:id, :name]) do |name|
-      #       where(name: name)
+      # @overload view(name, schema, &block)
+      #   @example View with the canonical schema
+      #     class Users < ROM::Relation[:sql]
+      #       view(:listing, schema) do
+      #         order(:name)
+      #       end
       #     end
       #
-      #     view(:listing, [:id, :name, :email]) do
-      #       select(:id, :name, :email).order(:name)
+      #   @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
-      #   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)
@@ -233,6 +259,8 @@ module ROM
             schemas[name].(instance_exec(&relation_block))
           end
         end
+
+        name
       end
 
       # Dynamically define a method that will forward to the dataset and wrap

data/lib/rom/relation.rb

@@ -71,7 +71,7 @@ module ROM
 
     # Return schema attribute
     #
-    # @return [Schema::Type]
+    # @return [Schema::Attribute]
     #
     # @api public
     def [](name)

data/lib/rom/schema/attribute.rb

@@ -0,0 +1,367 @@
+require 'delegate'
+require 'dry/equalizer'
+require 'dry/types/decorator'
+
+module ROM
+  class Schema
+    # 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)
+
+      # !@attribute [r] type
+      #   @return [Dry::Types::Definition, Dry::Types::Sum, Dry::Types::Constrained]
+      attr_reader :type
+
+      # @api private
+      def initialize(type)
+        @type = type
+      end
+
+      # @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 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 [Schema::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 [Schema::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 [Schema::Attribute]
+      #
+      # @api public
+      def wrapped(name = source.dataset)
+        self.class.new(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 [Schema::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, Schema::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 [Schema::Attribute]
+      #
+      # @api private
+      def to_read_type
+        read? ? meta[:read] : type
+      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

data/lib/rom/schema.rb

@@ -1,15 +1,35 @@
 require 'dry-equalizer'
 
-require 'rom/schema/type'
+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
@@ -45,20 +65,29 @@ module ROM
 
     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, type_class: Type, attributes: EMPTY_ARRAY, associations: EMPTY_ASSOCIATION_SET, inferrer: DEFAULT_INFERRER)
+    def self.define(name, attr_class: Attribute, attributes: EMPTY_ARRAY, associations: EMPTY_ASSOCIATION_SET, inferrer: DEFAULT_INFERRER)
       new(
         name,
-        attributes: attributes(attributes, type_class),
+        attributes: attributes(attributes, attr_class),
         associations: associations,
         inferrer: inferrer,
-        type_class: type_class
+        attr_class: attr_class
       )
     end
 
     # @api private
-    def self.attributes(attributes, type_class)
-      attributes.map { |type| type_class.new(type) }
+    def self.attributes(attributes, attr_class)
+      attributes.map { |type| attr_class.new(type) }
     end
 
     # @api private
@@ -90,18 +119,26 @@ module ROM
 
     # Iterate over schema's attributes
     #
-    # @yield [Schema::Type]
+    # @yield [Schema::Attribute]
     #
     # @api public
     def each(&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 }
@@ -109,6 +146,11 @@ module ROM
 
     # 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 =
@@ -127,7 +169,7 @@ module ROM
 
     # Project a schema to include only specified attributes
     #
-    # @param [*Array] names Attribute names
+    # @param [*Array<Symbol, Schema::Attribute>] names Attribute names
     #
     # @return [Schema]
     #
@@ -174,6 +216,15 @@ module ROM
       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 wrap(prefix = name.dataset)
       new(map { |attr| attr.wrapped(prefix) })
@@ -181,7 +232,7 @@ module ROM
 
     # Return FK attribute for a given relation name
     #
-    # @return [Dry::Types::Definition]
+    # @return [Schema::Attribute]
     #
     # @api public
     def foreign_key(relation)
@@ -190,7 +241,7 @@ module ROM
 
     # Return primary key attributes
     #
-    # @return [Array<Schema::Type>]
+    # @return [Array<Schema::Attribute>]
     #
     # @api public
     def primary_key
@@ -211,7 +262,9 @@ module ROM
 
     # Append more attributes to the schema
     #
-    # @param [*Array<Schema::Type>]
+    # This returns a new schema instance
+    #
+    # @param [*Array<Schema::Attribute>]
     #
     # @return [Schema]
     #
@@ -222,7 +275,7 @@ module ROM
 
     # Return a new schema with uniq attributes
     #
-    # @param [*Array<Schema::Type>]
+    # @param [*Array<Schema::Attribute>]
     #
     # @return [Schema]
     #
@@ -260,7 +313,7 @@ module ROM
       inferred, missing = inferrer.call(name, gateway)
 
       attr_names = map(&:name)
-      inferred_attrs = self.class.attributes(inferred, type_class).
+      inferred_attrs = self.class.attributes(inferred, attr_class).
                          reject { |attr| attr_names.include?(attr.name) }
 
       attributes.concat(inferred_attrs)
@@ -282,6 +335,12 @@ module ROM
       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(
@@ -289,6 +348,13 @@ module ROM
       )
     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(
@@ -317,8 +383,8 @@ module ROM
     end
 
     # @api private
-    def type_class
-      options.fetch(:type_class)
+    def attr_class
+      options.fetch(:attr_class)
     end
 
     # @api private

data/lib/rom/version.rb

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

data/rom.gemspec

@@ -17,10 +17,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 '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.0.beta'
+  gem.add_runtime_dependency 'rom-mapper', '~> 0.5.0.rc'
 
   gem.add_development_dependency 'rake', '~> 10.3'
   gem.add_development_dependency 'rspec', '~> 3.5'

data/spec/unit/rom/commands/pre_and_post_processors_spec.rb

@@ -1,49 +1,58 @@
 require 'rom/command'
+require 'rom/memory'
 
-RSpec.describe ROM::Command, 'before/after hooks' do
+RSpec.describe ROM::Commands::Create[:memory], 'before/after hooks' do
   let(:relation) do
     spy(:relation)
   end
 
   describe '#before' do
     subject(:command) do
-      Class.new(ROM::Command) do
+      Class.new(ROM::Commands::Create[:memory]) do
         before :init
+        before :normalize
 
         def init(*)
         end
 
+        def normalize(*)
+        end
+
         def prepare(*)
         end
       end.build(relation)
     end
 
     it 'returns a new command with configured before hooks' do
-      expect(command.before(:prepare).before_hooks).to eql(%i[init prepare])
+      expect(command.before(:prepare).before_hooks).to eql(%i[init normalize prepare])
     end
   end
 
   describe '#after' do
     subject(:command) do
-      Class.new(ROM::Command) do
+      Class.new(ROM::Commands::Create[:memory]) do
         after :finalize
+        after :filter
 
         def finalize(*)
         end
 
+        def filter(*)
+        end
+
         def prepare(*)
         end
       end.build(relation)
     end
 
     it 'returns a new command with configured after hooks' do
-      expect(command.after(:prepare).after_hooks).to eql(%i[finalize prepare])
+      expect(command.after(:prepare).after_hooks).to eql(%i[finalize filter prepare])
     end
   end
 
   context 'without curried args' do
     subject(:command) do
-      Class.new(ROM::Command) do
+      Class.new(ROM::Commands::Create[:memory]) do
         result :many
         before :prepare
         after :finalize
@@ -87,7 +96,7 @@ RSpec.describe ROM::Command, 'before/after hooks' do
 
   context 'with curried args' do
     subject(:command) do
-      Class.new(ROM::Command) do
+      Class.new(ROM::Commands::Create[:memory]) do
         result :many
         before :prepare
         after :finalize
@@ -135,10 +144,10 @@ RSpec.describe ROM::Command, 'before/after hooks' do
 
   context 'with pre-set opts' do
     subject(:command) do
-      Class.new(ROM::Command) do
+      Class.new(ROM::Commands::Create[:memory]) do
         result :many
-        before [prepare: { prepared: true }]
-        after [finalize: { finalized: true }]
+        before prepare: { prepared: true }
+        after finalize: { finalized: true }
 
         def execute(tuples)
           input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
@@ -183,10 +192,10 @@ RSpec.describe ROM::Command, 'before/after hooks' do
 
   context 'with pre-set opts for a curried command' do
     subject(:command) do
-      Class.new(ROM::Command) do
+      Class.new(ROM::Commands::Create[:memory]) do
         result :many
-        before [prepare: { prepared: true }]
-        after [finalize: { finalized: true }]
+        before prepare: { prepared: true }
+        after finalize: { finalized: true }
 
         def execute(tuples)
           input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
@@ -231,10 +240,10 @@ RSpec.describe ROM::Command, 'before/after hooks' do
 
   context 'calling with multiple args' do
     subject(:command) do
-      Class.new(ROM::Command) do
+      Class.new(ROM::Commands::Create[:memory]) do
         result :many
-        before [prepare: { prepared: true }]
-        after [finalize: { finalized: true }]
+        before prepare: { prepared: true }
+        after finalize: { finalized: true }
 
         def execute(tuples)
           input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }

data/spec/unit/rom/relation/view_spec.rb

@@ -1,9 +1,19 @@
 require 'rom'
 require 'rom/memory'
 
-RSpec.describe ROM::Relation do
+RSpec.describe ROM::Relation, '.view' do
   subject(:relation) { relation_class.new(ROM::Memory::Dataset.new([])) }
 
+  it 'returns view method name' do
+    klass = Class.new(ROM::Relation[:memory]) {
+      schema { attribute :id, ROM::Types::Int }
+    }
+
+    name = klass.view(:by_id, klass.schema) { self }
+
+    expect(name).to be(:by_id)
+  end
+
   shared_context 'relation with views' do
     before do
       relation << { id: 1, name: 'Joe' }

data/spec/unit/rom/schema/type_spec.rb

@@ -1,31 +1,31 @@
-require 'rom/schema/type'
+require 'rom/schema/attribute'
 
-RSpec.describe ROM::Schema::Type do
+RSpec.describe ROM::Schema::Attribute do
   describe '#inspect' do
     context 'with a primitive definition' do
       subject(:type) do
-        ROM::Schema::Type.new(ROM::Types::Int).meta(name: :id, primary_key: true)
+        ROM::Schema::Attribute.new(ROM::Types::Int).meta(name: :id, primary_key: true)
       end
 
       specify do
-        expect(type.inspect).to eql("#<ROM::Schema::Type[Integer] name=:id primary_key=true>")
+        expect(type.inspect).to eql("#<ROM::Schema::Attribute[Integer] name=:id primary_key=true>")
       end
     end
 
     context 'with a sum' do
       subject(:type) do
-        ROM::Schema::Type.new(ROM::Types::Bool).meta(name: :admin)
+        ROM::Schema::Attribute.new(ROM::Types::Bool).meta(name: :admin)
       end
 
       specify do
-        expect(type.inspect).to eql("#<ROM::Schema::Type[TrueClass | FalseClass] name=:admin>")
+        expect(type.inspect).to eql("#<ROM::Schema::Attribute[TrueClass | FalseClass] name=:admin>")
       end
     end
   end
 
   describe '#aliased' do
     subject(:type) do
-      ROM::Schema::Type.new(ROM::Types::String).meta(name: :user_name)
+      ROM::Schema::Attribute.new(ROM::Types::String).meta(name: :user_name)
     end
 
     specify do
@@ -35,7 +35,7 @@ RSpec.describe ROM::Schema::Type do
 
   describe '#method_missing' do
     subject(:type) do
-      ROM::Schema::Type.new(ROM::Types::Int).meta(name: :id, primary_key: true)
+      ROM::Schema::Attribute.new(ROM::Types::Int).meta(name: :id, primary_key: true)
     end
 
     specify do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom
 version: !ruby/object:Gem::Version
-  version: 3.0.0.beta3
+  version: 3.0.0.rc1
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-19 00:00:00.000000000 Z
+date: 2017-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -44,14 +44,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.4
 - !ruby/object:Gem::Dependency
   name: dry-core
   requirement: !ruby/object:Gem::Requirement
@@ -98,14 +104,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0.beta
+        version: 0.5.0.rc
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0.beta
+        version: 0.5.0.rc
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -145,6 +151,7 @@ files:
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".travis.yml"
+- ".yardopts"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
@@ -226,8 +233,8 @@ files:
 - lib/rom/relation/view_dsl.rb
 - lib/rom/relation_registry.rb
 - lib/rom/schema.rb
+- lib/rom/schema/attribute.rb
 - lib/rom/schema/dsl.rb
-- lib/rom/schema/type.rb
 - lib/rom/setup.rb
 - lib/rom/setup/auto_registration.rb
 - lib/rom/setup/auto_registration_strategies/base.rb

data/lib/rom/schema/type.rb

@@ -1,129 +0,0 @@
-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 private
-      def [](input)
-        type[input]
-      end
-
-      # @api private
-      def read?
-        ! meta[:read].nil?
-      end
-
-      def to_read_type
-        read? ? meta[:read] : 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