rom 2.0.2 → 4.2.1

data/spec/unit/rom/plugins/relation/key_inference_spec.rb

@@ -1,85 +0,0 @@
-require 'rom'
-require 'rom/memory'
-require 'rom/plugins/relation/key_inference'
-
-RSpec.describe ROM::Plugins::Relation::KeyInference do
-  subject(:relation) do
-    relation_class.new(
-      [],
-      __registry__: ROM::RelationRegistry.new(posts: posts, users: users, tags: tags)
-    )
-  end
-
-  let(:posts) { double(foreign_key: :post_id) }
-  let(:tags_name) { ROM::Relation::Name[:tags] }
-  let(:tags) { double(foreign_key: :tag_id) }
-  let(:users_name) { ROM::Relation::Name[:users] }
-  let(:users) { double(base_name: users_name) }
-
-  describe 'without a schema' do
-    let(:relation_class) do
-      Class.new(ROM::Memory::Relation) do
-        use :key_inference
-
-        dataset :users
-      end
-    end
-
-    describe '#base_name' do
-      it 'returns dataset name by default' do
-        expect(relation.base_name).to eql(ROM::Relation::Name[:users])
-      end
-    end
-
-    describe '#foreign_key' do
-      it 'returns default value' do
-        expect(relation.foreign_key).to be(:user_id)
-      end
-
-      it 'returns default value for another relation' do
-        expect(relation.foreign_key(:posts)).to be(:post_id)
-        expect(relation.foreign_key(posts)).to be(:post_id)
-      end
-
-      it 'returns default value for Relation::Name' do
-        expect(relation.foreign_key(ROM::Relation::Name[:posts])).to be(:post_id)
-      end
-
-      it 'supports objects responding to to_sym' do
-        external_name = double(to_sym: :tags)
-        expect(relation.foreign_key(external_name)).to be(:tag_id)
-      end
-    end
-  end
-
-  describe 'with a schema' do
-    let(:relation_class) do
-      Class.new(ROM::Memory::Relation) do
-        use :key_inference
-
-        schema :posts do
-          attribute :author_id, ROM::Types::Int.meta(foreign_key: true, relation: :users)
-        end
-      end
-    end
-
-    describe '#foreign_key' do
-      it 'returns configured value' do
-        expect(relation.foreign_key(ROM::Relation::Name[:users])).to be(:author_id)
-        expect(relation.foreign_key(:users)).to be(:author_id)
-        expect(relation.foreign_key(users)).to be(:author_id)
-        expect(relation.foreign_key(users_name)).to be(:author_id)
-      end
-
-      it 'falls back to default when schema has no fk specified' do
-        expect(relation.foreign_key(:tags)).to be(:tag_id)
-        expect(relation.foreign_key(tags_name)).to be(:tag_id)
-      end
-
-      it 'supports objects responding to to_sym' do
-        external_name = double(to_sym: :tags)
-        expect(relation.foreign_key(external_name)).to be(:tag_id)
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-require 'rom'
-require 'rom/memory'
-require 'rom/plugins/relation/view'
-
-RSpec.describe ROM::Plugins::Relation::View do
-  subject(:relation) { relation_class.new([]) }
-
-  let(:relation_class) do
-    Class.new(ROM::Memory::Relation) do
-      use :view
-
-      view(:base, [:id, :name]) do
-        self
-      end
-
-      view(:ids, [:id]) do
-        self
-      end
-
-      view(:names, [:name]) do |id|
-        self
-      end
-    end
-  end
-
-  describe '#attributes' do
-    it 'returns base view attributes by default' do
-      expect(relation.attributes).to eql([:id, :name])
-    end
-
-    it 'returns attributes for a view' do
-      expect(relation.ids.attributes).to eql([:id])
-    end
-
-    it 'returns attributes for a view with args' do
-      expect(relation.names(1).attributes).to eql([:name])
-    end
-
-    it 'returns attributes for a curried view' do
-      expect(relation.names.attributes).to eql([:name])
-    end
-
-    it 'returns correct arity for a curried view' do
-      expect(relation.names.arity).to be(1)
-    end
-
-    it 'returns explicitly set attributes' do
-      expect(relation.with(attributes: [:foo, :bar]).attributes).to eql([:foo, :bar])
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Relation::Composite 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 sorted(other)
-        other.source.order(:name)
-      end
-    end.new(users_dataset)
-  end
-
-  let(:tasks_relation) do
-    Class.new(ROM::Memory::Relation) do
-      def for_users(users)
-        restrict(name: users.map { |u| u[:name] })
-      end
-    end.new(tasks_dataset)
-  end
-
-  let(:name_list) { proc { |r| r.map { |t| t[:name] } } }
-  let(:upcaser) { proc { |r| r.map(&:upcase) } }
-
-  describe '#call' do
-    it 'sends a relation through mappers' do
-      relation = users_relation >> name_list >> upcaser
-      loaded = relation.call
-
-      expect(loaded.source).to eql(users_relation)
-
-      expect(loaded).to match_array(%w(JANE JOE))
-    end
-
-    it 'sends a relation through another relation' do
-      relation = users_relation >> users_relation.sorted
-      loaded = relation.call
-
-      expect(loaded.source).to eql(users_relation.sorted(users_relation.call))
-
-      expect(loaded).to match_array([
-        { name: 'Jane', email: 'jane@doe.org' },
-        { name: 'Joe', email: 'joe@doe.org' }
-      ])
-    end
-
-    it 'sends a relation through another composite relation' do
-      task_mapper = -> tasks_relation { tasks_relation }
-      relation = users_relation.by_name('Jane') >> (tasks_relation.for_users >> task_mapper)
-
-      loaded = relation.call
-
-      expect(loaded.source).to eql(tasks_relation.for_users(users_relation.by_name('Jane')))
-
-      expect(loaded).to match_array([
-        { name: 'Jane', title: 'be cool', priority: 2 }
-      ])
-    end
-  end
-
-  describe '#each' do
-    let(:relation) { users_relation >> name_list >> upcaser }
-
-    it 'calls and iterates' do
-      result = []
-      relation.each do |object|
-        result << object
-      end
-      expect(result).to match_array(%w(JANE JOE))
-    end
-
-    it 'returns enumerator if block is not provided' do
-      expect(relation.each.to_a).to match_array(%w(JANE JOE))
-    end
-  end
-
-  describe '#first' do
-    let(:relation) { users_relation >> name_list >> upcaser }
-
-    it 'calls and returns the first object' do
-      expect(relation.first).to eql('JOE')
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Relation::Curried 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 find(criteria)
-        restrict(criteria)
-      end
-    end.new(users_dataset)
-  end
-
-  describe '#call' do
-    let(:relation) { users_relation.by_name.call('Jane') }
-
-    it 'materializes a relation' do
-      expect(relation).to match_array([
-        name: 'Jane', email: 'jane@doe.org'
-      ])
-    end
-
-    it 'returns a loaded relation' do
-      expect(relation.source).to eql(users_relation.by_name('Jane'))
-    end
-  end
-
-  describe '#respond_to?' do
-    it 'returns true if wrapped relation responds to a method' do
-      expect(users_relation.by_name).to respond_to(:dataset)
-    end
-
-    it 'returns false if wrapped relation does not respond to a method' do
-      expect(users_relation.by_name).not_to respond_to(:not_here)
-    end
-  end
-
-  describe '#method_missing' do
-    it 'forwards to the relation' do
-      expect(users_relation.by_name.dataset).to eql(users_relation.dataset)
-    end
-
-    it 'does not forward to the relation when method is auto-curried' do
-      expect { users_relation.by_name.find }.to raise_error(NoMethodError, /find/)
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Relation::Graph 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
-    end.new(users_dataset)
-  end
-
-  let(:tasks_relation) do
-    Class.new(ROM::Memory::Relation) do
-      def for_users(_users)
-        self
-      end
-    end.new(tasks_dataset)
-  end
-
-  subject(:graph) { ROM::Relation::Graph.new(users_relation, [tasks_relation.for_users]) }
-
-  describe '#graph?' do
-    it 'returns true' do
-      expect(graph.graph?).to be(true)
-    end
-
-    it 'returns true when curried' do
-      expect(graph.by_name.graph?).to be(true)
-    end
-  end
-
-  it_behaves_like 'materializable relation' do
-    let(:mapper) do
-      T(:combine, [[:tasks, name: :name]])
-    end
-
-    let(:relation) do
-      ROM::Relation::Graph.new(users_relation.by_name('Jane'), [tasks_relation.for_users]) >> mapper
-    end
-  end
-
-  describe '#method_missing' do
-    it 'responds to the root methods' do
-      expect(graph).to respond_to(:by_name)
-    end
-
-    it 'forwards methods to the root and decorates response' do
-      expect(graph.by_name('Jane')).to be_instance_of(ROM::Relation::Graph)
-    end
-
-    it 'forwards methods to the root and decorates curried response' do
-      expect((users_relation.combine(tasks_relation.for_users)).by_name).to be_instance_of(ROM::Relation::Graph)
-    end
-
-    it 'returns original response from the root' do
-      expect(graph.mappers).to eql(users_relation.mappers)
-    end
-
-    it 'raises method error' do
-      expect { graph.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-  end
-
-  describe '#call' do
-    it 'materializes relations' do
-      expect(graph.call).to match_array([
-        users_relation,
-        [tasks_relation]
-      ])
-    end
-  end
-
-  describe '#to_a' do
-    it 'coerces to an array' do
-      expect(graph).to match_array([
-        users_relation.to_a,
-        [tasks_relation.for_users(users_relation).to_a]
-      ])
-    end
-
-    it 'returns empty arrays when left was empty' do
-      graph = ROM::Relation::Graph.new(users_relation.by_name('Not here'), [tasks_relation.for_users])
-
-      expect(graph).to match_array([
-        [], [ROM::Relation::Loaded.new(tasks_relation.for_users, [])]
-      ])
-    end
-  end
-end

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

@@ -1,165 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Relation, '#combine' do
-  include_context 'gateway only'
-  include_context 'users and tasks'
-
-  let(:tags_dataset) { gateway.dataset(:tags) }
-
-  let(:users_relation) do
-    Class.new(ROM::Memory::Relation) do
-      def by_name(name)
-        restrict(name: name)
-      end
-    end.new(users_dataset)
-  end
-
-  let(:tasks_relation) do
-    Class.new(ROM::Memory::Relation) do
-      def for_users(users)
-        names = users.map { |user| user[:name] }
-        restrict { |task| names.include?(task[:name]) }
-      end
-    end.new(tasks_dataset)
-  end
-
-  let(:tags_relation) do
-    Class.new(ROM::Memory::Relation) do
-      attr_accessor :tasks
-      forward :map
-
-      def for_tasks(tasks)
-        titles = tasks.map { |task| task[:title] }
-        restrict { |tag| titles.include?(tag[:task]) }
-      end
-
-      def for_users(users)
-        user_tasks = tasks.for_users(users)
-
-        for_tasks(user_tasks).map { |tag|
-          tag.merge(user: user_tasks.detect { |task|
-            task[:title] == tag[:task]
-          } [:name])
-        }
-      end
-    end.new(tags_dataset).tap { |r| r.tasks = tasks_relation }
-  end
-
-  before do
-    tags_dataset.insert(task: 'be cool', name: 'red')
-    tags_dataset.insert(task: 'be cool', name: 'green')
-  end
-
-  let(:map_users) {
-    proc { |users, tasks|
-      users.map { |user|
-        user.merge(tasks: tasks.select { |task| task[:name] == user[:name] })
-      }
-    }
-  }
-
-  let(:map_tasks) {
-    proc { |(tasks, children)|
-      tags = children.first
-
-      tasks.map { |task|
-        task.merge(tags: tags.select { |tag| tag[:task] == task[:title] })
-      }
-    }
-  }
-
-  let(:map_user_with_tasks_and_tags) {
-    proc { |users, (tasks, tags)|
-      users.map { |user|
-        user_tasks = tasks.select { |task| task[:name] == user[:name] }
-
-        user_tags = tasks.flat_map { |task|
-          tags.select { |tag| tag[:task] == task[:title] }
-        }
-
-        user.merge(
-          tasks: user_tasks,
-          tags: user_tags
-        )
-      }
-    }
-  }
-
-  let(:map_user_with_tasks) {
-    proc { |users, children|
-      map_users[users, map_tasks[children.first]]
-    }
-  }
-
-  it 'raises error when composite relation is passed as a node' do
-    expect {
-      users_relation.combine(tasks_relation >> proc {})
-    }.to raise_error(ROM::UnsupportedRelationError)
-  end
-
-  it 'supports more than one eagerly-loaded relation' do
-    expected = [
-      {
-        name: 'Jane',
-        email: 'jane@doe.org',
-        tasks: [
-          { name: 'Jane', title: 'be cool', priority: 2 }
-        ],
-        tags: [
-          { task: 'be cool', name: 'red' },
-          { task: 'be cool', name: 'green' }
-        ]
-      }
-    ]
-
-    user_with_tasks_and_tags = users_relation.by_name('Jane')
-      .combine(tasks_relation.for_users, tags_relation.for_users)
-
-    result = user_with_tasks_and_tags >> map_user_with_tasks_and_tags
-
-    expect(result.to_a).to eql(expected)
-  end
-
-  it 'supports more than one eagerly-loaded relation via chaining' do
-    expected = [
-      {
-        name: 'Jane',
-        email: 'jane@doe.org',
-        tasks: [
-          { name: 'Jane', title: 'be cool', priority: 2 }
-        ],
-        tags: [
-          { task: 'be cool', name: 'red' },
-          { task: 'be cool', name: 'green' }
-        ]
-      }
-    ]
-
-    user_with_tasks_and_tags = users_relation.by_name('Jane')
-      .combine(tasks_relation.for_users).combine(tags_relation.for_users)
-
-    result = user_with_tasks_and_tags >> map_user_with_tasks_and_tags
-
-    expect(result).to match_array(expected)
-  end
-
-  it 'supports nested eager-loading' do
-    expected = [
-      {
-        name: 'Jane', email: 'jane@doe.org', tasks: [
-          { name: 'Jane', title: 'be cool', priority: 2, tags: [
-            { task: 'be cool', name: 'red' },
-            { task: 'be cool', name: 'green' }
-          ] }
-        ]
-      }
-    ]
-
-    user_with_tasks = users_relation.by_name('Jane')
-      .combine(tasks_relation.for_users.combine(tags_relation.for_tasks))
-
-    result = user_with_tasks >> map_user_with_tasks
-
-    expect(result).to match_array(expected)
-  end
-end