dry-container 0.7.2 → 0.8.0

data/.codeclimate.yml

@@ -1,32 +0,0 @@
-engines:
-  rubocop:
-    enabled: true
-    checks:
-      Rubocop/Metrics/LineLength:
-        enabled: true
-        max: 120
-      Rubocop/Style/Documentation:
-        enabled: false
-      Rubocop/Lint/HandleExceptions:
-        enabled: true
-        exclude:
-          - rakelib/*.rake
-      Rubocop/Lint/NestedMethodDefinition:
-        enabled: true
-        exclude:
-          - lib/dry/container/mixin.rb
-      Rubocop/Metrics/MethodLength:
-        enabled: true
-        exclude:
-          - lib/dry/container/mixin.rb
-      Rubocop/Style/FileName:
-        enabled: true
-        exclude:
-          - lib/dry-container.rb
-
-ratings:
-  paths:
-    - lib/**/*.rb
-  exclude_paths:
-    - spec/**/*
-    - examples/**/*

data/.gitignore

@@ -1,10 +0,0 @@
-.DS_Store
-coverage
-/.bundle
-vendor/bundle
-bin/
-tmp/
-.idea/
-Gemfile.lock
-spec/examples.txt
-pkg/

data/.rspec

@@ -1,2 +0,0 @@
---color
---require ./spec/spec_helper.rb

data/.rubocop.yml

@@ -1,24 +0,0 @@
-# Generated by `rubocop --auto-gen-config`
-inherit_from: .rubocop_todo.yml
-
-Metrics/LineLength:
-  Max: 120
-
-Style/Documentation:
-  Enabled: false
-
-Lint/HandleExceptions:
-  Exclude:
-    - rakelib/*.rake
-
-Lint/NestedMethodDefinition:
-  Exclude:
-    - lib/dry/container/mixin.rb
-
-Metrics/MethodLength:
-  Exclude:
-    - lib/dry/container/mixin.rb
-
-Style/FileName:
-  Exclude:
-    - lib/dry-container.rb

data/.rubocop_todo.yml

@@ -1,6 +0,0 @@
-# This configuration was generated by `rubocop --auto-gen-config`
-# on 2015-06-16 19:51:19 +0100 using RuboCop version 0.32.0.
-# The point is for the user to remove these configuration records
-# one by one as the offenses are removed from the code base.
-# Note that changes in the inspected code, or installation of new
-# versions of RuboCop, may require this file to be generated again.

data/.travis.yml

@@ -1,30 +0,0 @@
-language: ruby
-dist: trusty
-sudo: required
-cache: bundler
-bundler_args: --without console
-script:
-  - bundle exec rake spec
-after_success:
-  - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
-rvm:
-  - 2.4.6
-  - 2.5.5
-  - 2.6.3
-  - jruby-9.2.7.0
-  - truffleruby
-matrix:
-  allow_failures:
-    - rvm: truffleruby
-env:
-  global:
-    - JRUBY_OPTS='--dev -J-Xmx1024M'
-    - COVERAGE='true'
-notifications:
-  email: false
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/19098b4253a72c9796db
-    on_success: change  # options: [always|never|change] default: always
-    on_failure: always  # options: [always|never|change] default: always
-    on_start: false     # default: false

data/CONTRIBUTING.md

@@ -1,29 +0,0 @@
-# Issue Guidelines
-
-## Reporting bugs
-
-If you found a bug, report an issue and describe what's the expected behavior versus what actually happens. If the bug causes a crash, attach a full backtrace. If possible, a reproduction script showing the problem is highly appreciated.
-
-## Reporting feature requests
-
-Report a feature request **only after discussing it first on [discourse.dry-rb.org](http://discourse.dry-rb.org)** where it was accepted. Please provide a concise description of the feature, don't link to a discussion thread, and instead summarize what was discussed.
-
-## Reporting questions, support requests, ideas, concerns etc.
-
-**PLEASE DON'T** - use [discourse.dry-rb.org](http://discourse.dry-rb.org) instead.
-
-# Pull Request Guidelines
-
-A Pull Request will only be accepted if it addresses a specific issue that was reported previously, or fixes typos, mistakes in documentation etc.
-
-Other requirements:
-
-1) Do not open a pull request if you can't provide tests along with it. If you have problems writing tests, ask for help in the related issue.
-2) Follow the style conventions of the surrounding code. In most cases, this is standard ruby style.
-3) Add API documentation if it's a new feature
-4) Update API documentation if it changes an existing feature
-5) Bonus points for sending a PR to [github.com/dry-rb/dry-rb.org](github.com/dry-rb/dry-rb.org) which updates user documentation and guides
-
-# Asking for help
-
-If these guidelines aren't helpful, and you're stuck, please post a message on [[discourse.dry-rb.org](http://discourse.dry-rb.org).

data/Gemfile

@@ -1,19 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-group :test do
-  platforms :mri do
-    gem 'codeclimate-test-reporter', require: false
-    gem 'simplecov', require: false
-  end
-end
-
-group :tools do
-  gem 'rubocop'
-  gem 'guard'
-  gem 'guard-rspec'
-  gem 'guard-rubocop'
-  gem 'listen', '3.0.6'
-  gem 'pry-byebug', platform: :mri
-end

data/Rakefile

@@ -1,12 +0,0 @@
-#!/usr/bin/env rake
-require 'bundler/gem_tasks'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
-
-require 'rspec/core'
-require 'rspec/core/rake_task'
-
-task default: :spec
-
-desc 'Run all specs in spec directory'
-RSpec::Core::RakeTask.new(:spec)

data/rakelib/rubocop.rake

@@ -1,18 +0,0 @@
-begin
-  require 'rubocop/rake_task'
-
-  Rake::Task[:default].enhance [:rubocop]
-
-  RuboCop::RakeTask.new do |task|
-    task.options << '--display-cop-names'
-  end
-
-  namespace :rubocop do
-    desc 'Generate a configuration file acting as a TODO list.'
-    task :auto_gen_config do
-      exec 'bundle exec rubocop --auto-gen-config'
-    end
-  end
-
-rescue LoadError
-end

data/spec/integration/container_spec.rb

@@ -1,18 +0,0 @@
-RSpec.describe Dry::Container do
-  let(:klass) { Dry::Container }
-  let(:container) { klass.new }
-
-  it_behaves_like 'a container'
-
-  describe 'inheritance' do
-    it 'sets up a container for a child class' do
-      parent = Class.new { extend Dry::Container::Mixin }
-      child = Class.new(parent)
-
-      parent.register(:foo, 'foo')
-      child.register(:foo, 'foo')
-
-      expect(parent[:foo]).to_not be(child[:foo])
-    end
-  end
-end

data/spec/integration/mixin_spec.rb

@@ -1,32 +0,0 @@
-RSpec.describe Dry::Container::Mixin do
-  describe 'extended' do
-    let(:klass) do
-      Class.new { extend Dry::Container::Mixin }
-    end
-    let(:container) { klass }
-
-    it_behaves_like 'a container'
-  end
-
-  describe 'included' do
-    let(:klass) do
-      Class.new { include Dry::Container::Mixin }
-    end
-    let(:container) { klass.new }
-
-    it_behaves_like 'a container'
-
-    context 'into a class with a custom .initialize method' do
-      let(:klass) do
-        Class.new do
-          include Dry::Container::Mixin
-          def initialize; end
-        end
-      end
-
-      it 'does not fail on missing member variable' do
-        expect { container.register :key, -> {} }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,104 +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
-
-begin
-  require 'pry-byebug'
-rescue LoadError
-end
-
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    #     be_bigger_than(2).and_smaller_than(4).description
-    #     # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #     # => "be bigger than 2"
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
-    mocks.verify_partial_doubles = true
-  end
-
-  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
-  # have no way to turn it off -- the option exists only for backwards
-  # compatibility in RSpec 3). It causes shared context metadata to be
-  # inherited by the metadata hash of host groups and examples, rather than
-  # triggering implicit auto-inclusion in groups with matching metadata.
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-
-  # This allows you to limit a spec run to individual examples or groups
-  # you care about by tagging them with `:focus` metadata. When nothing
-  # is tagged with `:focus`, all examples get run. RSpec also provides
-  # aliases for `it`, `describe`, and `context` that include `:focus`
-  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
-  config.filter_run_when_matching :focus
-
-  # Allows RSpec to persist some state between runs in order to support
-  # the `--only-failures` and `--next-failure` CLI options. We recommend
-  # you configure your source control system to ignore this file.
-  config.example_status_persistence_file_path = 'spec/examples.txt'
-
-  # Limits the available syntax to the non-monkey patched syntax that is
-  # recommended. For more details, see:
-  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
-  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
-  config.disable_monkey_patching!
-
-  # This setting enables warnings. It's recommended, but in some cases may
-  # be too noisy due to issues in dependencies.
-  config.warnings = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
-    config.default_formatter = 'doc'
-  end
-
-  # Print the n slowest examples and example groups at the
-  # end of the spec run, to help surface which specs are running
-  # particularly slow.
-  config.profile_examples = 3
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-end
-
-require 'dry/container'
-require 'dry/container/stub'
-
-Dir[Pathname(__FILE__).dirname.join('support/**/*.rb').to_s].each do |file|
-  require file
-end

data/spec/support/shared_examples/container.rb

@@ -1,664 +0,0 @@
-RSpec.shared_examples 'a container' do
-  describe 'configuration' do
-    describe 'registry' do
-      describe 'default' do
-        it { expect(klass.config.registry).to be_a(Dry::Container::Registry) }
-      end
-
-      describe 'custom' do
-        let(:custom_registry) { double('Registry') }
-        let(:key) { :key }
-        let(:item) { :item }
-        let(:options) { {} }
-
-        before do
-          klass.configure do |config|
-            config.registry = custom_registry
-          end
-
-          allow(custom_registry).to receive(:call)
-        end
-
-        after do
-          # HACK: Have to reset the configuration so that it doesn't
-          # interfere with other specs
-          klass.configure do |config|
-            config.registry = Dry::Container::Registry.new
-          end
-        end
-
-        subject! { container.register(key, item, options) }
-
-        it do
-          expect(custom_registry).to have_received(:call).with(
-            container._container,
-            key,
-            item,
-            options
-          )
-        end
-      end
-    end
-
-    describe 'resolver' do
-      describe 'default' do
-        it { expect(klass.config.resolver).to be_a(Dry::Container::Resolver) }
-      end
-
-      describe 'custom' do
-        let(:custom_resolver) { double('Resolver') }
-        let(:item) { double('Item') }
-        let(:key) { :key }
-
-        before do
-          klass.configure do |config|
-            config.resolver = custom_resolver
-          end
-
-          allow(custom_resolver).to receive(:call).and_return(item)
-        end
-
-        after do
-          # HACK: Have to reset the configuration so that it doesn't
-          # interfere with other specs
-          klass.configure do |config|
-            config.resolver = Dry::Container::Resolver.new
-          end
-        end
-
-        subject! { container.resolve(key) }
-
-        it { expect(custom_resolver).to have_received(:call).with(container._container, key) }
-        it { is_expected.to eq(item) }
-      end
-    end
-
-    describe 'namespace_separator' do
-      describe 'default' do
-        it { expect(klass.config.namespace_separator).to eq('.') }
-      end
-
-      describe 'custom' do
-        let(:custom_registry) { double('Registry') }
-        let(:key) { 'key' }
-        let(:namespace_separator) { '-' }
-        let(:namespace) { 'one' }
-
-        before do
-          klass.configure do |config|
-            config.namespace_separator = namespace_separator
-          end
-
-          container.namespace(namespace) do
-            register('key', 'item')
-          end
-        end
-
-        after do
-          # HACK: Have to reset the configuration so that it doesn't
-          # interfere with other specs
-          klass.configure do |config|
-            config.namespace_separator = '.'
-          end
-        end
-
-        subject! { container.resolve([namespace, key].join(namespace_separator)) }
-
-        it { is_expected.to eq('item') }
-      end
-    end
-  end
-
-  context 'with default configuration' do
-    describe 'registering a block' do
-      context 'without options' do
-        context 'without arguments' do
-          it 'registers and resolves an object' do
-            container.register(:item) { 'item' }
-
-            expect(container.keys).to eq(['item'])
-            expect(container.key?(:item)).to be true
-            expect(container.resolve(:item)).to eq('item')
-          end
-        end
-
-        context 'with arguments' do
-          it 'registers and resolves a proc' do
-            container.register(:item) { |item| item }
-
-            expect(container.resolve(:item).call('item')).to eq('item')
-          end
-
-          it 'does not call a proc on resolving if one accepts an arbitrary number of keyword arguments' do
-            container.register(:item) { |*| 'item' }
-
-            expect(container.resolve(:item)).to be_a_kind_of Proc
-            expect(container.resolve(:item).call).to eq('item')
-          end
-        end
-      end
-
-      context 'with option call: false' do
-        it 'registers and resolves a proc' do
-          container.register(:item, call: false) { 'item' }
-
-          expect(container.keys).to eq(['item'])
-          expect(container.key?(:item)).to be true
-          expect(container.resolve(:item).call).to eq('item')
-          expect(container[:item].call).to eq('item')
-        end
-      end
-    end
-
-    describe 'registering a proc' do
-      context 'without options' do
-        context 'without arguments' do
-          it 'registers and resolves an object' do
-            container.register(:item, proc { 'item' })
-
-            expect(container.keys).to eq(['item'])
-            expect(container.key?(:item)).to be true
-            expect(container.resolve(:item)).to eq('item')
-            expect(container[:item]).to eq('item')
-          end
-        end
-
-        context 'with arguments' do
-          it 'registers and resolves a proc' do
-            container.register(:item, proc { |item| item })
-
-            expect(container.keys).to eq(['item'])
-            expect(container.key?(:item)).to be true
-            expect(container.resolve(:item).call('item')).to eq('item')
-            expect(container[:item].call('item')).to eq('item')
-          end
-        end
-      end
-
-      context 'with option call: false' do
-        it 'registers and resolves a proc' do
-          container.register(:item, proc { 'item' }, call: false)
-
-          expect(container.keys).to eq(['item'])
-          expect(container.key?(:item)).to be true
-          expect(container.resolve(:item).call).to eq('item')
-          expect(container[:item].call).to eq('item')
-        end
-      end
-
-      context 'with option memoize: true' do
-        it 'registers and resolves a proc' do
-          container.register(:item, proc { 'item' }, memoize: true)
-
-          expect(container[:item]).to be container[:item]
-          expect(container.keys).to eq(['item'])
-          expect(container.key?(:item)).to be true
-          expect(container.resolve(:item)).to eq('item')
-          expect(container[:item]).to eq('item')
-        end
-
-        it 'only resolves the proc once' do
-          resolved_times = 0
-
-          container.register(:item, proc { resolved_times += 1 }, memoize: true)
-
-          expect(container.resolve(:item)).to be 1
-          expect(container.resolve(:item)).to be 1
-        end
-
-        context 'when receiving something other than a proc' do
-          it do
-            expect { container.register(:item, 'Hello!', memoize: true) }.to raise_error(Dry::Container::Error)
-          end
-        end
-      end
-    end
-
-    describe 'registering an object' do
-      context 'without options' do
-        it 'registers and resolves the object' do
-          item = 'item'
-          container.register(:item, item)
-
-          expect(container.keys).to eq(['item'])
-          expect(container.key?(:item)).to be true
-          expect(container.resolve(:item)).to be(item)
-          expect(container[:item]).to be(item)
-        end
-      end
-
-      context 'with option call: false' do
-        it 'registers and resolves an object' do
-          item = -> { 'test' }
-          container.register(:item, item, call: false)
-
-          expect(container.keys).to eq(['item'])
-          expect(container.key?(:item)).to be true
-          expect(container.resolve(:item)).to eq(item)
-          expect(container[:item]).to eq(item)
-        end
-      end
-    end
-
-    describe 'registering with the same key multiple times' do
-      it do
-        container.register(:item, proc { 'item' })
-
-        expect { container.register(:item, proc { 'item' }) }.to raise_error(Dry::Container::Error)
-      end
-    end
-
-    describe 'resolving with a key that has not been registered' do
-      it do
-        expect(container.key?(:item)).to be false
-        expect { container.resolve(:item) }.to raise_error(Dry::Container::Error)
-      end
-    end
-
-    describe 'mixing Strings and Symbols' do
-      it do
-        container.register(:item, 'item')
-        expect(container.resolve('item')).to eql('item')
-      end
-    end
-
-    describe '#merge' do
-      let(:key) { :key }
-      let(:other) { Dry::Container.new }
-
-      before do
-        other.register(key) { :item }
-      end
-
-      context 'without namespace argument' do
-        subject! { container.merge(other) }
-
-        it { expect(container.resolve(key)).to be(:item) }
-        it { expect(container[key]).to be(:item) }
-      end
-
-      context 'with namespace argument' do
-        subject! { container.merge(other, namespace: namespace) }
-
-        context 'when namespace is nil' do
-          let(:namespace) { nil }
-
-          it { expect(container.resolve(key)).to be(:item) }
-          it { expect(container[key]).to be(:item) }
-        end
-
-        context 'when namespace is not nil' do
-          let(:namespace) { 'namespace' }
-
-          it { expect(container.resolve("#{namespace}.#{key}")).to be(:item) }
-          it { expect(container["#{namespace}.#{key}"]).to be(:item) }
-        end
-      end
-    end
-
-    describe '#key?' do
-      let(:key) { :key }
-
-      before do
-        container.register(key) { :item }
-      end
-
-      subject! { container.key?(resolve_key) }
-
-      context 'when key exists in container' do
-        let(:resolve_key) { key }
-
-        it { is_expected.to be true }
-      end
-
-      context 'when key does not exist in container' do
-        let(:resolve_key) { :random }
-
-        it { is_expected.to be false }
-      end
-    end
-
-    describe '#keys' do
-      let(:keys) { [:key_1, :key_2] }
-      let(:expected_keys) { ['key_1', 'key_2'] }
-
-      before do
-        keys.each do |key|
-          container.register(key) { :item }
-        end
-      end
-
-      subject! { container.keys }
-
-      it 'returns stringified versions of all registered keys' do
-        is_expected.to match_array(expected_keys)
-      end
-    end
-
-    describe '#each_key' do
-      let(:keys) { [:key_1, :key_2] }
-      let(:expected_keys) { ['key_1', 'key_2'] }
-      let!(:yielded_keys) { [] }
-
-      before do
-        keys.each do |key|
-          container.register(key) { :item }
-        end
-      end
-
-      subject! do
-        container.each_key { |key| yielded_keys << key }
-      end
-
-      it 'yields stringified versions of all registered keys to the block' do
-        expect(yielded_keys).to match_array(expected_keys)
-      end
-
-      it 'returns the container' do
-        is_expected.to eq(container)
-      end
-    end
-
-    describe '#each' do
-      let(:keys) { [:key_1, :key_2] }
-      let(:expected_key_value_pairs) { [['key_1', 'value_for_key_1'], ['key_2', 'value_for_key_2']] }
-      let!(:yielded_key_value_pairs) { [] }
-
-      before do
-        keys.each do |key|
-          container.register(key) { "value_for_#{key}" }
-        end
-      end
-
-      subject! do
-        container.each { |key, value| yielded_key_value_pairs << [key, value] }
-      end
-
-      it 'yields stringified versions of all registered keys to the block' do
-        expect(yielded_key_value_pairs).to match_array(expected_key_value_pairs)
-      end
-
-      it 'returns the container' do
-        is_expected.to eq(expected_key_value_pairs)
-      end
-    end
-
-    describe '#decorate' do
-      require 'delegate'
-
-      let(:key) { :key }
-      let(:decorated_class_spy) { spy(:decorated_class_spy) }
-      let(:decorated_class) { Class.new }
-
-      context 'for callable item' do
-        before do
-          allow(decorated_class_spy).to receive(:new) { decorated_class.new }
-          container.register(key, memoize: memoize) { decorated_class_spy.new }
-          container.decorate(key, with: SimpleDelegator)
-        end
-
-        context 'memoize false' do
-          let(:memoize) { false }
-
-          it 'does not call the block until the key is resolved' do
-            expect(decorated_class_spy).not_to have_received(:new)
-            container.resolve(key)
-            expect(decorated_class_spy).to have_received(:new)
-          end
-
-          specify do
-            expect(container[key]).to be_instance_of(SimpleDelegator)
-            expect(container[key].__getobj__).to be_instance_of(decorated_class)
-            expect(container[key]).not_to be(container[key])
-            expect(container[key].__getobj__).not_to be(container[key].__getobj__)
-          end
-        end
-
-        context 'memoize true' do
-          let(:memoize) { true }
-
-          specify do
-            expect(container[key]).to be_instance_of(SimpleDelegator)
-            expect(container[key].__getobj__).to be_instance_of(decorated_class)
-            expect(container[key]).to be(container[key])
-          end
-        end
-      end
-
-      context 'for not callable item' do
-        describe 'wrapping' do
-          before do
-            container.register(key, call: false) { "value" }
-            container.decorate(key, with: SimpleDelegator)
-          end
-
-          it 'expected to be an instance of SimpleDelegator' do
-            expect(container.resolve(key)).to be_instance_of(SimpleDelegator)
-            expect(container.resolve(key).__getobj__.call).to eql("value")
-          end
-        end
-
-        describe 'memoization' do
-          before do
-            @called = 0
-            container.register(key, 'value')
-
-            container.decorate(key) do |value|
-              @called += 1
-              "<#{value}>"
-            end
-          end
-
-          it 'decorates static value only once' do
-            expect(container.resolve(key)).to eql('<value>')
-            expect(container.resolve(key)).to eql('<value>')
-            expect(@called).to be(1)
-          end
-        end
-      end
-
-      context 'with an instance as a decorator' do
-        let(:decorator) do
-          double.tap do |decorator|
-            allow(decorator).to receive(:call) { |input| "decorated #{input}" }
-          end
-        end
-
-        before do
-          container.register(key) { "value" }
-          container.decorate(key, with: decorator)
-        end
-
-        it 'expected to pass original value to decorator#call method' do
-          expect(container.resolve(key)).to eq("decorated value")
-        end
-      end
-    end
-
-    describe 'namespace' do
-      context 'when block does not take arguments' do
-        before do
-          container.namespace('one') do
-            register('two', 2)
-          end
-        end
-
-        subject! { container.resolve('one.two') }
-
-        it 'registers items under the given namespace' do
-          is_expected.to eq(2)
-        end
-      end
-
-      context 'when block takes arguments' do
-        before do
-          container.namespace('one') do |c|
-            c.register('two', 2)
-          end
-        end
-
-        subject! { container.resolve('one.two') }
-
-        it 'registers items under the given namespace' do
-          is_expected.to eq(2)
-        end
-      end
-
-      context 'with nesting' do
-        before do
-          container.namespace('one') do
-            namespace('two') do
-              register('three', 3)
-            end
-          end
-        end
-
-        subject! { container.resolve('one.two.three') }
-
-        it 'registers items under the given namespaces' do
-          is_expected.to eq(3)
-        end
-      end
-
-      context 'with nesting and when block takes arguments' do
-        before do
-          container.namespace('one') do |c|
-            c.register('two', 2)
-            c.register('three', c.resolve('two'))
-          end
-        end
-
-        subject! { container.resolve('one.three') }
-
-        it 'resolves items relative to the namespace' do
-          is_expected.to eq(2)
-        end
-      end
-    end
-
-    describe 'import' do
-      it 'allows importing of namespaces' do
-        ns = Dry::Container::Namespace.new('one') do
-          register('two', 2)
-        end
-
-        container.import(ns)
-
-        expect(container.resolve('one.two')).to eq(2)
-      end
-
-      it 'allows importing of nested namespaces' do
-        ns = Dry::Container::Namespace.new('two') do
-          register('three', 3)
-        end
-
-        container.namespace('one') do
-          import(ns)
-        end
-
-        expect(container.resolve('one.two.three')).to eq(3)
-      end
-    end
-  end
-
-  describe 'stubbing' do
-    before do
-      container.enable_stubs!
-
-      container.register(:item, 'item')
-      container.register(:foo, 'bar')
-    end
-
-    after do
-      container.unstub
-    end
-
-    it 'keys can be stubbed' do
-      container.stub(:item, 'stub')
-      expect(container.resolve(:item)).to eql('stub')
-      expect(container[:item]).to eql('stub')
-    end
-
-    it 'only other keys remain accesible' do
-      container.stub(:item, 'stub')
-      expect(container.resolve(:foo)).to eql('bar')
-      expect(container[:foo]).to eql('bar')
-    end
-
-    it 'keys can be reverted back to their original value' do
-      container.stub(:item, 'stub')
-      container.unstub(:item)
-
-      expect(container.resolve(:item)).to eql('item')
-      expect(container[:item]).to eql('item')
-    end
-
-    describe 'with block argument' do
-      it 'executes the block with the given stubs' do
-        expect { |b| container.stub(:item, 'stub', &b) }.to yield_control
-      end
-
-      it 'keys are stubbed only while inside the block' do
-        container.stub(:item, 'stub') do
-          expect(container.resolve(:item)).to eql('stub')
-        end
-
-        expect(container.resolve(:item)).to eql('item')
-      end
-    end
-
-    describe 'mixing Strings and Symbols' do
-      it do
-        container.stub(:item, 'stub')
-        expect(container.resolve('item')).to eql('stub')
-      end
-    end
-
-    it 'raises an error when key is missing' do
-      expect { container.stub(:non_existing, 'something') }.
-        to raise_error(ArgumentError, 'cannot stub "non_existing" - no such key in container')
-    end
-  end
-
-  describe '.freeze' do
-    before do
-      container.register(:foo, 'bar')
-    end
-
-    it 'allows to freeze a container so that nothing can be registered later' do
-      container.freeze
-      error = RUBY_VERSION >= '2.5' ? FrozenError : RuntimeError
-      expect { container.register(:baz, 'quux') }.to raise_error(error)
-      expect(container).to be_frozen
-    end
-
-    it 'returns self back' do
-      expect(container.freeze).to be(container)
-    end
-  end
-
-  describe '.dup' do
-    it "returns a copy that doesn't share registered keys with the parent" do
-      container.dup.register(:foo, 'bar')
-      expect(container.key?(:foo)).to be false
-    end
-  end
-
-  describe '.clone' do
-    it "returns a copy that doesn't share registered keys with the parent" do
-      container.clone.register(:foo, 'bar')
-      expect(container.key?(:foo)).to be false
-    end
-
-    it 're-uses frozen container' do
-      expect(container.freeze.clone).to be_frozen
-      expect(container.clone._container).to be(container._container)
-    end
-  end
-
-  describe '.resolve' do
-    it 'accepts a fallback block' do
-      expect(container.resolve('missing') { :fallback }).to be(:fallback)
-    end
-  end
-end