rom 2.0.2 → 3.0.0

data/spec/unit/rom/container_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Container do
+RSpec.describe ROM::Container do
   include_context 'container'
   include_context 'users and tasks'
 
@@ -8,16 +8,22 @@ describe ROM::Container do
     configuration
 
     users = Class.new(ROM::Relation[:memory]) do
-      register_as :users
-      dataset :users
+      schema(:users) do
+        attribute :name, ROM::Types::String
+        attribute :email, ROM::Types::String
+      end
+
       def by_name(name)
         restrict(name: name).project(:name)
       end
     end
 
     tasks = Class.new(ROM::Relation[:memory]) do
-      register_as :tasks
-      dataset :tasks
+      schema(:tasks) do
+        attribute :name, ROM::Types::String
+        attribute :title, ROM::Types::String
+        attribute :priority, ROM::Types::Int
+      end
     end
 
     create_user = Class.new(ROM::Commands::Create[:memory]) do
@@ -83,6 +89,10 @@ describe ROM::Container do
       expect(container.relation(:tasks)).to be_kind_of(ROM::Relation)
       expect(container.relation(:tasks).mappers.elements).to be_empty
     end
+
+    it 'returns a relation with finalized schema' do
+      expect(container.relation(:tasks).schema.relations[:users]).to be(container.relations[:users])
+    end
   end
 
   describe '#mappers' do

data/spec/unit/rom/create_container_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::CreateContainer do
+RSpec.describe ROM::CreateContainer do
   describe '#finalize' do
     include_context 'container'
 

data/spec/unit/rom/enumerable_dataset_spec.rb

@@ -0,0 +1,15 @@
+require 'rom/enumerable_dataset'
+
+RSpec.describe ROM::EnumerableDataset do
+  let(:klass) do
+    Class.new do
+      include ROM::EnumerableDataset
+
+      def self.row_proc
+        -> i { i.each_with_object({}) { |(k,v),h| h[k.to_sym] = v } }
+      end
+    end
+  end
+
+  it_behaves_like 'an enumerable dataset'
+end

data/spec/unit/rom/gateway_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Gateway do
+RSpec.describe ROM::Gateway do
 
   subject(:gateway) { Class.new(ROM::Gateway).new }
 

data/spec/unit/rom/mapper_registry_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::MapperRegistry do
+RSpec.describe ROM::MapperRegistry do
   subject(:registry) { ROM::MapperRegistry.new }
 
   let(:user_mapper) { double('user_mapper') }

data/spec/unit/rom/memory/commands_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'rom/memory'
 
-describe ROM::Memory::Commands do
+RSpec.describe ROM::Memory::Commands do
   let(:relation) do
     Class.new(ROM::Relation[:memory]) do
       schema do

data/spec/unit/rom/memory/dataset_spec.rb

@@ -3,7 +3,7 @@ require 'rom/lint/spec'
 
 require 'rom/memory/dataset'
 
-describe ROM::Memory::Dataset do
+RSpec.describe ROM::Memory::Dataset do
   subject(:dataset) { ROM::Memory::Dataset.new(data) }
 
   let(:data) do

data/spec/unit/rom/memory/{repository_spec.rb → gateway_spec.rb}

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'rom/lint/spec'
 require 'rom/memory'
 
-describe ROM::Memory::Gateway do
+RSpec.describe ROM::Memory::Gateway do
   let(:gateway) { ROM::Memory::Gateway }
   let(:uri) { nil }
 

data/spec/unit/rom/memory/inheritance_spec.rb

@@ -0,0 +1,32 @@
+require 'rom/memory'
+
+RSpec.describe ROM::Memory::Relation, '.inherited' do
+  subject(:relation) do
+    Class.new(ROM::Relation[:test]) do
+      schema(:users) do
+        attribute :name, ROM::Types::String
+      end
+    end.new([])
+  end
+
+  before do
+    module Test
+      module AnotherAdapter
+        class Relation < ROM::Memory::Relation
+          adapter :test
+        end
+      end
+    end
+
+    ROM.register_adapter(:test, Test::AnotherAdapter)
+  end
+
+  after do
+    ROM.adapters.delete(:test)
+  end
+
+  it 'extends subclass with core methods' do
+    expect(relation.name.to_sym).to be(:users)
+    expect(relation.schema.map(&:name)).to eql(%i[name])
+  end
+end

data/spec/unit/rom/memory/relation_spec.rb

@@ -4,8 +4,16 @@ require 'rom/lint/spec'
 require 'rom/memory/dataset'
 require 'rom/memory/relation'
 
-describe ROM::Memory::Relation do
-  subject(:relation) { ROM::Memory::Relation.new(dataset) }
+RSpec.describe ROM::Memory::Relation do
+  subject(:relation) do
+    Class.new(ROM::Memory::Relation) do
+      schema do
+        attribute :name, ROM::Types::String
+        attribute :email, ROM::Types::String
+        attribute :age, ROM::Types::Int
+      end
+    end.new(dataset) 
+  end
 
   let(:dataset) do
     ROM::Memory::Dataset.new([
@@ -30,7 +38,11 @@ describe ROM::Memory::Relation do
 
   describe '#project' do
     it 'projects tuples with the provided keys' do
-      expect(relation.project(:name, :age)).to match_array([
+      projected = relation.project(:name, :age)
+
+      expect(projected.schema).to eql(relation.schema.project(:name, :age))
+
+      expect(projected).to match_array([
         { name: 'Jane', age: 10 },
         { name: 'Jade', age: 11 },
         { name: 'Joe',  age: 12 },

data/spec/unit/rom/memory/storage_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'rom/memory/storage'
 
-describe ROM::Memory::Storage do
+RSpec.describe ROM::Memory::Storage do
   describe 'thread safe' do
     let(:threads) { 4 }
     let(:operations) { 5000 }

data/spec/unit/rom/plugin_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "ROM::PluginRegistry" do
+RSpec.describe "ROM::PluginRegistry" do
   include_context 'container'
 
   before do

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/plugins/relation/key_inference_spec.rb

@@ -58,7 +58,7 @@ RSpec.describe ROM::Plugins::Relation::KeyInference do
         use :key_inference
 
         schema :posts do
-          attribute :author_id, ROM::Types::Int.meta(foreign_key: true, relation: :users)
+          attribute :author_id, ROM::Types::Int.meta(foreign_key: true, target: :users)
         end
       end
     end

data/spec/unit/rom/registry_spec.rb

@@ -0,0 +1,86 @@
+require 'rom/registry'
+
+RSpec.shared_examples_for 'registry fetch' do
+  it 'raises an ArgumentError when nil is used as a key' do
+    expect {
+      registry.public_send(fetch_method, nil)
+    }.to raise_error(ArgumentError, "key cannot be nil")
+  end
+
+  it 'returns registered element identified by name' do
+    expect(registry.public_send(fetch_method, :mars)).to be(mars)
+  end
+
+  it 'raises error when element is not found' do
+    expect { registry.public_send(fetch_method, :twix) }.to raise_error(
+      ROM::Registry::ElementNotFoundError,
+      ":twix doesn't exist in Candy registry"
+    )
+  end
+
+  it 'returns the value from an optional block when key is not found' do
+    value = registry.public_send(fetch_method, :candy) { :twix }
+
+    expect(value).to eq(:twix)
+  end
+
+  it 'calls #to_sym on a key before fetching' do
+    expect(registry.public_send(fetch_method, double(to_sym: :mars))).to be(mars)
+  end
+end
+
+RSpec.describe ROM::Registry do
+  subject(:registry) { registry_class.new(mars: mars) }
+
+  let(:mars) { double('mars') }
+
+  let(:registry_class) do
+    Class.new(ROM::Registry) do
+      def self.name
+        'Candy'
+      end
+    end
+  end
+
+  describe '#fetch' do
+    let(:fetch_method) { :fetch }
+
+    it_behaves_like 'registry fetch'
+  end
+
+  describe '#[]' do
+    let(:fetch_method) { :[] }
+
+    it_behaves_like 'registry fetch'
+  end
+
+  describe '#method_missing' do
+    it 'returns registered element identified by name' do
+      expect(registry.mars).to be(mars)
+    end
+
+    it 'raises no-method error when element is not there' do
+      expect { registry.twix }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#key?' do
+    let(:mars) { double(to_sym: :mars) }
+
+    it 'calls #to_sym on a key before checking if it exists' do
+      registry.key?(:mars)
+    end
+
+    it 'returns true for an existing key' do
+      expect(registry.key?(:mars)).to be(true)
+    end
+
+    it 'returns false for a non-existing key' do
+      expect(registry.key?(:twix)).to be(false)
+    end
+
+    it 'returns false for a nil key' do
+      expect(registry.key?(nil)).to be(false)
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'rom/memory'
+
+RSpec.describe ROM::Relation, '#[]' do
+  it 'defines a canonical schema for a relation' do
+    class Test::Users < ROM::Relation[:memory]
+      schema do
+        attribute :id, Types::Int
+        attribute :name, Types::String
+      end
+    end
+
+    relation = Test::Users.new([])
+
+    expect(relation[:id]).to be(Test::Users.schema[:id])
+    expect(relation[:name]).to be(Test::Users.schema[:name])
+  end
+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/composite_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Relation::Composite do
+RSpec.describe ROM::Relation::Composite do
   include_context 'gateway only'
   include_context 'users and tasks'
 

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Relation::Graph do
+RSpec.describe ROM::Relation::Graph do
   include_context 'gateway only'
   include_context 'users and tasks'
 

data/spec/unit/rom/relation/lazy/combine_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Relation, '#combine' do
+RSpec.describe ROM::Relation, '#combine' do
   include_context 'gateway only'
   include_context 'users and tasks'
 

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Relation do
+RSpec.describe ROM::Relation do
   include_context 'gateway only'
   include_context 'users and tasks'
 

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Relation::Loaded do
+RSpec.describe ROM::Relation::Loaded do
   include_context 'no container'
   include_context 'users and tasks'
 

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'rom/memory'
 
-describe ROM::Relation, '.schema' do
+RSpec.describe ROM::Relation, '.schema' do
   it 'defines a canonical schema for a relation' do
     class Test::Users < ROM::Relation[:memory]
       schema do
@@ -13,16 +13,42 @@ describe ROM::Relation, '.schema' do
 
     Test::Users.schema.finalize!
 
-    schema = ROM::Schema.new(
+    relation_name = ROM::Relation::Name[:test_users]
+
+    schema = ROM::Memory::Schema.define(
       ROM::Relation::Name.new(:test_users),
-      id: ROM::Memory::Types::Int.meta(primary_key: true, name: :id),
-      name: ROM::Memory::Types::String.meta(name: :name),
-      admin: ROM::Memory::Types::Bool.meta(name: :admin)
+      attributes: [
+        ROM::Memory::Types::Int.meta(primary_key: true, name: :id, source: relation_name),
+        ROM::Memory::Types::String.meta(name: :name, source: relation_name),
+        ROM::Memory::Types::Bool.meta(name: :admin, source: relation_name)
+      ]
     ).finalize!
 
     expect(Test::Users.schema.primary_key).to eql([Test::Users.schema[:id]])
 
     expect(Test::Users.schema).to eql(schema)
+
+    expect(Test::Users.schema.relations).to be_empty
+  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
@@ -81,6 +107,24 @@ describe ROM::Relation, '.schema' do
     expect(Test::Users.register_as).to be(:test_users)
   end
 
+  it 'allows setting both dataset and relation alias' do
+    class Test::Users < ROM::Relation[:memory]
+      schema(:test_users, as: :users) { }
+    end
+
+    expect(Test::Users.register_as).to be(:users)
+    expect(Test::Users.dataset).to be(:test_users)
+  end
+
+  it 'raises error when schema_class is missing' do
+    class Test::Users < ROM::Relation[:memory]
+      schema_class nil
+    end
+
+    expect { Test::Users.schema(:test) { } }.
+      to raise_error(ROM::MissingSchemaClassError, "Test::Users relation is missing schema_class")
+  end
+
   describe '#schema' do
     it 'returns defined schema' do
       class Test::Users < ROM::Relation[:memory]
@@ -111,7 +155,7 @@ describe ROM::Relation, '.schema' do
         end
       end
 
-      expect(Test::Users.schema[:admin]).to eql(ROM::Types::Bool.meta(name: :admin))
+      expect(Test::Users.schema[:admin]).to eql(ROM::Types::Bool.meta(name: :admin, source: ROM::Relation::Name[:test_users]))
     end
   end
 end

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

@@ -0,0 +1,122 @@
+require 'rom'
+require 'rom/memory'
+
+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' }
+      relation << { id: 2, name: 'Jane' }
+    end
+
+    it 'uses projected schema for view schema' do
+      expect(relation.schemas[:names].map(&:name)).to eql(%i[name])
+    end
+
+    it 'auto-projects the relation via schema' do
+      new_rel = relation_class.new([{ name: 'Jane' }, { name: 'Joe' }])
+      names_schema = relation_class.schemas[:names]
+
+      expect(names_schema).to receive(:call).with(relation).and_return(new_rel)
+      expect(relation.names).to eql(new_rel)
+    end
+
+    it 'auto-projects a restricted relation via schema' do
+      new_rel = relation_class.new([{ id: 2 }])
+      ids_schema = relation_class.schemas[:ids_for_names]
+
+      expect(ids_schema).to receive(:call).with(relation.restrict(name: ['Jane'])).and_return(new_rel)
+      expect(relation.ids_for_names(['Jane'])).to eql(new_rel)
+    end
+  end
+
+  context 'with an explicit schema' do
+    before do
+      # this is normally called automatically during setup
+      relation_class.finalize({}, relation)
+    end
+
+    include_context 'relation with views' do
+      let(:relation_class) do
+        Class.new(ROM::Memory::Relation) do
+          schema(:users) do
+            attribute :id, ROM::Types::Int
+            attribute :name, ROM::Types::String
+          end
+
+          view(:names) do
+            schema do
+              project(:name)
+            end
+
+            relation do
+              self
+            end
+          end
+
+          view(:ids_for_names) do
+            schema do
+              project(:id)
+            end
+
+            relation do |names|
+              restrict(name: names)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'with an inferred schema' do
+    before do
+      # this is normally called automatically during setup
+      relation_class.schema.finalize!
+      relation_class.finalize({}, relation)
+    end
+
+    include_context 'relation with views' do
+      let(:relation_class) do
+        Class.new(ROM::Memory::Relation) do
+          schema_inferrer -> dataset, gateway {
+            [[ROM::Types::Int.meta(name: :id, source: :users),
+             ROM::Types::String.meta(name: :name, source: :users)], []]
+          }
+
+          schema(:users, infer: true)
+
+          view(:names) do
+            schema do
+              project(:name)
+            end
+
+            relation do
+              self
+            end
+          end
+
+          view(:ids_for_names) do
+            schema do
+              project(:id)
+            end
+
+            relation do |names|
+              restrict(name: names)
+            end
+          end
+        end
+      end
+    end
+  end
+end