rom 0.9.1 → 1.0.0.beta1

data/lib/rom/environment_plugin.rb

@@ -1,17 +0,0 @@
-require 'rom/plugin_base'
-
-module ROM
-  # EnvironmentPlugin is a simple object used to store environment plugin configurations
-  #
-  # @private
-  class EnvironmentPlugin < PluginBase
-    # Apply this plugin to the provided environment
-    #
-    # @param [ROM::Environment] environment
-    #
-    # @api private
-    def apply_to(environment, options = {})
-      mod.apply(environment, options)
-    end
-  end
-end

data/lib/rom/environment_plugins/auto_registration.rb

@@ -1,38 +0,0 @@
-module ROM
-  module EnvironmentPlugins
-    # Automatically registers relations, mappers and commands as they are defined
-    #
-    # For now this plugin is always enabled
-    #
-    # @api public
-    module AutoRegistration
-      # Say "yes" for envs that have this plugin enabled
-      #
-      # By default it says "no" in Environment#auto_registration?
-      #
-      # @api private
-      def auto_registration?
-        true
-      end
-
-      # @api private
-      def self.apply(environment, options = {})
-        environment.extend(AutoRegistration)
-
-        if_proc = options.fetch(:if, ->(*args) { true })
-
-        ROM::Relation.on(:inherited) do |relation|
-          environment.register_relation(relation) if if_proc.call(relation)
-        end
-
-        ROM::Command.on(:inherited) do |command|
-          environment.register_command(command) if if_proc.call(command)
-        end
-
-        ROM::Mapper.on(:inherited) do |mapper|
-          environment.register_mapper(mapper) if if_proc.call(mapper)
-        end
-      end
-    end
-  end
-end

data/lib/rom/repository.rb

@@ -1,16 +0,0 @@
-require 'rom/gateway'
-
-module ROM
-  # Abstract repository class
-  #
-  # This is a transitional placeholder, deprecating the Repository class.
-  #
-  # @api public
-  class Repository < Gateway
-    def self.inherited(_klass)
-      ROM::Deprecations.announce "Inheriting from ROM::Repository is", <<-MSG
-        Please inherit from ROM::Gateway instead.
-      MSG
-    end
-  end
-end

data/lib/rom/setup_dsl/command.rb

@@ -1,36 +0,0 @@
-module ROM
-  # Setup DSL-specific command extensions
-  #
-  # @private
-  class Command
-    # Generate a command subclass
-    #
-    # This is used by Setup#commands DSL and its `define` block
-    #
-    # @api private
-    def self.build_class(name, relation, options = EMPTY_HASH, &block)
-      type = options.fetch(:type) { name }
-      command_type = Inflector.classify(type)
-      adapter = options.fetch(:adapter)
-      parent = adapter_namespace(adapter).const_get(command_type)
-      class_name = generate_class_name(adapter, command_type, relation)
-
-      ClassBuilder.new(name: class_name, parent: parent).call do |klass|
-        klass.register_as(name)
-        klass.relation(relation)
-        klass.class_eval(&block) if block
-      end
-    end
-
-    # Create a command subclass name based on adapter, type and relation
-    #
-    # @api private
-    def self.generate_class_name(adapter, command_type, relation)
-      pieces = ['ROM']
-      pieces << Inflector.classify(adapter)
-      pieces << 'Commands'
-      pieces << "#{command_type}[#{Inflector.classify(relation)}s]"
-      pieces.join('::')
-    end
-  end
-end

data/lib/rom/setup_dsl/mapper.rb

@@ -1,32 +0,0 @@
-module ROM
-  # Setup DSL-specific mapper extensions
-  #
-  # @private
-  class Mapper
-    # Generate a mapper subclass
-    #
-    # This is used by Setup#mappers DSL
-    #
-    # @api private
-    def self.build_class(name, options = EMPTY_HASH, &block)
-      class_name = "ROM::Mapper[#{name}]"
-
-      parent = options[:parent]
-      inherit_header = options.fetch(:inherit_header) { Mapper.inherit_header }
-
-      parent_class =
-        if parent
-          ROM.boot.mapper_classes.detect { |klass| klass.relation == parent }
-        else
-          self
-        end
-
-      ClassBuilder.new(name: class_name, parent: parent_class).call do |klass|
-        klass.relation(name)
-        klass.inherit_header(inherit_header)
-
-        klass.class_eval(&block) if block
-      end
-    end
-  end
-end

data/lib/rom/setup_dsl/relation.rb

@@ -1,30 +0,0 @@
-module ROM
-  # Setup DSL-specific relation extensions
-  #
-  # @private
-  class Relation
-    # Generate a relation subclass
-    #
-    # This is used by Setup#relation DSL
-    #
-    # @api private
-    def self.build_class(name, options = EMPTY_HASH)
-      class_name = "ROM::Relation[#{Inflector.camelize(name)}]"
-      adapter = options.fetch(:adapter)
-
-      ClassBuilder.new(name: class_name, parent: self[adapter]).call do |klass|
-        klass.gateway(options.fetch(:gateway) {
-          if options.key?(:repository)
-          ROM::Deprecations.announce "The :repository key is", <<-MSG
-            Please use `gateway: :#{options.fetch(:repository)}` instead.
-          MSG
-            options.fetch(:repository)
-          else
-            :default
-          end
-        })
-        klass.dataset(name)
-      end
-    end
-  end
-end

data/spec/integration/inline_setup_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-RSpec.describe 'Inline setup' do
-  before do
-    module Test
-      module Dummy
-        class Gateway < ROM::Memory::Gateway
-          def schema
-            [:users, :tasks]
-          end
-        end
-
-        class Relation < ROM::Relation
-          adapter :dummy
-        end
-      end
-    end
-
-    ROM.register_adapter :dummy, Test::Dummy
-  end
-
-  context 'using global env' do
-    it 'auto-registers components' do
-      rom = ROM.setup(:dummy) do
-        relation(:users)
-      end
-
-      users = rom.relation(:users)
-
-      expect(users).to be_kind_of(Test::Dummy::Relation)
-    end
-  end
-
-  context 'using local env' do
-    it 'auto-registers components' do
-      env = ROM::Environment.new
-
-      rom = env.setup(:dummy) do
-        relation(:users)
-      end
-
-      users = rom.relation(:users)
-
-      expect(users).to be_kind_of(Test::Dummy::Relation)
-    end
-  end
-
-  context 'defining a relation with custom dataset name' do
-    it 'registers under provided name and uses custom dataset' do
-      env = ROM::Environment.new
-
-      rom = env.setup(:dummy) do
-        relation(:super_users) do
-          dataset :users
-        end
-      end
-
-      users = rom.relation(:super_users)
-
-      expect(users).to be_kind_of(Test::Dummy::Relation)
-      expect(users.dataset).to be(rom.gateways[:default].dataset(:users))
-    end
-  end
-end

data/spec/unit/rom/repository_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Repository do
-
-  it "warns when inherited from" do
-    expect {
-      Class.new(ROM::Repository)
-    }.to output(/inherit from ROM::Gateway/).to_stderr
-  end
-
-
-end

data/spec/unit/rom/setup_spec.rb

@@ -1,253 +0,0 @@
-require 'spec_helper'
-
-describe ROM::Setup do
-  it 'is configurable' do
-    setup = ROM::Setup.new({})
-
-    setup.configure do |config|
-      config.sql.infer_relations = false
-    end
-
-    expect(setup.config.sql.infer_relations).to be(false)
-    expect(setup.config[:sql][:infer_relations]).to be(false)
-
-    expect(setup.config).to respond_to(:sql)
-    expect(setup.config).to respond_to(:other=)
-
-    setup.config.freeze
-
-    expect(setup.config.other).to be(nil)
-    expect(setup.config.key?(:other)).to be(false)
-    expect(setup.config.key?(:sql)).to be(true)
-  end
-
-  it 'is configurable via settings hash' do
-    setup = ROM.setup(:memory, 'something', infer_schema: false)
-
-    setup.finalize
-
-    expect(setup.config.gateways.default.infer_schema).to be(false)
-
-    setup = ROM.setup(:memory, infer_schema: false)
-
-    setup.finalize
-
-    expect(setup.config.gateways.default.infer_schema).to be(false)
-
-    setup = ROM.setup(default: [:memory, infer_schema: false])
-
-    setup.finalize
-
-    expect(setup.config.gateways.default.infer_schema).to be(false)
-  end
-
-  describe '#finalize' do
-    context 'with gateway that supports schema inferring' do
-      it 'builds relation from inferred schema' do
-        setup = ROM.setup(:memory)
-        repo = setup.default
-        dataset = double('dataset')
-
-        allow(repo).to receive(:schema).and_return([:users])
-        allow(repo).to receive(:dataset).with(:users).and_return(dataset)
-
-        rom = setup.finalize
-
-        expect(rom.relations.users.dataset).to be(dataset)
-      end
-
-      it 'skips inferring a relation when there is a defined one already' do
-        setup = ROM.setup(:memory)
-        repo = setup.default
-        dataset = double('dataset')
-
-        allow(repo).to receive(:schema).and_return([:test_users])
-        allow(repo).to receive(:dataset).with(:test_users).and_return(dataset)
-
-        class Test::Users < ROM::Relation[:memory]; end
-
-        expect { setup.finalize }.not_to raise_error
-
-        rom = setup.env
-
-        expect(rom.relations.test_users).to be_instance_of(Test::Users)
-      end
-
-      it 'skips inferring when it is turned off for the adapter' do
-        setup = ROM.setup(:memory)
-
-        setup.configure { |config| config.gateways.default.infer_relations = false }
-
-        repo = setup.default
-
-        expect(repo).not_to receive(:schema)
-
-        setup.finalize
-      end
-
-      it 'infers configured relations' do
-        setup = ROM.setup(:memory)
-
-        setup.configure do |config|
-          config.gateways.default.inferrable_relations = [:test_tasks]
-        end
-
-        repo = setup.default
-        dataset = double('dataset')
-
-        allow(repo).to receive(:schema).and_return([:test_tasks, :test_users])
-
-        expect(repo).to receive(:dataset).with(:test_tasks).and_return(dataset)
-        expect(repo).to_not receive(:dataset).with(:test_users)
-
-        rom = setup.finalize
-
-        expect(rom.relations.elements.key?(:test_users)).to be(false)
-        expect(rom.relations[:test_tasks]).to be_kind_of(ROM::Memory::Relation)
-        expect(rom.relations[:test_tasks].dataset).to be(dataset)
-      end
-
-      it 'skip inferring blacklisted relations' do
-        setup = ROM.setup(:memory)
-
-        setup.configure do |config|
-          config.gateways.default.not_inferrable_relations = [:test_users]
-        end
-
-        repo = setup.default
-        dataset = double('dataset')
-
-        allow(repo).to receive(:schema).and_return([:test_tasks, :test_users])
-
-        expect(repo).to receive(:dataset).with(:test_tasks).and_return(dataset)
-        expect(repo).to_not receive(:dataset).with(:test_users)
-
-        rom = setup.finalize
-
-        expect(rom.relations.elements.key?(:test_users)).to be(false)
-        expect(rom.relations[:test_tasks]).to be_kind_of(ROM::Memory::Relation)
-        expect(rom.relations[:test_tasks].dataset).to be(dataset)
-      end
-
-      it 'can register multiple relations with same dataset' do
-        setup = ROM.setup(:memory)
-
-        Class.new(ROM::Relation[:memory]) do
-          dataset :fruits
-          register_as :apples
-
-          def apple?
-            true
-          end
-        end
-
-        Class.new(ROM::Relation[:memory]) do
-          dataset :fruits
-          register_as :oranges
-
-          def orange?
-            true
-          end
-        end
-
-        rom = setup.finalize
-
-        expect(rom.relations.apples).to be_apple
-        expect(rom.relations.oranges).to be_orange
-        expect(rom.relations.apples).to_not eq(rom.relations.oranges)
-      end
-
-      it "raises an error when registering relations with the same `register_as`" do
-        setup = ROM.setup(:memory)
-
-        Class.new(ROM::Relation[:memory]) do
-          dataset :guests
-          register_as :users
-        end
-
-        Class.new(ROM::Relation[:memory]) do
-          dataset :admins
-          register_as :users
-        end
-
-        expect { setup.finalize }.to raise_error(
-          ROM::RelationAlreadyDefinedError, /register_as :users/
-        )
-      end
-
-      it 'resets boot to nil' do
-        setup = ROM.setup(:memory)
-
-        allow(setup).to receive(:container).and_raise(StandardError)
-
-        expect { ROM.finalize }.to raise_error(StandardError)
-        expect(ROM.boot).to be(nil)
-      end
-    end
-
-    context 'empty setup' do
-      let(:setup) { ROM::Setup.new({}) }
-      let(:env) { setup.finalize }
-
-      it 'builds empty gateways' do
-        expect(env.gateways).to eql({})
-      end
-
-      it 'builds empty relations' do
-        expect(env.relations).to eql(ROM::RelationRegistry.new)
-      end
-
-      it 'builds empty mappers' do
-        expect(env.mappers).to eql(ROM::Registry.new)
-      end
-
-      it 'builds empty commands' do
-        expect(env.commands).to eql(ROM::Registry.new)
-      end
-    end
-  end
-
-  describe '#method_missing' do
-    it 'returns a gateway if it is defined' do
-      repo = double('repo')
-      setup = ROM::Setup.new(repo: repo)
-
-      expect(setup.repo).to be(repo)
-    end
-
-    it 'raises error if repo is not defined' do
-      setup = ROM::Setup.new({})
-
-      expect { setup.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-  end
-
-  describe '#[]' do
-    it 'returns a gateway if it is defined' do
-      repo = double('repo')
-      setup = ROM::Setup.new(repo: repo)
-
-      expect(setup[:repo]).to be(repo)
-    end
-
-    it 'raises error if repo is not defined' do
-      setup = ROM::Setup.new({})
-
-      expect { setup[:not_here] }.to raise_error(KeyError, /not_here/)
-    end
-  end
-
-  describe 'defining components when adapter was not registered' do
-    it 'raises error when trying to define a relation' do
-      expect {
-        Class.new(ROM::Relation[:not_here])
-      }.to raise_error(ROM::AdapterNotPresentError, /not_here/)
-    end
-
-    it 'raises error when trying to define a command' do
-      expect {
-        Class.new(ROM::Commands::Create[:not_here])
-      }.to raise_error(ROM::AdapterNotPresentError, /not_here/)
-    end
-  end
-end