dry-system 0.7.3 → 0.8.0

data/spec/fixtures/test/lib/test/models/book.rb

@@ -1,6 +0,0 @@
-module Test
-  module Models
-    class Book
-    end
-  end
-end

data/spec/fixtures/test/lib/test/models/user.rb

@@ -1,6 +0,0 @@
-module Test
-  module Models
-    class User
-    end
-  end
-end

data/spec/fixtures/test/lib/test/singleton_dep.rb

@@ -1,7 +0,0 @@
-require 'singleton'
-
-module Test
-  class SingletonDep
-    include Singleton
-  end
-end

data/spec/fixtures/test/system/boot/bar.rb

@@ -1,11 +0,0 @@
-Test::Container.namespace(:test) do |container|
-  module Test
-    module Bar
-      # I shall be booted
-    end
-  end
-
-  container.finalize(:bar) do
-    container.register(:bar, 'I was finalized')
-  end
-end

data/spec/fixtures/test/system/boot/client.rb

@@ -1,7 +0,0 @@
-Test::Container.finalize(:client) do |container|
-  use :logger
-
-  Client = Struct.new(:logger)
-
-  container.register(:client, Client.new(logger))
-end

data/spec/fixtures/test/system/boot/db.rb

@@ -1 +0,0 @@
-# this is just for Container.finalize spec, actual finalization code is in the test

data/spec/fixtures/test/system/boot/hell.rb

@@ -1,3 +0,0 @@
-Test::Container.finalize :heaven do |container|
-  container.register('heaven', 'string')
-end

data/spec/fixtures/test/system/boot/logger.rb

@@ -1,5 +0,0 @@
-Test::Container.finalize(:logger) do |container|
-  require 'logger'
-
-  container.register(:logger, Logger.new(container.root.join('log/test.log')))
-end

data/spec/fixtures/umbrella/system/boot/db.rb

@@ -1,10 +0,0 @@
-Test::Umbrella.namespace(:db) do |container|
-  module Db
-    class Repo
-    end
-  end
-
-  container.finalize(:db) do
-    container.register(:repo, Db::Repo.new)
-  end
-end

data/spec/integration/boot_spec.rb

@@ -1,18 +0,0 @@
-RSpec.describe 'boot files' do
-  subject(:system) { Test::Container }
-
-  before do
-    class Test::Container < Dry::System::Container
-      configure do |config|
-        config.root = SPEC_ROOT.join('fixtures/test').realpath
-      end
-    end
-  end
-
-  it 'auto-boots dependency of a bootable component' do
-    system.start(:client)
-
-    expect(system[:client]).to be_a(Client)
-    expect(system[:client].logger).to be_a(Logger)
-  end
-end

data/spec/integration/container/lazy_loading/manual_registration_spec.rb

@@ -1,18 +0,0 @@
-RSpec.describe 'Lazy-loading manual registration files' do
-  before do
-    module Test
-      class Container < Dry::System::Container
-        configure do |config|
-          config.root = SPEC_ROOT.join('fixtures/manual_registration').realpath
-        end
-
-        load_paths!('lib')
-      end
-    end
-  end
-
-  it 'loads a manual registration file if the component could not be found' do
-    expect(Test::Container['foo.special']).to be_a(Test::Foo)
-    expect(Test::Container['foo.special'].name).to eq "special"
-  end
-end

data/spec/integration/import_spec.rb

@@ -1,81 +0,0 @@
-require 'dry/system/stubs'
-
-RSpec.describe 'Lazy-booting external deps' do
-  before do
-    module Test
-      class Umbrella < Dry::System::Container
-        configure do |config|
-          config.name = :core
-          config.root = SPEC_ROOT.join('fixtures/umbrella').realpath
-        end
-      end
-
-      class App < Dry::System::Container
-        configure do |config|
-          config.name = :main
-        end
-      end
-    end
-  end
-
-  shared_examples_for 'lazy booted dependency' do
-    it 'lazy boots an external dep provided by top-level container' do
-      expect(user_repo.repo).to be_instance_of(Db::Repo)
-    end
-
-    it 'loads an external dep during finalization' do
-      system.finalize!
-      expect(user_repo.repo).to be_instance_of(Db::Repo)
-    end
-  end
-
-  context 'when top-level container provides the dependency' do
-    let(:user_repo) do
-      Class.new { include Test::Import['db.repo'] }.new
-    end
-
-    let(:system) { Test::Umbrella }
-
-    before do
-      module Test
-        Umbrella.import(main: App)
-        Import = Umbrella.injector
-      end
-    end
-
-    it_behaves_like 'lazy booted dependency'
-
-    context 'when stubs are enabled' do
-      before do
-        system.enable_stubs!
-      end
-
-      it_behaves_like 'lazy booted dependency'
-    end
-  end
-
-  context 'when top-level container provides the dependency through import' do
-    let(:user_repo) do
-      Class.new { include Test::Import['core.db.repo'] }.new
-    end
-
-    let(:system) { Test::App }
-
-    before do
-      module Test
-        App.import(core: Umbrella)
-        Import = App.injector
-      end
-    end
-
-    it_behaves_like 'lazy booted dependency'
-
-    context 'when stubs are enabled' do
-      before do
-        system.enable_stubs!
-      end
-
-      it_behaves_like 'lazy booted dependency'
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,48 +0,0 @@
-# encoding: utf-8
-
-if RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '2.3'
-  require 'simplecov'
-  SimpleCov.start
-end
-
-begin
-  require 'byebug'
-rescue LoadError; end
-
-SPEC_ROOT = Pathname(__FILE__).dirname
-
-Dir[SPEC_ROOT.join('support/*.rb').to_s].each { |f| require f }
-Dir[SPEC_ROOT.join('shared/*.rb').to_s].each { |f| require f }
-
-require 'dry/system/container'
-require 'dry/system/stubs'
-
-module TestNamespace
-  def remove_constants
-    constants.each do |name|
-      remove_const(name)
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-
-  config.before do
-    @load_paths = $LOAD_PATH.dup
-    @loaded_features = $LOADED_FEATURES.dup
-    Object.const_set(:Test, Module.new { |m| m.extend(TestNamespace) })
-  end
-
-  config.after do
-    ($LOAD_PATH - @load_paths).each do |path|
-      $LOAD_PATH.delete(path)
-    end
-    ($LOADED_FEATURES - @loaded_features).each do |file|
-      $LOADED_FEATURES.delete(file)
-    end
-
-    Test.remove_constants
-    Object.send(:remove_const, :Test)
-  end
-end

data/spec/unit/auto_registrar/configuration_spec.rb

@@ -1,26 +0,0 @@
-require 'dry/system/auto_registrar/configuration'
-
-RSpec.describe Dry::System::AutoRegistrar::Configuration do
-  subject(:auto_registration_conf) { Dry::System::AutoRegistrar::Configuration.new }
-
-  describe "deafult values" do
-    it "will setup exclude default proc" do
-      expect(subject.exclude.(8)).to eq false
-    end
-
-    it "will setup instance default proc" do
-      component = double("component")
-      expect(component).to receive(:instance)
-      subject.instance.(component)
-    end
-  end
-
-  describe "add custom proc object to configuration" do
-    it "execute proc that was previously save" do
-      proc = Proc.new { |value| value + 1 }
-      subject.instance(&proc)
-      result = subject.instance.(5)
-      expect(result).to eq 6
-    end
-  end
-end

data/spec/unit/component_spec.rb

@@ -1,121 +0,0 @@
-require 'dry/system/component'
-
-RSpec.describe Dry::System::Component do
-  subject(:component) { Dry::System::Component.new(name) }
-
-  describe '.new' do
-    it 'caches components' do
-      create = -> {
-        Dry::System::Component.new('foo.bar', namespace: 'foo')
-      }
-
-      expect(create.()).to be(create.())
-    end
-
-    it 'allows to have the same key multiple times in the identifier/path' do
-      component = Dry::System::Component.new('foo.bar.foo', namespace: 'foo')
-      expect(component.identifier).to eql('bar.foo')
-    end
-
-    it 'removes only the initial part from the identifier/path' do
-      component = Dry::System::Component.new('foo.bar.foo.user.foo.bar', namespace: 'foo.bar.foo')
-      expect(component.identifier).to eql('user.foo.bar')
-    end
-
-    it 'raises when namepsace is not present  in path' do
-      expect { Dry::System::Component.new('foo.bar.foo', namespace: 'baz') }
-        .to raise_error(Dry::System::InvalidComponentError, /baz/)
-    end
-  end
-
-  context 'when name is a symbol' do
-    let(:name) { :foo }
-
-    describe '#identifier' do
-      it 'returns qualified identifier' do
-        expect(component.identifier).to eql('foo')
-      end
-    end
-
-    describe '#namespace' do
-      it 'returns configured namespace' do
-        expect(component.namespace).to be(nil)
-      end
-    end
-
-    describe '#root_key' do
-      it 'returns component key' do
-        expect(component.root_key).to be(:foo)
-      end
-    end
-
-    describe '#instance' do
-      it 'builds an instance' do
-        class Foo; end
-        expect(component.instance).to be_instance_of(Foo)
-        Object.send(:remove_const, :Foo)
-      end
-    end
-  end
-
-  shared_examples_for 'a valid component' do
-    describe '#identifier' do
-      it 'returns qualified identifier' do
-        expect(component.identifier).to eql('test.foo')
-      end
-    end
-
-    describe '#file' do
-      it 'returns relative path to the component file' do
-        expect(component.file).to eql('test/foo.rb')
-      end
-    end
-
-    describe '#namespace' do
-      it 'returns configured namespace' do
-        expect(component.namespace).to be(nil)
-      end
-    end
-
-    describe '#namespaced' do
-      it 'returns a namespaced component' do
-        namespaced = component.namespaced(:test)
-
-        expect(namespaced.identifier).to eql('foo')
-        expect(namespaced.path).to eql('test/foo')
-        expect(namespaced.file).to eql('test/foo.rb')
-      end
-    end
-
-    describe '#root_key' do
-      it 'returns component key' do
-        expect(component.root_key).to be(:test)
-      end
-    end
-
-    describe '#instance' do
-      it 'builds an instance' do
-        module Test; class Foo; end; end
-        expect(component.instance).to be_instance_of(Test::Foo)
-      end
-    end
-  end
-
-  context 'when name is a path' do
-    let(:name) { 'test/foo' }
-
-    it_behaves_like 'a valid component'
-  end
-
-  context 'when name is a qualified string identifier' do
-    let(:name) { 'test.foo' }
-
-    it_behaves_like 'a valid component'
-  end
-
-  context 'when name is a qualified symbol identifier' do
-    let(:name) { :'test.foo' }
-
-    it_behaves_like 'a valid component'
-  end
-end

data/spec/unit/container/auto_register_spec.rb

@@ -1,113 +0,0 @@
-require 'dry/system/container'
-
-RSpec.describe Dry::System::Container, '.auto_register!' do
-  context 'standard loader' do
-    before do
-      class Test::Container < Dry::System::Container
-        configure do |config|
-          config.root = SPEC_ROOT.join('fixtures').realpath
-        end
-
-        load_paths!('components')
-        auto_register!('components')
-      end
-    end
-
-    it { expect(Test::Container['foo']).to be_an_instance_of(Foo) }
-    it { expect(Test::Container['bar']).to be_an_instance_of(Bar) }
-    it { expect(Test::Container['bar.baz']).to be_an_instance_of(Bar::Baz) }
-
-    it "doesn't register files with inline option 'auto_register: false'" do
-      expect(Test::Container.key?('no_register')).to eql false
-    end
-  end
-
-  context 'with custom configuration block' do
-    before do
-      class Test::Container < Dry::System::Container
-        configure do |config|
-          config.root = SPEC_ROOT.join('fixtures').realpath
-        end
-
-        load_paths!('components')
-      end
-    end
-
-    it 'exclude specific components' do
-      Test::Container.auto_register!('components') do |config|
-        config.instance do |component|
-          component.identifier
-        end
-
-        config.exclude do |component|
-          component.path =~ /bar/
-        end
-      end
-
-      expect(Test::Container['foo']).to eql('foo')
-
-      expect(Test::Container.key?('bar')).to eql false
-      expect(Test::Container.key?('bar.baz')).to eql false
-    end
-  end
-
-  context 'standard loader with a default namespace configured' do
-    before do
-      class Test::Container < Dry::System::Container
-        configure do |config|
-          config.root = SPEC_ROOT.join('fixtures').realpath
-          config.default_namespace = 'namespaced'
-        end
-
-        load_paths!('namespaced_components')
-        auto_register!('namespaced_components')
-      end
-    end
-
-    specify { expect(Test::Container['bar']).to be_a(Namespaced::Bar) }
-    specify { expect(Test::Container['bar'].foo).to be_a(Namespaced::Foo) }
-    specify { expect(Test::Container['foo']).to be_a(Namespaced::Foo) }
-  end
-
-  context 'standard loader with a default namespace with multiple level' do
-    before do
-      class Test::Container < Dry::System::Container
-        configure do |config|
-          config.root = SPEC_ROOT.join('fixtures').realpath
-          config.default_namespace = 'multiple.level'
-        end
-
-        load_paths!('multiple_namespaced_components')
-        auto_register!('multiple_namespaced_components')
-      end
-    end
-
-    specify { expect(Test::Container['baz']).to be_a(Multiple::Level::Baz) }
-    specify { expect(Test::Container['foz']).to be_a(Multiple::Level::Foz) }
-  end
-
-  context 'with a custom loader' do
-    before do
-      class Test::Loader < Dry::System::Loader
-        def call(*args)
-          constant.respond_to?(:call) ? constant : constant.new(*args)
-        end
-      end
-
-      class Test::Container < Dry::System::Container
-        configure do |config|
-          config.root = SPEC_ROOT.join('fixtures').realpath
-          config.loader = ::Test::Loader
-        end
-
-        load_paths!('components')
-        auto_register!('components')
-      end
-    end
-
-    it { expect(Test::Container['foo']).to be_an_instance_of(Foo) }
-    it { expect(Test::Container['bar']).to eq(Bar) }
-    it { expect(Test::Container['bar'].call).to eq("Welcome to my Moe's Tavern!") }
-    it { expect(Test::Container['bar.baz']).to be_an_instance_of(Bar::Baz) }
-  end
-end