rom 2.0.2 → 3.0.0.beta1

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/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,11 +13,15 @@ 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]])
@@ -111,7 +115,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,112 @@
+require 'rom'
+require 'rom/memory'
+
+RSpec.describe ROM::Relation do
+  subject(:relation) { relation_class.new(ROM::Memory::Dataset.new([])) }
+
+  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

data/spec/unit/rom/relation_spec.rb

@@ -1,6 +1,6 @@
 require 'rom/memory'
 
-describe ROM::Relation do
+RSpec.describe ROM::Relation do
   subject(:relation) { Class.new(ROM::Relation).new(dataset) }
 
   let(:dataset) { ROM::Memory::Dataset.new([jane, joe]) }
@@ -196,7 +196,7 @@ describe ROM::Relation do
 
   describe "#with" do
     it "returns a new instance with the original dataset and given custom options" do
-      relation = Class.new(ROM::Relation) { option :custom }.new([])
+      relation = Class.new(ROM::Relation) { option :custom }.new([], custom: true)
 
       custom_opts = { mappers: "Custom Mapper Registry" }
       new_relation = relation.with(custom_opts).with(custom: true)
@@ -217,6 +217,20 @@ describe ROM::Relation do
     end
   end
 
+  describe '#schema' do
+    it 'returns an empty schema by default' do
+      relation = Class.new(ROM::Relation[:memory]) {
+        def self.name
+          'SomeRelation'
+        end
+      }.new([])
+
+      expect(relation.schema).to be_empty
+      expect(relation.schema.name).to be(:some_relation)
+      expect(relation.schema?).to be(false)
+    end
+  end
+
   describe '#schema_hash' do
     it 'returns a schema hash type' do
       relation = Class.new(ROM::Relation[:memory]) do

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

@@ -0,0 +1,52 @@
+require 'rom/schema'
+
+RSpec.describe ROM::Schema, '#[]' do
+  context 'with a schema' do
+    subject(:schema) do
+      define_schema(:users, id: :Int, name: :String, email: :String)
+    end
+
+    it 'returns an attribute identified by its canonical name' do
+      expect(schema[:email]).to eql(define_type(:email, :String, source: :users))
+    end
+
+    it 'returns an aliased attribute identified by its canonical name' do
+      expect(schema.rename(id: :user_id)[:id]).to eql(define_type(:id, :Int, source: :users, alias: :user_id))
+    end
+
+    it 'raises KeyError when attribute is not found' do
+      expect { schema[:not_here] }.to raise_error(KeyError, /not_here/)
+    end
+  end
+
+  context 'with a merged schema' do
+    subject(:schema) do
+      left.merge(right.__send__(:new, right.map { |attr| attr.meta(source: :tasks) }))
+    end
+
+    let(:left) do
+      define_schema(:users, id: :Int, name: :String)
+    end
+
+    let(:right) do
+      define_schema(:tasks, id: :Int, title: :String)
+    end
+
+    it 'returns an attribute identified by its canonical name' do
+      expect(schema[:id]).to eql(define_type(:id, :Int, source: :users))
+    end
+
+    it 'returns an attribute identified by its canonical name when its unique' do
+      expect(schema[:title]).to eql(define_type(:title, :String, source: :tasks))
+    end
+
+    it 'returns an attribute identified by its canonical name and its source' do
+      expect(schema[:id, :tasks]).to eql(define_type(:id, :Int, source: :tasks))
+    end
+
+    it 'raises KeyError when attribute is not found' do
+      expect { schema[:not_here] }.to raise_error(KeyError, /not_here/)
+      expect { schema[:not_here, :tasks] }.to raise_error(KeyError, /not_here/)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'rom/schema'
+
+RSpec.describe ROM::Schema, '#exclude' do
+  subject(:schema) do
+    define_schema(:users, id: :Int, name: :String, email: :String)
+  end
+
+  let(:excluded) do
+    schema.exclude(:id, :name)
+  end
+
+  it 'returns projected schema with renamed attributes using provided prefix' do
+    expect(excluded.map(&:name)).to eql(%i[email])
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'rom/schema'
+
+RSpec.describe ROM::Schema, '#finalize!' do
+  context 'without inferrer' do
+    subject(:schema) do
+      define_schema(:users, id: :Int, name: :String)
+    end
+
+    before { schema.finalize! }
+
+    it 'returns a frozen canonical schema' do
+      expect(schema).to be_frozen
+    end
+  end
+
+  context 'with inferrer' do
+    subject(:schema) do
+      ROM::Schema.define(:users, attributes: attributes, inferrer: inferrer)
+    end
+
+    let(:inferrer) do
+      proc { [[define_type(:name, :String)], [:id, :age]]}
+    end
+
+    context 'when all required attributes are present' do
+      let(:attributes) do
+        [define_type(:id, :Int), define_type(:age, :Int)]
+      end
+
+      it 'concats defined attributes with inferred attributes' do
+        expect(schema.finalize!.map(&:name)).to eql(%i[id age name])
+      end
+    end
+
+    context 'when inferred attributes are overridden' do
+      let(:attributes) do
+        [define_type(:id, :Int),
+         define_type(:age, :Int),
+         define_type(:name, :String).meta(custom: true)]
+      end
+
+      it 'respects overridden attributes' do
+        expect(schema.finalize!.map(&:name)).to eql(%i[id age name])
+        expect(schema[:name].meta[:custom]).to be(true)
+      end
+    end
+
+    context 'when some attributes are missing' do
+      let(:attributes) do
+        []
+      end
+
+      it 'raises error' do
+        expect { schema.finalize! }.
+          to raise_error(ROM::Schema::MissingAttributesError, /missing attributes in :users schema: :id, :age/)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'rom/schema'
+
+RSpec.describe ROM::Schema, '#key?' do
+  subject(:schema) do
+    define_schema(:users, name: :String)
+  end
+
+  it 'returns true when an attribute exists' do
+    expect(schema.key?(:name)).to be(true)
+  end
+
+  it 'returns false when an attribute does not exist' do
+    expect(schema.key?(:foo)).to be(false)
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'rom/schema'
+
+RSpec.describe ROM::Schema, '#merge' do
+  subject(:schema) { left.merge(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/prefix_spec.rb

@@ -0,0 +1,16 @@
+require 'rom/schema'
+
+RSpec.describe ROM::Schema, '#prefix' do
+  subject(:schema) do
+    define_schema(:users, id: :Int, name: :String)
+  end
+
+  let(:prefixed) do
+    schema.prefix(:user)
+  end
+
+  it 'returns projected schema with renamed attributes using provided prefix' do
+    expect(prefixed.map(&:alias)).to eql(%i[user_id user_name])
+    expect(prefixed.map { |attr| attr.meta[:name] }).to eql(%i[id name])
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'rom/schema'
+
+RSpec.describe ROM::Schema, '#project' do
+  subject(:schema) do
+    define_schema(:users, id: :Int, name: :String, age: :Int)
+  end
+
+  it 'projects provided attribute names' do
+    expect(schema.project(:name, :age).map(&:name)).to eql(%i[name age])
+  end
+
+  it 'projects provided attributes' do
+    expect(schema.project(schema[:name], schema[:age]).map(&:name)).to eql(%i[name age])
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'rom/schema'
+
+RSpec.describe ROM::Schema, '#rename' do
+  subject(:schema) do
+    define_schema(
+      :users,
+      user_id: :Int, user_name: :String, user_email: :String
+    )
+  end
+
+  let(:renamed) do
+    schema.rename(user_id: :id, user_name: :name)
+  end
+
+  it 'returns projected schema with renamed attributes' do
+    expect(renamed.map(&:name)).to eql(%i[user_id user_name user_email])
+    expect(renamed.map(&:alias)).to eql([:id, :name, nil])
+    expect(renamed.all?(&:aliased?)).to be(false)
+    expect(renamed[:user_id]).to be_aliased
+    expect(renamed[:user_name]).to be_aliased
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'rom/schema/type'
+
+RSpec.describe ROM::Schema::Type 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)
+      end
+
+      specify do
+        expect(type.inspect).to eql("#<ROM::Schema::Type[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)
+      end
+
+      specify do
+        expect(type.inspect).to eql("#<ROM::Schema::Type[TrueClass | FalseClass] name=:admin>")
+      end
+    end
+  end
+
+  describe '#aliased' do
+    subject(:type) do
+      ROM::Schema::Type.new(ROM::Types::String).meta(name: :user_name)
+    end
+
+    specify do
+      expect(type.as(:name).meta[:alias]).to eql(:name)
+    end
+  end
+
+  describe '#method_missing' do
+    subject(:type) do
+      ROM::Schema::Type.new(ROM::Types::Int).meta(name: :id, primary_key: true)
+    end
+
+    specify do
+      expect(type.meta).to eql(name: :id, primary_key: true)
+    end
+
+    specify do
+      expect { type.not_here }.to raise_error(NoMethodError, /not_here/)
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'rom/schema'
+
+RSpec.describe ROM::Schema, '#wrap' do
+  subject(:schema) do
+    define_schema(:users, id: :Int, name: :String)
+  end
+
+  let(:wrapped) do
+    schema.wrap(:users)
+  end
+
+  it 'returns projected schema with renamed attributes using provided prefix' do
+    expect(wrapped.map(&:alias)).to eql(%i[users_id users_name])
+    expect(wrapped.map { |attr| attr.meta[:name] }).to eql(%i[id name])
+    expect(wrapped.all?(&:wrapped?)).to be(true)
+  end
+end

data/spec/unit/rom/schema_spec.rb

@@ -1,8 +1,8 @@
 RSpec.describe ROM::Schema do
   describe '#to_h' do
     it 'returns hash with attributes' do
-      attrs = { id: ROM::Types::Int, name: ROM::Types::String }
-      schema = ROM::Schema.new(:name, attrs)
+      attrs = { id: ROM::Types::Int.meta(name: :id), name: ROM::Types::String.meta(name: :name) }
+      schema = ROM::Schema.define(:name, attributes: attrs.values)
 
       expect(schema.to_h).to eql(attrs)
     end