rom 2.0.2 → 4.2.1

data/spec/integration/relations/registry_dsl_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-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/repositories/extending_relations_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-describe 'Repository' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  before do
-    module ROM
-      module Memory
-        class Relation < ROM::Relation
-          def self.freaking_awesome?
-            true
-          end
-
-          def freaking_cool?
-            true
-          end
-        end
-      end
-    end
-  end
-
-  after do
-    ROM::Memory::Relation.class_eval do
-      undef_method :freaking_cool?
-      class << self
-        undef_method :freaking_awesome?
-      end
-    end
-  end
-
-  shared_examples_for 'extended relation' do
-    it 'can extend relation class' do
-      expect(container.relations.users.class).to be_freaking_awesome
-    end
-
-    it 'can extend relation instance' do
-      expect(container.relations.users).to be_freaking_cool
-    end
-  end
-
-  context 'using DSL' do
-    it_behaves_like 'extended relation' do
-      before do
-        configuration.relation(:users)
-      end
-    end
-  end
-
-  context 'using class definition' do
-    it_behaves_like 'extended relation' do
-      before do
-        configuration.register_relation(Class.new(ROM::Relation[:memory]) { dataset :users })
-      end
-    end
-  end
-end

data/spec/integration/repositories/setting_logger_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-require 'logger'
-
-describe 'Repositories / Setting logger' do
-  let(:logger_class) do
-    Class.new do
-      attr_reader :messages
-
-      def initialize
-        @messages = []
-      end
-
-      def info(msg)
-        @messages << msg
-      end
-    end
-  end
-
-  let(:logger) do
-    logger_class.new
-  end
-
-  it 'sets up a logger for a given gateway' do
-    container = ROM.container(:memory) do |config|
-      config.gateways[:default].use_logger(logger)
-    end
-      
-    container.gateways[:default].logger.info("test")
-
-    expect(logger.messages).to eql(["test"])
-  end
-end

data/spec/integration/setup_spec.rb

@@ -1,160 +0,0 @@
-require 'spec_helper'
-require 'dry-struct'
-
-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
-    it 'sets up registries based on class definitions' do
-      container = 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
-
-      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
-  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')])
-    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
-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,50 +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
-        def execute(tuples, user)
-          super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
-        end
-      end
-    end
-
-    configuration.commands(:tags) do
-      define(:create) do
-        def execute(tuples, task)
-          super(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 @@
-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,52 +0,0 @@
-# encoding: utf-8
-
-# this is needed for guard to work, not sure why :(
-require "bundler"
-Bundler.setup
-
-if ENV['COVERAGE'] == 'true' && RUBY_ENGINE == 'ruby' && RUBY_VERSION='2.3.1'
-  require "simplecov"
-  SimpleCov.start do
-    add_filter '/spec/'
-  end
-end
-
-SPEC_ROOT = root = Pathname(__FILE__).dirname
-
-require 'rom/support/deprecations'
-ROM::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.after do
-    Test.remove_constants
-  end
-
-  config.around do |example|
-    ConstantLeakFinder.find(example)
-  end
-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/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/association_set_spec.rb

@@ -1,23 +0,0 @@
-RSpec.describe ROM::AssociationSet do
-  describe '#try' do
-    it 'returns association when it exists' do
-      assoc = spy(:assoc)
-      assoc_set = ROM::AssociationSet.new(users: assoc)
-
-      assoc_set.try(:users, &:done)
-
-      expect(assoc).to have_received(:done)
-    end
-
-    it 'returns false when assoc is not found' do
-      assoc = spy(:assoc)
-      fallback = spy(:fallback)
-      assoc_set = ROM::AssociationSet.new({})
-
-      assoc_set.try(:users, &:done) or fallback.done
-
-      expect(assoc).to_not have_received(:done)
-      expect(fallback).to have_received(:done)
-    end
-  end
-end