rom 3.3.3 → 4.0.0.beta1

data/spec/integration/relations/registry_dsl_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Relation registration DSL' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  it 'allows to expose chainable relations' do
-    configuration.relation(:tasks) do
-      def high_priority
-        restrict { |tuple| tuple[:priority] < 2 }
-      end
-
-      def by_title(title)
-        restrict(title: title)
-      end
-    end
-
-    configuration.relation(:users) do
-      def with_tasks
-        join(tasks)
-      end
-    end
-
-    tasks = container.relations.tasks
-
-    expect(tasks.class.name).to eql("ROM::Relation[Tasks]")
-    expect(tasks.high_priority.inspect).to include("#<ROM::Relation[Tasks]")
-
-    expect(tasks.high_priority.by_title("be nice")).to match_array(
-      [name: "Joe", title: "be nice", priority: 1]
-    )
-
-    expect(tasks.by_title("be cool")).to match_array(
-      [name: "Jane", title: "be cool", priority: 2]
-    )
-
-    users = container.relations.users
-
-    expect(users.with_tasks).to match_array(
-      [{ name: "Joe", email: "joe@doe.org", title: "be nice", priority: 1 },
-       { name: "Joe", email: "joe@doe.org", title: "sleep well", priority: 2 },
-       { name: "Jane", email: "jane@doe.org", title: "be cool", priority: 2 }]
-    )
-  end
-end

data/spec/integration/setup_spec.rb

@@ -1,193 +0,0 @@
-require 'spec_helper'
-require 'rom/plugins/relation/key_inference'
-require 'dry-struct'
-
-RSpec.describe 'Configuring ROM' do
-  context 'with existing schema' do
-    include_context 'container'
-    include_context 'users and tasks'
-
-    let(:jane) { { name: 'Jane', email: 'jane@doe.org' } }
-    let(:joe) { { name: 'Joe', email: 'joe@doe.org' } }
-
-    before do
-      configuration.relation(:users)
-      configuration.relation(:tasks)
-    end
-
-    it 'configures schema relations' do
-      expect(container.gateways[:default][:users]).to match_array([joe, jane])
-    end
-
-    it 'configures rom relations' do
-      users = container.relations.users
-
-      expect(users).to be_kind_of(ROM::Relation)
-      expect(users).to respond_to(:tasks)
-
-      tasks = users.tasks
-
-      expect(tasks).to be_kind_of(ROM::Relation)
-      expect(tasks).to respond_to(:users)
-      expect(tasks.users).to be(users)
-    end
-  end
-
-  context 'without schema' do
-    it 'builds empty registries if there is no schema' do
-      container = ROM.container(:memory)
-      expect(container.relations).to eql(ROM::RelationRegistry.new)
-      expect(container.mappers).to eql(ROM::Registry.new)
-    end
-  end
-
-  describe 'defining classes' do
-    let(:container) do
-      ROM.container(:memory) do |config|
-        class Test::UserRelation < ROM::Relation[:memory]
-          dataset :users
-
-          def by_name(name)
-            restrict(name: name)
-          end
-        end
-
-        class Test::TaskRelation < ROM::Relation[:memory]
-          dataset :tasks
-        end
-
-        class Test::CreateUser < ROM::Commands::Update[:memory]
-          relation :users
-          register_as :create
-        end
-
-        config.register_relation(Test::UserRelation, Test::TaskRelation)
-        config.register_command(Test::CreateUser)
-      end
-    end
-
-    it 'sets up registries based on class definitions' do
-      expect(container.relations.users).to be_kind_of(Test::UserRelation)
-      expect(container.relations.users.tasks).to be(container.relations.tasks)
-
-      expect(container.commands.users[:create]).to be_kind_of(Test::CreateUser)
-
-      expect(container.relations.tasks).to be_kind_of(Test::TaskRelation)
-      expect(container.relations.tasks.users).to be(container.relations.users)
-    end
-
-    it 'sets empty schemas by default' do
-      expect(container.relations[:users].schema).to be_empty
-      expect(container.relations[:tasks].schema).to be_empty
-    end
-  end
-
-  describe 'quick setup' do
-    # NOTE: move to DSL tests
-    it 'exposes boot DSL inside the setup block via `macros` plugin' do
-      module Test
-        User = Class.new(Dry::Struct) do
-          attribute :name, Types::String
-        end
-      end
-
-      container = ROM.container(:memory) do |rom|
-        rom.relation(:users) do
-          def by_name(name)
-            restrict(name: name)
-          end
-        end
-
-        rom.commands(:users) do
-          define(:create)
-        end
-
-        rom.mappers do
-          define(:users) do
-            model Test::User
-          end
-        end
-      end
-
-      container.commands.users.create.call(name: 'Jane')
-
-      expect(container.relation(:users).by_name('Jane').as(:users).to_a)
-        .to eql([Test::User.new(name: 'Jane')])
-
-      expect(container.relations[:users].map_with(:users).to_a)
-        .to eql([Test::User.new(name: 'Jane')])
-    end
-  end
-
-  describe 'multi-step setup' do
-    it 'exposes boot DSL that can be invoked multiple times' do
-      module Test
-        User = Class.new(Dry::Struct) do
-          attribute :name, Types::String
-        end
-      end
-
-      configuration = ROM::Configuration.new(:memory)
-
-      configuration.relation(:users) do
-        def by_name(name)
-          restrict(name: name)
-        end
-      end
-
-      configuration.commands(:users) do
-        define(:create)
-      end
-
-      configuration.mappers do
-        define(:users) do
-          model Test::User
-        end
-      end
-
-      container = ROM.container(configuration)
-
-      container.command(:users).create.call(name: 'Jane')
-
-      expect(container.relation(:users).by_name('Jane').as(:users).to_a)
-        .to eql([Test::User.new(name: 'Jane')])
-    end
-  end
-
-  it 'allows to use a relation with a schema in multiple containers' do
-    class Test::UserRelation < ROM::Relation[:memory]
-      dataset :users
-
-      schema do
-        attribute :id, Types::Int.meta(primary_key: true)
-      end
-    end
-
-    2.times do
-      ROM.container(:memory) { |c| c.register_relation(Test::UserRelation) }
-    end
-  end
-
-  describe 'configuring plugins for all relations' do
-    it 'allows setting instrumentation for relations' do
-      Test::Notifications = double(:notifications)
-
-      configuration = ROM::Configuration.new(:memory)
-
-      configuration.plugin(:memory, relations: :instrumentation) do |p|
-        p.notifications = Test::Notifications
-      end
-
-      configuration.plugin(:memory, relations: :key_inference)
-
-      configuration.relation(:users)
-
-      container = ROM.container(configuration)
-
-      users = container.relations[:users]
-
-      expect(users.notifications).to be(Test::Notifications)
-      expect(users).to respond_to(:foreign_key)
-    end
-  end
-end

data/spec/shared/command_behavior.rb

@@ -1,28 +0,0 @@
-shared_examples_for 'a command' do
-  describe '#name' do
-    it 'returns relation name' do
-      expect(command.name).to eql(command.relation.name)
-    end
-  end
-
-  describe '#gateway' do
-    it 'returns relation gateway' do
-      expect(command.gateway).to eql(command.relation.gateway)
-    end
-  end
-
-  describe '#method_missing' do
-    it 'forwards to relation and wraps response if it returned another relation' do
-      if command.class.restrictable
-        new_command = command.by_id(1)
-
-        expect(new_command).to be_instance_of(command.class)
-        expect(new_command.relation).to eql(command.by_id(1).relation)
-      end
-    end
-
-    it 'raises error when message is not known' do
-      expect { command.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-  end
-end

data/spec/shared/command_graph.rb

@@ -1,54 +0,0 @@
-shared_context 'command graph' do
-  include_context 'container'
-
-  before do
-    configuration.relation :users do
-      def by_name(name)
-        restrict(name: name)
-      end
-    end
-
-    configuration.relation :tasks do
-      def by_user_and_title(user, title)
-        by_user(user).by_title(title)
-      end
-
-      def by_user(user)
-        restrict(user: user)
-      end
-
-      def by_title(title)
-        restrict(title: title)
-      end
-    end
-
-    configuration.relation :books
-    configuration.relation :tags
-
-    configuration.commands(:users) do
-      define(:create) do
-        result :one
-      end
-    end
-
-    configuration.commands(:books) do
-      define(:create) do
-        before :associate
-
-        def associate(tuples, user)
-          tuples.map { |t| t.merge(user: user.fetch(:name)) }
-        end
-      end
-    end
-
-    configuration.commands(:tags) do
-      define(:create) do
-        before :associate
-
-        def associate(tuples, task)
-          tuples.map { |t| t.merge(task: task.fetch(:title)) }
-        end
-      end
-    end
-  end
-end

data/spec/shared/container.rb

@@ -1,9 +0,0 @@
-RSpec.shared_context 'container' do
-  let(:container) { ROM.container(configuration) }
-  let!(:configuration) { ROM::Configuration.new(:memory) }
-  let(:gateway) { configuration.gateways[:default] }
-  let(:users_relation) { container.relation(:users) }
-  let(:tasks_relation) { container.relation(:tasks) }
-  let(:users_dataset) { gateway.dataset(:users) }
-  let(:tasks_dataset) { gateway.dataset(:tasks) }
-end

data/spec/shared/enumerable_dataset.rb

@@ -1,52 +0,0 @@
-RSpec.shared_examples_for "an enumerable dataset" do
-  subject(:dataset) { klass.new(data) }
-
-  let(:data) do
-    [{ 'name' => 'Jane' }, { 'name' => 'Joe' }]
-  end
-
-  describe '#each' do
-    it 'yields tuples through row_proc' do
-      result = []
-
-      dataset.each do |tuple|
-        result << tuple
-      end
-
-      expect(result).to match_array([{ name: 'Jane' }, { name: 'Joe' }])
-    end
-  end
-
-  describe '#to_a' do
-    it 'casts dataset to an array' do
-      expect(dataset.to_a).to eql([{ name: 'Jane' }, { name: 'Joe' }])
-    end
-  end
-
-  describe '#find_all' do
-    it 'yields tuples through row_proc' do
-      result = dataset.find_all { |tuple| tuple[:name] == 'Jane' }
-
-      expect(result).to be_instance_of(klass)
-      expect(result).to match_array([{ name: 'Jane' }])
-    end
-  end
-
-  describe '#kind_of?' do
-    it 'does not forward to data object' do
-      expect(dataset).to be_kind_of(klass)
-    end
-  end
-
-  describe '#instance_of?' do
-    it 'does not forward to data object' do
-      expect(dataset).to be_instance_of(klass)
-    end
-  end
-
-  describe '#is_a?' do
-    it 'does not forward to data object' do
-      expect(dataset.is_a?(klass)).to be(true)
-    end
-  end
-end

data/spec/shared/gateway_only.rb

@@ -1,6 +0,0 @@
-RSpec.shared_context 'gateway only' do
-  let(:gateway) { ROM::Memory::Gateway.new }
-
-  let(:users_dataset) { gateway.dataset(:users) }
-  let(:tasks_dataset) { gateway.dataset(:tasks) }
-end

data/spec/shared/materializable.rb

@@ -1,36 +0,0 @@
-shared_examples_for 'materializable relation' do
-  describe '#each' do
-    it 'yields objects' do
-      count = relation.to_a.size
-      result = []
-
-      relation.each do |object|
-        result << object
-      end
-
-      expect(result.count).to eql(count)
-    end
-
-    it 'returns enumerator when block is not provided' do
-      expect(relation.each.to_a).to eql(relation.to_a)
-    end
-  end
-
-  describe '#one' do
-    it 'returns one tuple' do
-      expect(relation.one).to be_instance_of(Hash)
-    end
-  end
-
-  describe '#first' do
-    it 'returns first tuple' do
-      expect(relation.first).to be_instance_of(Hash)
-    end
-  end
-
-  describe '#call' do
-    it 'materializes relation' do
-      expect(relation.call).to be_instance_of(ROM::Relation::Loaded)
-    end
-  end
-end

data/spec/shared/no_container.rb

@@ -1,16 +0,0 @@
-require 'rom/memory'
-
-RSpec.shared_context 'no container' do
-  let(:gateway) { ROM::Memory::Gateway.new }
-
-  let(:users_dataset) { gateway.dataset(:users) }
-  let(:tasks_dataset) { gateway.dataset(:tasks) }
-
-  let(:users_relation) do
-    Class.new(ROM::Memory::Relation).new(users_dataset)
-  end
-
-  let(:tasks_relation) do
-    Class.new(ROM::Memory::Relation).new(tasks_dataset)
-  end
-end

data/spec/shared/one_behavior.rb

@@ -1,26 +0,0 @@
-shared_examples_for 'a relation that returns one tuple' do
-  describe '#one' do
-    it 'returns first tuple' do
-      users_relation.delete(name: 'Joe', email: 'joe@doe.org')
-      expect(relation.one).to eql(name: 'Jane', email: 'jane@doe.org')
-    end
-
-    it 'raises error when there is more than one tuple' do
-      expect { relation.one }.to raise_error(ROM::TupleCountMismatchError)
-    end
-  end
-
-  describe '#one!' do
-    it 'returns first tuple' do
-      users_relation.delete(name: 'Joe', email: 'joe@doe.org')
-      expect(relation.one!).to eql(name: 'Jane', email: 'jane@doe.org')
-    end
-
-    it 'raises error when there is no tuples' do
-      users_relation.delete(name: 'Jane', email: 'jane@doe.org')
-      users_relation.delete(name: 'Joe', email: 'joe@doe.org')
-
-      expect { relation.one! }.to raise_error(ROM::TupleCountMismatchError)
-    end
-  end
-end

data/spec/shared/users_and_tasks.rb

@@ -1,10 +0,0 @@
-RSpec.shared_context 'users and tasks' do
-  before do
-    users_dataset.insert(name: "Joe", email: "joe@doe.org")
-    users_dataset.insert(name: "Jane", email: "jane@doe.org")
-
-    tasks_dataset.insert(name: "Joe", title: "be nice", priority: 1)
-    tasks_dataset.insert(name: "Joe", title: "sleep well", priority: 2)
-    tasks_dataset.insert(name: "Jane", title: "be cool", priority: 2)
-  end
-end

data/spec/spec_helper.rb

@@ -1,59 +0,0 @@
-require 'pathname'
-
-if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
-  require 'yaml'
-  rubies = YAML.load(File.read(File.join(__dir__, '..', '.travis.yml')))['rvm']
-  latest_mri = rubies.select { |v| v =~ /\A\d+\.\d+.\d+\z/ }.max
-
-  if RUBY_VERSION == latest_mri
-    require 'simplecov'
-    SimpleCov.start do
-      add_filter '/spec/'
-    end
-  end
-end
-
-SPEC_ROOT = root = Pathname(__FILE__).dirname
-
-require 'dry/core/deprecations'
-Dry::Core::Deprecations.set_logger!(SPEC_ROOT.join('../log/deprecations.log'))
-
-require 'rom'
-
-begin
-  require 'byebug'
-rescue LoadError
-end
-
-Dir[root.join('support/*.rb').to_s].each do |f|
-  require f
-end
-Dir[root.join('shared/*.rb').to_s].each do |f|
-  require f
-end
-
-# Namespace holding all objects created during specs
-module Test
-  def self.remove_constants
-    constants.each(&method(:remove_const))
-  end
-end
-
-def T(*args)
-  ROM::Processor::Transproc::Functions[*args]
-end
-
-RSpec.configure do |config|
-  config.include(SchemaHelpers)
-
-  config.after do
-    Test.remove_constants
-  end
-
-  config.around do |example|
-    ConstantLeakFinder.find(example)
-  end
-
-  config.disable_monkey_patching!
-  config.warnings = true
-end

data/spec/support/constant_leak_finder.rb

@@ -1,14 +0,0 @@
-# Finds leaking constants created during ROM specs
-module ConstantLeakFinder
-  def self.find(example)
-    constants = Object.constants
-
-    example.run
-
-    added_constants = (Object.constants - constants)
-    added = added_constants.map(&Object.method(:const_get))
-    if added.any? { |mod| mod.ancestors.map(&:name).grep(/\AROM/).any? }
-      raise "Leaking constants: #{added_constants.inspect}"
-    end
-  end
-end

data/spec/support/mutant.rb

@@ -1,10 +0,0 @@
-module Mutant
-  class Selector
-    # Expression based test selector
-    class Expression < self
-      def call(_subject)
-        integration.all_tests
-      end
-    end # Expression
-  end # Selector
-end # Mutant

data/spec/support/schema.rb

@@ -1,14 +0,0 @@
-require 'dry-types'
-
-module SchemaHelpers
-  def define_schema(source, attrs)
-    ROM::Schema.define(
-      source,
-      attributes: attrs.map { |name, type| define_type(name, type, source: source) }
-    )
-  end
-
-  def define_type(name, id, **opts)
-    ROM::Types.const_get(id).meta(name: name, **opts)
-  end
-end

data/spec/support/types.rb

@@ -1,5 +0,0 @@
-require 'dry-types'
-
-module Types
-  include Dry::Types.module
-end

data/spec/test/memory_repository_lint_test.rb

@@ -1,27 +0,0 @@
-require 'rom'
-require 'rom/memory'
-require 'rom/lint/test'
-
-require 'minitest/autorun'
-
-class MemoryRepositoryLintTest < Minitest::Test
-  include ROM::Lint::TestGateway
-
-  def setup
-    @gateway = ROM::Memory::Gateway
-    @identifier = :memory
-  end
-
-  def gateway_instance
-    ROM::Memory::Gateway.new
-  end
-end
-
-class MemoryDatasetLintTest < Minitest::Test
-  include ROM::Lint::TestEnumerableDataset
-
-  def setup
-    @data = [{ name: 'Jane', age: 24 }, { name: 'Joe', age: 25 }]
-    @dataset = ROM::Memory::Dataset.new(@data)
-  end
-end

data/spec/unit/rom/array_dataset_spec.rb

@@ -1,59 +0,0 @@
-require 'rom/array_dataset'
-
-RSpec.describe ROM::ArrayDataset do
-  let(:klass) do
-    Class.new do
-      include ROM::ArrayDataset
-
-      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' do
-    describe '#flatten' do
-      let(:data) { [[{ 'name' => 'Jane' }], [{ 'name' => 'Joe' }]] }
-
-      it 'returns a new dataset with flattened data' do
-        result = dataset.flatten
-
-        expect(result).to match_array([{ name: 'Jane' }, { name: 'Joe' }])
-      end
-    end
-
-    describe '#map!' do
-      context 'with a block' do
-        it 'returns a new dataset with mapped data' do
-          dataset.map! do |row|
-            row.merge(age: 21)
-          end
-
-          expect(dataset).to match_array([
-            { name: 'Jane', age: 21 }, { name: 'Joe', age: 21 }
-          ])
-        end
-      end
-
-      context 'without a block' do
-        it 'returns an enumerator' do
-          result = dataset.map!
-
-          expect(result).to be_instance_of(Enumerator)
-
-          expect(result).to match_array([
-            { name: 'Jane' }, { name: 'Joe' }
-          ])
-        end
-      end
-    end
-
-    describe '#values_at' do
-      it 'returns a new dataset with rows at given indices' do
-        result = dataset.values_at(1)
-
-        expect(result).to match_array([{ name: 'Joe' }])
-      end
-    end
-  end
-end