rom 2.0.2 → 4.2.1

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

@@ -1,214 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Relation do
-  include_context 'gateway only'
-  include_context 'users and tasks'
-
-  let(:users_relation) do
-    Class.new(ROM::Memory::Relation) do
-      def by_name(name)
-        restrict(name: name)
-      end
-
-      def by_name_sorted(name, order_by = :name)
-        by_name(name).order(order_by)
-      end
-
-      def by_email(email)
-        restrict(name: email)
-      end
-
-      def by_name_and_email(name, email)
-        by_name(name).by_email(email)
-      end
-
-      def by_name_and_email_sorted(name, email, order_by)
-        by_name_and_email(name, email).order(order_by)
-      end
-
-      def all(*args)
-        if args.any?
-          restrict(*args)
-        else
-          self
-        end
-      end
-    end.new(users_dataset)
-  end
-
-  let(:tasks_relation) do
-    Class.new(ROM::Memory::Relation) do
-      def for_users(users)
-        names = users.map { |u| u[:name] }
-        restrict { |t| names.include?(t[:name]) }
-      end
-    end.new(tasks_dataset)
-  end
-
-  it_behaves_like 'a relation that returns one tuple' do
-    let(:relation) { users_relation }
-  end
-
-  describe '#map_with' do
-    it 'raises error when unknown mapper was selected' do
-      expect {
-        users_relation.as(:not_here)
-      }.to raise_error(ROM::MapperMissingError, /not_here/)
-    end
-  end
-
-  describe '#method_missing' do
-    it 'forwards to relation and auto-curries' do
-      relation = users_relation.by_name_and_email_sorted('Jane')
-
-      expect(relation.name).to eql(ROM::Relation::Name[:by_name_and_email_sorted])
-      expect(relation.curry_args).to eql(['Jane'])
-
-      relation = relation['jane@doe.org']
-
-      expect(relation.name).to eql(ROM::Relation::Name[:by_name_and_email_sorted])
-      expect(relation.curry_args).to eql(['Jane', 'jane@doe.org'])
-
-      expect(relation[:email]).to match_array(
-        users_relation.by_name_and_email_sorted('Jane', 'jane@doe.org', :email)
-      )
-    end
-
-    it 'forwards to relation and does not auto-curry when it is not needed' do
-      relation = users_relation.by_name('Jane')
-
-      expect(relation).to_not be_curried
-      expect(relation).to match_array(users_relation.by_name('Jane'))
-    end
-
-    it 'forwards to relation and return lazy when arity is unknown' do
-      relation = users_relation.all(name: 'Jane')
-      expect(relation).to_not be_curried
-      expect(relation).to match_array(users_relation.by_name('Jane').to_a)
-    end
-
-    it 'returns original response if it is not a relation' do
-      expect(users_relation.gateway).to be(:default)
-    end
-
-    it 'raises NoMethodError when relation does not respond to a method' do
-      expect { users_relation.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-  end
-
-  describe '#call' do
-    it 'auto-curries' do
-      relation = users_relation.by_name
-
-      expect(relation.name).to eql(ROM::Relation::Name[:by_name])
-      expect(relation['Jane'].to_a).to eql(users_relation.by_name('Jane').to_a)
-    end
-
-    it 'returns relation' do
-      expect(users_relation.call.to_a).to eql(users_relation.to_a)
-    end
-
-    describe 'using mappers' do
-      subject(:users) { users_relation.with(mappers: mappers) }
-
-      let(:name_list) { proc { |r| r.map { |t| t[:name] } } }
-      let(:upcaser) { proc { |r| r.map(&:upcase) } }
-      let(:mappers) { { name_list: name_list, upcaser: upcaser } }
-
-      it 'sends relation through mappers' do
-        relation = users.map_with(:name_list, :upcaser).by_name('Jane')
-
-        expect(relation.call.to_a).to eql(['JANE'])
-      end
-    end
-  end
-
-  describe '#first' do
-    it 'return first tuple' do
-      expect(users_relation.first).to eql(name: 'Joe', email: 'joe@doe.org')
-    end
-
-    it 'raises when relation is curried and arity does not match' do
-      expect { users_relation.by_name.first }.to raise_error(
-        ArgumentError, "#{users_relation.class.to_s}#by_name arity is 1 (0 args given)"
-      )
-    end
-
-    it 'does not raise when relation is curried and arity matches' do
-      expect { users_relation.by_name_sorted('Joe').first }.to_not raise_error
-    end
-  end
-
-  describe '#each' do
-    it 'yields relation tuples' do
-      result = []
-      users_relation.each do |tuple|
-        result << tuple
-      end
-      expect(result).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-
-    it 'returns an enumerator if block is not provided' do
-      expect(users_relation.each.to_a).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-
-    it 'raises when relation is curried and arity does not match' do
-      expect { users_relation.by_name.each {} }.to raise_error(
-        ArgumentError, "#{users_relation.class.to_s}#by_name arity is 1 (0 args given)"
-      )
-    end
-
-    it 'does not raise when relation is curried and arity matches' do
-      expect { users_relation.by_name_sorted('Jane').first }.to_not raise_error
-    end
-  end
-
-  describe '#to_ary' do
-    it 'returns an array with relation tuples' do
-      expect(users_relation.to_ary).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-
-    it 'raises when relation is curried and arity does not match' do
-      expect { users_relation.by_name.to_ary }.to raise_error(
-        ArgumentError, "#{users_relation.class.to_s}#by_name arity is 1 (0 args given)"
-      )
-    end
-
-    it 'does not raise when relation is curried and arity matches' do
-      expect { users_relation.by_name_sorted('Jane').first }.to_not raise_error
-    end
-  end
-
-  describe '#>>' do
-    it 'composes two relations' do
-      other = users_relation.by_name('Jane') >> tasks_relation.for_users
-
-      expect(other).to match_array([
-        { name: 'Jane', title: 'be cool', priority: 2 }
-      ])
-    end
-
-    it_behaves_like 'a relation that returns one tuple' do
-      let(:relation) { users_relation >> proc { |r| r } }
-
-      describe 'using a mapper' do
-        it 'returns one mapped tuple' do
-          mapper = proc { |r| r.map { |t| t[:name].upcase } }
-          relation = users_relation.by_name('Jane') >> mapper
-
-          expect(relation.one).to eql('JANE')
-          expect(relation.one!).to eql('JANE')
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Relation::Loaded do
-  include_context 'no container'
-  include_context 'users and tasks'
-
-  subject(:users) { ROM::Relation::Loaded.new(users_relation) }
-
-  describe '#each' do
-    it 'yields tuples from relation' do
-      result = []
-
-      users.each do |tuple|
-        result << tuple
-      end
-
-      expect(result).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-
-    it 'returns enumerator when block is not provided' do
-      expect(users.each.to_a).to eql(users.collection.to_a)
-    end
-  end
-
-  describe '#to_ary' do
-    it 'coerces to an array' do
-      expect(users.to_ary).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-  end
-
-  describe '#pluck' do
-    it 'returns a list of values under provided key' do
-      expect(users.pluck(:email)).to eql(%w(joe@doe.org jane@doe.org))
-    end
-  end
-
-  describe '#primary_keys' do
-    it 'returns a list of primary key values' do
-      expect(users.source).to receive(:primary_key).and_return(:name)
-      expect(users.primary_keys).to eql(%w(Joe Jane))
-    end
-  end
-
-  it_behaves_like 'a relation that returns one tuple' do
-    let(:relation) { users }
-  end
-end

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

@@ -1,58 +0,0 @@
-require 'rom/relation/name'
-
-RSpec.describe ROM::Relation::Name do
-  describe '.[]' do
-    it 'returns a new name from args' do
-      expect(ROM::Relation::Name[:users]).to eql(
-        ROM::Relation::Name.new(:users)
-      )
-
-      expect(ROM::Relation::Name[:authors, :users]).to eql(
-        ROM::Relation::Name.new(:authors, :users)
-      )
-    end
-
-    it 'returns name object when it was passed in as arg' do
-      name = ROM::Relation::Name[:users]
-      expect(ROM::Relation::Name[name]).to be(name)
-    end
-
-    it 'caches name instances' do
-      name = ROM::Relation::Name[:users]
-      expect(ROM::Relation::Name[:users]).to be(name)
-    end
-  end
-
-  describe '#inspect' do
-    it 'provides relation name' do
-      name = ROM::Relation::Name.new(:users)
-      expect(name.inspect).to eql("ROM::Relation::Name(users)")
-    end
-
-    it 'provides dataset and relation names' do
-      name = ROM::Relation::Name.new(:authors, :users)
-      expect(name.inspect).to eql("ROM::Relation::Name(authors on users)")
-    end
-  end
-
-  describe '#with' do
-    it 'returns a new name with the same dataset but for a different relation name' do
-      name = ROM::Relation::Name[:users]
-      expect(name.with(:people)).to be(ROM::Relation::Name[:people, :users])
-    end
-  end
-
-  describe '#to_sym' do
-    it 'returns relation name' do
-      expect(ROM::Relation::Name.new(:users).to_sym).to be(:users)
-      expect(ROM::Relation::Name.new(:authors, :users).to_sym).to be(:authors)
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns stringified relation name' do
-      expect(ROM::Relation::Name.new(:users).to_s).to eql('users')
-      expect(ROM::Relation::Name.new(:authors, :users).to_s).to eql('authors on users')
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-describe ROM::Relation, '.schema' do
-  it 'defines a canonical schema for a relation' do
-    class Test::Users < ROM::Relation[:memory]
-      schema do
-        attribute :id, Types::Int.meta(primary_key: true)
-        attribute :name, Types::String
-        attribute :admin, Types::Bool
-      end
-    end
-
-    Test::Users.schema.finalize!
-
-    schema = ROM::Schema.new(
-      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)
-    ).finalize!
-
-    expect(Test::Users.schema.primary_key).to eql([Test::Users.schema[:id]])
-
-    expect(Test::Users.schema).to eql(schema)
-  end
-
-  it 'allows setting composite primary key' do
-    class Test::Users < ROM::Relation[:memory]
-      schema do
-        attribute :name, Types::String
-        attribute :email, Types::String
-
-        primary_key :name, :email
-      end
-    end
-
-    schema = Test::Users.schema.finalize!
-
-    expect(schema.primary_key).to eql([schema[:name], schema[:email]])
-  end
-
-  it 'allows setting foreign keys' do
-    class Test::Posts < ROM::Relation[:memory]
-      schema do
-        attribute :author_id, Types::ForeignKey(:users)
-        attribute :title, Types::String
-      end
-    end
-
-    schema = Test::Posts.schema
-
-    expect(schema[:author_id].primitive).to be(Integer)
-
-    expect(schema.foreign_key(:users)).to be(schema[:author_id])
-  end
-
-  it 'sets register_as and dataset' do
-    class Test::Users < ROM::Relation[:memory]
-      schema(:users) do
-        attribute :id, Types::Int
-        attribute :name, Types::String
-      end
-    end
-
-    expect(Test::Users.dataset).to be(:users)
-    expect(Test::Users.register_as).to be(:users)
-  end
-
-  it 'sets dataset and respects custom register_as' do
-    class Test::Users < ROM::Relation[:memory]
-      register_as :test_users
-
-      schema(:users) do
-        attribute :id, Types::Int
-        attribute :name, Types::String
-      end
-    end
-
-    expect(Test::Users.dataset).to be(:users)
-    expect(Test::Users.register_as).to be(:test_users)
-  end
-
-  describe '#schema' do
-    it 'returns defined schema' do
-      class Test::Users < ROM::Relation[:memory]
-        schema do
-          attribute :id, Types::Int.meta(primary_key: true)
-          attribute :name, Types::String
-          attribute :admin, Types::Bool
-        end
-      end
-
-      users = Test::Users.new([])
-
-      expect(users.schema).to be(Test::Users.schema)
-    end
-
-    it 'uses custom schema dsl' do
-      class Test::SchemaDSL < ROM::Schema::DSL
-        def bool(name)
-          attribute(name, ::ROM::Types::Bool)
-        end
-      end
-
-      class Test::Users < ROM::Relation[:memory]
-        schema_dsl Test::SchemaDSL
-
-        schema do
-          bool :admin
-        end
-      end
-
-      expect(Test::Users.schema[:admin]).to eql(ROM::Types::Bool.meta(name: :admin))
-    end
-  end
-end

data/spec/unit/rom/relation_spec.rb

@@ -1,237 +0,0 @@
-require 'rom/memory'
-
-describe ROM::Relation do
-  subject(:relation) { Class.new(ROM::Relation).new(dataset) }
-
-  let(:dataset) { ROM::Memory::Dataset.new([jane, joe]) }
-
-  let(:jane) { { id: 1, name: 'Jane' } }
-  let(:joe) { { id: 2, name: 'Joe' } }
-
-  describe '.[]' do
-    before do
-      module Test::TestAdapter
-        class Relation < ROM::Relation
-          adapter :test
-
-          def test_relation?
-            true
-          end
-        end
-      end
-
-      module Test::BrokenAdapter
-        class Relation < ROM::Relation
-          def test_relation?
-            true
-          end
-        end
-      end
-
-      ROM.register_adapter(:test, Test::TestAdapter)
-      ROM.register_adapter(:broken, Test::BrokenAdapter)
-    end
-
-    it 'returns relation subclass from the registered adapter' do
-      subclass = Class.new(ROM::Relation[:test])
-
-      relation = subclass.new([])
-
-      expect(relation).to be_test_relation
-    end
-
-    it 'raises error when adapter relation has no identifier' do
-      expect {
-        Class.new(ROM::Relation[:broken])
-      }.to raise_error(ROM::MissingAdapterIdentifierError, /Test::BrokenAdapter::Relation/)
-    end
-  end
-
-  describe ".dataset" do
-    it 'allows setting dataset name' do
-      rel_class = Class.new(ROM::Relation[:memory]) { dataset :users }
-
-      expect(rel_class.dataset).to be(:users)
-    end
-  end
-
-  describe ".register_as" do
-    it "defaults to dataset with a generated class" do
-      rel = Class.new(ROM::Relation[:memory]) { dataset :users }
-      expect(rel.register_as).to eq(:users)
-      rel.register_as(:guests)
-      expect(rel.register_as).to eq(:guests)
-    end
-
-    it "defaults to dataset with a defined class that has dataset inferred" do
-      class Test::Users < ROM::Relation[:memory]; end
-      expect(Test::Users.register_as).to eq(:test_users)
-    end
-
-    it "defaults to dataset with a defined class that has dataset set manually" do
-      class Test::Users < ROM::Relation[:memory]
-        dataset :guests
-      end
-      expect(Test::Users.register_as).to eq(:guests)
-    end
-
-    it "defaults to :dataset of parent class" do
-      class Test::SuperUsers < ROM::Relation[:memory]
-        dataset :users
-      end
-
-      class Test::DescendantUsers < Test::SuperUsers; end
-
-      expect(Test::DescendantUsers.register_as).to be(:users)
-    end
-
-    it "sets custom value for super and descendant classes" do
-      class Test::SuperUsers < ROM::Relation[:memory]
-        register_as :users
-      end
-
-      class Test::DescendantUsers < Test::SuperUsers
-        register_as :descendant_users
-      end
-
-      expect(Test::SuperUsers.register_as).to eq(:users)
-      expect(Test::DescendantUsers.register_as).to eq(:descendant_users)
-    end
-
-    it "sets provided value overriding inherited value" do
-      module Test
-        class BaseRelation < ROM::Relation[:memory]
-        end
-
-        class UsersRelation < BaseRelation
-          register_as :users
-          dataset :users
-        end
-      end
-
-      expect(Test::UsersRelation.register_as).to be(:users)
-    end
-  end
-
-  describe '#name' do
-    context 'missing dataset' do
-      context 'with Relation inside module' do
-        before do
-          module Test::Test
-            class SuperRelation < ROM::Relation[:memory]; end
-          end
-        end
-
-        it 'returns name based on module and class' do
-          relation = Test::Test::SuperRelation.new([])
-
-          expect(relation.name).to eql(ROM::Relation::Name.new(:test_test_super_relation))
-        end
-      end
-
-      context 'with Relation without module' do
-        before do
-          class Test::SuperRelation < ROM::Relation[:memory]; end
-        end
-
-        it 'returns name based only on class' do
-          relation = Test::SuperRelation.new([])
-
-          expect(relation.name).to eql(ROM::Relation::Name.new(:test_super_relation))
-        end
-      end
-
-      context 'with a descendant relation' do
-        before do
-          class Test::SuperRelation < ROM::Relation[:memory]; end
-          class Test::DescendantRelation < Test::SuperRelation; end
-        end
-
-        it 'inherits :name from the super relation' do
-          relation = Test::DescendantRelation.new([])
-
-          expect(relation.name).to eql(ROM::Relation::Name.new(:test_super_relation))
-        end
-      end
-    end
-
-    context 'manualy set dataset' do
-      before do
-        module Test::TestAdapter
-          class Relation < ROM::Relation[:memory]
-            dataset :foo_bar
-          end
-        end
-      end
-
-      it 'returns name based on dataset' do
-        relation = Test::TestAdapter::Relation.new([])
-
-        expect(relation.name).to eql(ROM::Relation::Name.new(:foo_bar))
-      end
-    end
-  end
-
-  describe "#each" do
-    it "yields all objects" do
-      result = []
-
-      relation.each do |user|
-        result << user
-      end
-
-      expect(result).to eql([jane, joe])
-    end
-
-    it "returns an enumerator if block is not provided" do
-      expect(relation.each).to be_instance_of(Enumerator)
-    end
-  end
-
-  describe "#to_a" do
-    it "materializes relation to an array" do
-      expect(relation.to_a).to eql([jane, joe])
-    end
-  end
-
-  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([])
-
-      custom_opts = { mappers: "Custom Mapper Registry" }
-      new_relation = relation.with(custom_opts).with(custom: true)
-
-      expect(new_relation.dataset).to be(relation.dataset)
-      expect(new_relation.options).to include(custom_opts.merge(custom: true))
-    end
-  end
-
-  describe '#graph?' do
-    it 'returns false' do
-      expect(relation.graph?).to be(false)
-    end
-
-    it 'returns false when curried' do
-      relation = Class.new(ROM::Relation[:memory]) { def by_name(_); self; end }.new([])
-      expect(relation.by_name.graph?).to be(false)
-    end
-  end
-
-  describe '#schema_hash' 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)
-    end
-
-    it 'returns a plain Hash coercer when there is no schema' do
-      relation = Class.new(ROM::Relation[:memory]).new([])
-
-      tuple = [[:id, '1']]
-
-      expect(relation.schema_hash[tuple]).to eql(id: '1')
-    end
-  end
-end

data/spec/unit/rom/schema_spec.rb

@@ -1,10 +0,0 @@
-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)
-
-      expect(schema.to_h).to eql(attrs)
-    end
-  end
-end