rom 3.3.3 → 4.0.0.beta1

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

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Relation::Composite do
-  include_context 'gateway only'
-  include_context 'users and tasks'
-
-  let(:users_relation) do
-    Class.new(ROM::Memory::Relation) do
-      schema do
-        attribute :name, ROM::Types::String
-        attribute :email, ROM::Types::String
-      end
-
-      def by_name(name)
-        restrict(name: name)
-      end
-
-      def sorted(other)
-        other.source.order(:name)
-      end
-
-      def select(key)
-        project(key)
-      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
-
-  describe '#__send__' do
-    it 'proxies Kernel methods' do
-      relation = (users_relation >> name_list >> upcaser).__send__(:select, :name)
-
-      expect(relation.call).to match_array(%w(JANE JOE))
-    end
-  end
-end

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

@@ -1,67 +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 by_name_and_age(name, age)
-        restrict(name: name, age: age)
-      end
-
-      def find(criteria)
-        restrict(criteria)
-      end
-    end.new(users_dataset)
-  end
-
-  describe '#call' do
-    let(:relation) { users_relation.by_name }
-
-    it 'materializes a relation' do
-      expect(relation.('Jane').to_a).to eql([name: 'Jane', email: 'jane@doe.org'])
-    end
-
-    it 'returns a loaded relation' do
-      expect(relation.('Jane').source).to eql(users_relation.by_name('Jane'))
-    end
-
-    it 'raises argument error if no arguments were provided' do
-      expect { relation.() }.
-        to raise_error(
-             ArgumentError,
-             "curried #{users_relation.class}#by_name relation was called without any arguments")
-    end
-
-    it 'returns self when has curried args and no additional args were provided' do
-      curried = users_relation.by_name_and_age.('Jane')
-
-      expect(curried.().__id__).to be(curried.__id__)
-    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,106 +0,0 @@
-require 'spec_helper'
-
-RSpec.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
-
-      def by_title(title)
-        restrict(title: title)
-      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 '#with_nodes' do
-    it 'returns a new graph with new nodes' do
-      new_tasks = tasks_relation.by_title('foo')
-      new_graph = graph.with_nodes([new_tasks])
-
-      expect(new_graph.nodes[0]).to be(new_tasks)
-    end
-  end
-
-  describe '#call' do
-    it 'materializes relations' do
-      root, nodes = graph.call.to_a
-
-      expect(root.to_a).to eql(users_relation.to_a)
-      expect(nodes.flatten).to eql(tasks_relation.to_a)
-    end
-  end
-
-  describe '#to_a' do
-    it 'coerces to an array' do
-      root, nodes = graph.to_a
-
-      expect(root.to_a).to eql(users_relation.to_a)
-      expect(nodes.flatten).to eql(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])
-
-      root, nodes = graph.to_a
-
-      expect(root).to be_empty
-      expect(nodes.flatten).to be_empty
-    end
-  end
-end

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

@@ -1,165 +0,0 @@
-require 'spec_helper'
-
-RSpec.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', user: 'Jane' },
-          { task: 'be cool', name: 'green', user: 'Jane' }
-        ]
-      }
-    ]
-
-    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', user: 'Jane' },
-          { task: 'be cool', name: 'green', user: 'Jane' }
-        ]
-      }
-    ]
-
-    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

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

@@ -1,165 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::Relation, '#graph' 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.graph(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', user: 'Jane' },
-          { task: 'be cool', name: 'green', user: 'Jane' }
-        ]
-      }
-    ]
-
-    user_with_tasks_and_tags = users_relation.by_name('Jane')
-      .graph(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', user: 'Jane' },
-          { task: 'be cool', name: 'green', user: 'Jane' }
-        ]
-      }
-    ]
-
-    user_with_tasks_and_tags = users_relation.by_name('Jane')
-      .graph(tasks_relation.for_users).graph(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')
-      .graph(tasks_relation.for_users.graph(tags_relation.for_tasks))
-
-    result = user_with_tasks >> map_user_with_tasks
-
-    expect(result).to match_array(expected)
-  end
-end