rom 3.0.0.beta2 → 3.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7783cc66c1b765933756f1ac1aa1c90d37e457c3
-  data.tar.gz: b7303d0198ff50269246903fe532500a94fd4829
+  metadata.gz: 98cf29125e7e877f9eadf9603755d7bacf9603af
+  data.tar.gz: 596ae65060eb04d7f52be2406908a4541b758c6e
 SHA512:
-  metadata.gz: 228c165ca9052fc4a50963fc17929ff0f1eb6ee94a856df11d0d9dc58eae5118f908c9dbb58db4f50071a9398bf92afbd28e247f8f15753d31edc25ea76494a9
-  data.tar.gz: 836531fb06c233cdee08a8cad06c648bc498095a7914d50f3dc25553dab7e761d912b38dde9f9fcbd9638db5381e6a0506798b1e455d77c58af6360e8dc29ea3
+  metadata.gz: 8cf082f7aa10bc96e0b186f8bf42b6d64fa3a703780cf763292f2393374009a5a26f5387b4b0df2381371d82cf49bdb210438c07fb0b9303a72d5065e3952fd8
+  data.tar.gz: 864cd037917d3df2ded0efca14a7a27aa53023ce296532df70aa28f7cb5ad1b917b41b6ada18e6be6ec566f321cd6d4920d9f954096330e07e11ab89539f40b4

data/CHANGELOG.md

@@ -6,13 +6,14 @@
 * Schemas have their own types with adapter-specific APIs (solnic)
 * Schema attributes include meta properties `source` and `target` (for FKs) (solnic)
 * Inferred schemas can have explicit attribute definitions for cases where inference didn't work (solnic)
-* New schema APIs: `#project`, `#rename`, `#exclude`, `#prefix`, `#wrap` and `#merge` (solnic)
+* New schema APIs: `#project`, `#rename`, `#exclude`, `#prefix`, `#wrap`, `#merge`, `#append` and `#uniq` (solnic)
 * New schema attribute APIs: `#name`, `#aliased`, `#aliased?`, `#prefixed`, `#prefixed?`, `#wrapped`, `#wrapped?`, `#source`, `#target`, `#primary_key?`, `#foreign_key?` (solnic)
 * Schemas are coercible to arrays that include all attribute types (solnic)
 * Automatic relation view projection via `Schema#call` (abstract method for adapters) (solnic)
 * `Relation#new(dataset, new_opts)` interface (solnic)
 * `Relation#[]` interface for convenient access to schema attributes (solnic)
 * `Command` has now support for `before` and `after` hooks (solnic)
+* Support for `read` types in schemas, these are used when relation loads its tuples (solnic)
 * New `Command#before` method for creating a command with before hook(s) at run-time (solnic)
 * New `Command#after` method for creating a command with after hook(s) at run-time (solnic)
 * New `Gateway#transaction` method runs code inside a transaction (flash-gordon)

data/lib/rom/command.rb

@@ -170,14 +170,19 @@ module ROM
       self.class.build(new_relation, options.merge(source: relation))
     end
 
+    # @api public
+    def with_opts(new_opts)
+      self.class.new(relation, options.merge(new_opts))
+    end
+
     # @api public
     def before(*hooks)
-      self.class.new(relation, options.merge(before: hooks))
+      self.class.new(relation, options.merge(before: before_hooks + hooks))
     end
 
     # @api public
     def after(*hooks)
-      self.class.new(relation, options.merge(after: hooks))
+      self.class.new(relation, options.merge(after: after_hooks + hooks))
     end
 
     private

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

@@ -20,9 +20,9 @@ module ROM
 
               input_handler =
                 if default_input != Hash && relation.schema?
-                  -> tuple { relation.schema_hash[input[tuple]] }
+                  -> tuple { relation.input_schema[input[tuple]] }
                 elsif relation.schema?
-                  relation.schema_hash
+                  relation.input_schema
                 else
                   default_input
                 end

data/lib/rom/relation.rb

@@ -30,6 +30,8 @@ module ROM
   #
   # @api public
   class Relation
+    NOOP_OUTPUT_SCHEMA = -> tuple { tuple }.freeze
+
     extend Initializer
     extend ClassInterface
 
@@ -51,13 +53,20 @@ module ROM
     #                    schema (if it was defined) and sets an empty one as
     #                    the fallback
     #   @api public
-    option :schema, reader: true, default: method(:default_schema).to_proc
+    option :schema, reader: true, optional: true, default: method(:default_schema).to_proc
 
-    # @!attribute [r] schema_hash
+    # @!attribute [r] input_schema
     #   @return [Object#[]] tuple processing function, uses schema or defaults to Hash[]
     #   @api private
-    option :schema_hash, reader: true, default: -> relation {
-      relation.schema? ? Types::Coercible::Hash.schema(relation.schema.to_h) : Hash
+    option :input_schema, reader: true, default: -> relation {
+      relation.schema? ? schema.to_input_hash : Hash
+    }
+
+    # @!attribute [r] output_schema
+    #   @return [Object#[]] tuple processing function, uses schema or defaults to NOOP_OUTPUT_SCHEMA
+    #   @api private
+    option :output_schema, reader: true, optional: true, default: -> relation {
+      relation.schema.any?(&:read?) ? schema.to_output_hash : NOOP_OUTPUT_SCHEMA
     }
 
     # Return schema attribute
@@ -77,7 +86,7 @@ module ROM
     # @api public
     def each(&block)
       return to_enum unless block
-      dataset.each { |tuple| yield(tuple) }
+      dataset.each { |tuple| yield(output_schema[tuple]) }
     end
 
     # Composes with other relations

data/lib/rom/schema.rb

@@ -205,10 +205,36 @@ module ROM
     #
     # @api public
     def merge(other)
-      new(attributes + other.attributes)
+      append(*other)
     end
     alias_method :+, :merge
 
+    # Append more attributes to the schema
+    #
+    # @param [*Array<Schema::Type>]
+    #
+    # @return [Schema]
+    #
+    # @api public
+    def append(*new_attributes)
+      new(attributes + new_attributes)
+    end
+
+    # Return a new schema with uniq attributes
+    #
+    # @param [*Array<Schema::Type>]
+    #
+    # @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
@@ -256,6 +282,20 @@ module ROM
       freeze
     end
 
+    # @api private
+    def to_output_hash
+      Types::Coercible::Hash.schema(
+        map { |attr| [attr.name, attr.to_read_type] }.to_h
+      )
+    end
+
+    # @api private
+    def to_input_hash
+      Types::Coercible::Hash.schema(
+        map { |attr| [attr.name, attr] }.to_h
+      )
+    end
+
     private
 
     # @api private

data/lib/rom/schema/dsl.rb

@@ -32,9 +32,15 @@ module ROM
       # @see Relation.schema
       #
       # @api public
-      def attribute(name, type)
+      def attribute(name, type, options = EMPTY_HASH)
         @attributes ||= {}
-        @attributes[name] = type.meta(name: name, source: relation)
+
+        @attributes[name] =
+          if options[:read]
+            type.meta(name: name, source: relation, read: options[:read])
+          else
+            type.meta(name: name, source: relation)
+          end
       end
 
       # Specify which key(s) should be the primary key

data/lib/rom/schema/type.rb

@@ -13,6 +13,20 @@ module ROM
         @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)

data/lib/rom/version.rb

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

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

@@ -8,26 +8,36 @@ RSpec.describe ROM::Command, 'before/after hooks' do
   describe '#before' do
     subject(:command) do
       Class.new(ROM::Command) do
+        before :init
+
+        def init(*)
+        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 include(:prepare)
+      expect(command.before(:prepare).before_hooks).to eql(%i[init prepare])
     end
   end
 
   describe '#after' do
     subject(:command) do
       Class.new(ROM::Command) do
+        after :finalize
+
+        def finalize(*)
+        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 include(:prepare)
+      expect(command.after(:prepare).after_hooks).to eql(%i[finalize prepare])
     end
   end
 

data/spec/unit/rom/commands_spec.rb

@@ -168,4 +168,21 @@ RSpec.describe 'Commands' do
       expect(command.call('foo')).to be(ROM::EMPTY_ARRAY)
     end
   end
+
+  describe '#with_opts' do
+    subject(:command) do
+      Class.new(ROM::Command::Create).build(relation, options)
+    end
+
+    let(:relation) { double(:relation) }
+    let(:options) { { result: :one } }
+
+    it 'returns a new command with updated options' do
+      new_command = command.with_opts(before: :test)
+
+      expect(new_command.relation).to be(relation)
+      expect(new_command.result).to be(:one)
+      expect(new_command.before_hooks).to eql([:test])
+    end
+  end
 end

data/spec/unit/rom/plugins/command/schema_spec.rb

@@ -38,17 +38,17 @@ RSpec.describe ROM::Plugins::Command::Schema do
 
     context 'when relation has a schema' do
       let(:relation) do
-        instance_double(ROM::Relation, schema?: true, schema_hash: schema_hash)
+        instance_double(ROM::Relation, schema?: true, input_schema: input_schema)
       end
 
-      let(:schema_hash) do
-        double(:schema_hash)
+      let(:input_schema) do
+        double(:input_schema)
       end
 
       it 'sets schema hash as input handler' do
         command = Class.new(command_class).build(relation)
 
-        expect(command.input).to be(schema_hash)
+        expect(command.input).to be(input_schema)
       end
 
       it 'sets a composed input handler with schema hash and a custom one' do
@@ -57,7 +57,7 @@ RSpec.describe ROM::Plugins::Command::Schema do
         command = Class.new(command_class) { input my_handler }.build(relation)
 
         expect(my_handler).to receive(:[]).with('some value').and_return('my handler')
-        expect(schema_hash).to receive(:[]).with('my handler').and_return('a tuple')
+        expect(input_schema).to receive(:[]).with('my handler').and_return('a tuple')
 
         expect(command.input['some value']).to eql('a tuple')
       end

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

@@ -0,0 +1,51 @@
+require 'rom/relation'
+
+RSpec.describe ROM::Relation, '#call' do
+  subject(:relation) do
+    relation_class.new(data)
+  end
+
+  context 'without read types in schema' do
+    let(:relation_class) do
+      Class.new(ROM::Relation[:memory]) do
+        schema do
+          attribute :id, ROM::Types::Int
+          attribute :name, ROM::Types::String
+        end
+      end
+    end
+
+    let(:data) do
+      [{ id: '1', name: 'Jane' }, { id: '2', name: 'John'} ]
+    end
+
+    it 'has noop output_schema' do
+      expect(relation.output_schema).to be(ROM::Relation::NOOP_OUTPUT_SCHEMA)
+    end
+
+    it 'returns loaded relation with data' do
+      expect(relation.call.collection).
+        to eql(data)
+    end
+  end
+
+  context 'with read types in schema' do
+    let(:relation_class) do
+      Class.new(ROM::Relation[:memory]) do
+        schema do
+          attribute :id, ROM::Types::String, read: ROM::Types::Coercible::Int
+          attribute :name, ROM::Types::String
+        end
+      end
+    end
+
+    let(:data) do
+      [{ id: '1', name: 'Jane' }, { id: '2', name: 'John'} ]
+    end
+
+    it 'returns loaded relation with coerced data' do
+      expect(relation.call.collection).
+        to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'John'} ])
+    end
+  end
+end

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

@@ -29,6 +29,26 @@ RSpec.describe ROM::Relation, '.schema' do
     expect(Test::Users.schema).to eql(schema)
   end
 
+  it 'allows defining types for reading tuples' do
+    module Test
+      module Types
+        CoercibleDate = ROM::Types::Date.constructor(Date.method(:parse))
+      end
+    end
+
+    class Test::Users < ROM::Relation[:memory]
+      schema do
+        attribute :id, Types::Int
+        attribute :date, Types::Coercible::String, read: Test::Types::CoercibleDate
+      end
+    end
+
+    schema = Test::Users.schema
+
+    expect(schema.to_output_hash).
+      to eql(ROM::Types::Coercible::Hash.schema(id: schema[:id].type, date: schema[:date].meta[:read]))
+  end
+
   it 'allows setting composite primary key' do
     class Test::Users < ROM::Relation[:memory]
       schema do

data/spec/unit/rom/relation_spec.rb

@@ -232,13 +232,13 @@ RSpec.describe ROM::Relation do
     end
   end
 
-  describe '#schema_hash' do
+  describe '#input_schema' do
     it 'returns a schema hash type' do
       relation = Class.new(ROM::Relation[:memory]) do
         schema { attribute :id, ROM::Types::Coercible::Int }
       end.new([])
 
-      expect(relation.schema_hash[id: '1']).to eql(id: 1)
+      expect(relation.input_schema[id: '1']).to eql(id: 1)
     end
 
     it 'returns a plain Hash coercer when there is no schema' do
@@ -246,7 +246,7 @@ RSpec.describe ROM::Relation do
 
       tuple = [[:id, '1']]
 
-      expect(relation.schema_hash[tuple]).to eql(id: '1')
+      expect(relation.input_schema[tuple]).to eql(id: '1')
     end
   end
 end

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

@@ -0,0 +1,17 @@
+require 'rom/schema'
+
+RSpec.describe ROM::Schema, '#append' do
+  subject(:schema) { left.append(*right) }
+
+  let(:left) do
+    define_schema(:users, id: :Int, name: :String)
+  end
+
+  let(:right) do
+    define_schema(:tasks, user_id: :Int)
+  end
+
+  it 'returns a new schema with attributes from two schemas' do
+    expect(schema.map(&:name)).to eql(%i[id name user_id])
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'rom/schema'
+
+RSpec.describe ROM::Schema, '#uniq' do
+  subject(:schema) { left.merge(right) }
+
+  let(:left) do
+    define_schema(:users, id: :Int, name: :String)
+  end
+
+  let(:right) do
+    define_schema(:tasks, id: :Int, user_id: :Int)
+  end
+
+  it 'returns a new schema with unique attributes from two schemas' do
+    expect(schema.uniq.map(&:name)).to eql(%i[id name user_id])
+  end
+
+  it 'accepts a block' do
+    expect(schema.uniq(&:primitive).map(&:name)).to eql(%i[id name])
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom
 version: !ruby/object:Gem::Version
-  version: 3.0.0.beta2
+  version: 3.0.0.beta3
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-12 00:00:00.000000000 Z
+date: 2017-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -345,6 +345,7 @@ files:
 - spec/unit/rom/plugins/relation/key_inference_spec.rb
 - spec/unit/rom/registry_spec.rb
 - spec/unit/rom/relation/attribute_reader_spec.rb
+- spec/unit/rom/relation/call_spec.rb
 - spec/unit/rom/relation/composite_spec.rb
 - spec/unit/rom/relation/curried_spec.rb
 - spec/unit/rom/relation/graph_spec.rb
@@ -356,6 +357,7 @@ files:
 - spec/unit/rom/relation/view_spec.rb
 - spec/unit/rom/relation_spec.rb
 - spec/unit/rom/schema/accessing_attributes_spec.rb
+- spec/unit/rom/schema/append_spec.rb
 - spec/unit/rom/schema/exclude_spec.rb
 - spec/unit/rom/schema/finalize_spec.rb
 - spec/unit/rom/schema/key_predicate_spec.rb
@@ -364,6 +366,7 @@ files:
 - spec/unit/rom/schema/project_spec.rb
 - spec/unit/rom/schema/rename_spec.rb
 - spec/unit/rom/schema/type_spec.rb
+- spec/unit/rom/schema/uniq_spec.rb
 - spec/unit/rom/schema/wrap_spec.rb
 - spec/unit/rom/schema_spec.rb
 - spec/unit/rom/setup/auto_registration_spec.rb