dry-container 0.6.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 35fd3e8023c0220150dade45164cdefbe011633c
-  data.tar.gz: 4060a17b5831ef9c1fe7aa4440e0c34ef7d8fb4e
+SHA256:
+  metadata.gz: ac1a656d67e37d72da3265e2f092e507460cba4615db8f3727ee1acbca41584c
+  data.tar.gz: be191bd45d43147d12c858d8683463be5e59a66ef2f473e8c19d7010bda0794c
 SHA512:
-  metadata.gz: 9e1f8876a5ea3cdb77b8516e1d85481ed86b58d70c8d41aa77d71c45fbf30bdd1b4c226a60a50a0795fde809934461a8c72ff6225b6a2b4b9bd6e468cb369709
-  data.tar.gz: bf68f2feb7608a30d851f69c7e370741a0cf2af50e539abe027cad53ce3714b7965b8964266b5e045fabb43fcdcb6f86f95b9398de874b8f7752cf4c56797558
+  metadata.gz: c95deccc6ad3f976d31949d1a39e1bc4d6f5797604045aed3f7254d3a1e88ca35c76ee0483ad14bbc6abe0aed8fb13d157cd793c6eb1ff417343a0037a56358f
+  data.tar.gz: a6bac7cb3f1819b6bb89a2989de1fe0c3d9a182144a556394cec1f8a1d48bf848589c57ffc7b4daaac106cb0a5673b086f901f2b1deba81c64796a6a1038c6c0

data/.gitignore

@@ -7,3 +7,4 @@ tmp/
 .idea/
 Gemfile.lock
 spec/examples.txt
+pkg/

data/.travis.yml

@@ -8,22 +8,18 @@ script:
 after_success:
   - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
 rvm:
-  - 2.0
-  - 2.1
-  - 2.2
-  - 2.3.1
-  - rbx-3
-  - jruby-9.1.5.0
-  - ruby-head
-  - jruby-head
+  - 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'
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head
 notifications:
   email: false
   webhooks:

data/CHANGELOG.md

@@ -1,10 +1,85 @@
-## Unreleased
+## v0.7.2 - 2019-07-09
+
+## Added
+
+* `.resolve` accepts an optional fallback block, similar to how `Hash#fetch` works ([flash-gordon](https://github.com/flash-gordon))
+  ```ruby
+  container.resolve('missing_key') { :fallback } # => :fallback
+  ```
+* `.decorate` can (again) work with static values. Also, it can take a block instead of `with` ([flash-gordon](https://github.com/flash-gordon))
+  ```ruby
+  container.register('key', 'value')
+  container.decorate('key') { |v| "<'#{v}'>" }
+  container.resolve('key') # => "<'value'>"
+  ```
+
+[Compare v0.7.1...0.7.2](https://github.com/dry-rb/dry-container/compare/v0.7.1...v0.7.2)
+
+## v0.7.1 - 2019-06-07
+
+## Fixed
+
+* Added `Mixin#dup` and `Mixin#clone`, now copies don't share underlying containers (flash-gordon)
+
+[Compare v0.7.0...0.7.1](https://github.com/dry-rb/dry-container/compare/v0.7.0...v0.7.1)
+
+## v0.7.0 - 2019-02-05
+
+## Changed
+
+* [BREAKING] Now only Ruby 2.3 and above is supported ([flash-gordon](https://github.com/flash-gordon))
+
+## Fixed
+
+* Symbols are now coerced to strings when resolving stubbed dependencies ([cthulhu666](https://github.com/cthulhu666))
+* Stubbing keys not present in container will raise an error ([flash-gordon](https://github.com/flash-gordon))
+
+  This means after upgrading you may see errors like this
+  ```
+  ArgumentError (cannot stub "something" - no such key in container)
+  ```
+  Be sure you register dependencies before using them. The new behavior will likely save quite a bit of time when debugging ill-configured container setups.
+
+## Added
+
+* Namespace DSL resolves keys relative to the current namespace, see the corresponding [changes](https://github.com/dry-rb/dry-container/pull/47) ([yuszuv](https://github.com/yuszuv))
+* Registered objects can be decorated with the following API ([igor-alexandrov](https://github.com/igor-alexandrov))
+
+  ```ruby
+  class CreateUser
+    def call(params)
+      # ...
+    end
+  end
+  container.register('create_user') { CreateUser.new }
+  container.decorate('create_user', with: ShinyLogger.new)
+
+  # Now subsequent resolutions will return a wrapped object
+
+  container.resolve('create_user')
+  # => #<ShinyLogger @obj=#<CreateUser:0x...>]>
+  ```
+* Freezing a container now prevents further registrations ([flash-gordon](https://github.com/flash-gordon))
+
+## Internal
+
+* Handling container items was generalized in [#34](https://github.com/dry-rb/dry-container/pull/34) ([GabrielMalakias](https://github.com/GabrielMalakias))
+
+[Compare v0.6.0...0.7.0](https://github.com/dry-rb/dry-container/compare/v0.6.0...v0.7.0)
+
+## v0.6.0 - 2016-12-09
 
 ## Added
 
 * `Dry::Container::Mixin#each` - provides a means of seeing what all is registered in the container ([jeremyf](https://github.com/jeremyf))
 
-## v0.5.0
+## Fixed
+
+* Including mixin into a class with a custom initializer ([maltoe](https://github.com/maltoe))
+
+[Compare v0.5.0...v0.6.0](https://github.com/dry-rb/dry-container/compare/v0.5.0...v0.6.0)
+
+## v0.5.0 - 2016-08-31
 
 ## Added
 
@@ -14,4 +89,4 @@
 
 * `required_ruby_version` set to `>= 2.0.0` ([artofhuman](https://github.com/artofhuman))
 
-[Compare v0.4.0...HEAD](https://github.com/dry-rb/dry-container/compare/v0.4.0...v0.5.0)
+[Compare v0.4.0...v0.5.0](https://github.com/dry-rb/dry-container/compare/v0.4.0...v0.5.0)

data/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# 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

@@ -15,4 +15,5 @@ group :tools do
   gem 'guard-rspec'
   gem 'guard-rubocop'
   gem 'listen', '3.0.6'
+  gem 'pry-byebug', platform: :mri
 end

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Ruby Object Mapper
+Copyright (c) 2015-2017 dry-container
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/README.md

@@ -1,171 +1,23 @@
-[gitter]: https://gitter.im/dry-rb/chat
 [gem]: https://rubygems.org/gems/dry-container
 [travis]: https://travis-ci.org/dry-rb/dry-container
-[code_climate]: https://codeclimate.com/github/dry-rb/dry-container
+[maintainability]: https://codeclimate.com/github/dry-rb/dry-container/maintainability
+[test_coverage]: https://codeclimate.com/github/dry-rb/dry-container/test_coverage
 [inch]: http://inch-ci.org/github/dry-rb/dry-container
+[chat]: https://dry-rb.zulipchat.com
 
-# dry-container [![Join the Gitter chat](https://badges.gitter.im/Join%20Chat.svg)][gitter]
+# dry-container [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
 
 [![Gem Version](https://img.shields.io/gem/v/dry-container.svg)][gem]
 [![Build Status](https://img.shields.io/travis/dry-rb/dry-container.svg)][travis]
-[![Code Climate](https://img.shields.io/codeclimate/github/dry-rb/dry-container.svg)][code_climate]
-[![Test Coverage](https://img.shields.io/codeclimate/coverage/github/dry-rb/dry-container.svg)][code_climate]
+[![Maintainability](https://api.codeclimate.com/v1/badges/97faf9446cb5811100e7/maintainability)][maintainability]
+[![Test Coverage](https://api.codeclimate.com/v1/badges/97faf9446cb5811100e7/test_coverage)][test_coverage]
 [![API Documentation Coverage](http://inch-ci.org/github/dry-rb/dry-container.svg)][inch]
 
-
 A simple, configurable container implemented in Ruby.
 
-## Synopsis
-
-### Brief Example
-
-```ruby
-container = Dry::Container.new
-container.register(:parrot) { |a| puts a }
-
-parrot = container.resolve(:parrot)
-parrot.call("Hello World")
-# Hello World
-# => nil
-```
-
-See [Dry::AutoInject Usage](https://github.com/dry-rb/dry-auto_inject#usage) for additional details.
-
-### Detailed Example
-
-```ruby
-User = Struct.new(:name, :email)
-
-data_store = Concurrent::Map.new.tap do |ds|
-  ds[:users] = Concurrent::Array.new
-end
-
-# Initialize container
-container = Dry::Container.new
-
-# Register an item with the container to be resolved later
-container.register(:data_store, data_store)
-container.register(:user_repository, -> { container.resolve(:data_store)[:users] })
-
-# Resolve an item from the container
-container.resolve(:user_repository) << User.new('Jack', 'jack@dry-container.com')
-# You can also resolve with []
-container[:user_repository] << User.new('Jill', 'jill@dry-container.com')
-# => [
-#      #<struct User name="Jack", email="jack@dry-container.com">,
-#      #<struct User name="Jill", email="jill@dry-container.com">
-#    ]
-
-# If you wish to register an item that responds to call but don't want it to be
-# called when resolved, you can use the options hash
-container.register(:proc, -> { :result }, call: false)
-container.resolve(:proc)
-# => #<Proc:0x007fa75e652c98@(irb):25 (lambda)>
-
-# You can also register using a block
-container.register(:item) do
-  :result
-end
-container.resolve(:item)
-# => :result
-
-container.register(:block, call: false) do
-  :result
-end
-container.resolve(:block)
-# => #<Proc:0x007fa75e6830f0@(irb):36>
-
-# You can also register items under namespaces using the #namespace method
-container.namespace('repositories') do
-  namespace('checkout') do
-    register('orders') { Concurrent::Array.new }
-  end
-end
-container.resolve('repositories.checkout.orders')
-# => []
-
-# Or import a namespace
-ns = Dry::Container::Namespace.new('repositories') do
-  namespace('authentication') do
-    register('users') { Concurrent::Array.new }
-  end
-end
-container.import(ns)
-container.resolve('repositories.authentication.users')
-# => []
-
-# You can also register a block that is used to initialize a dependency and
-# then memoize it, allowing several dependencies to be added without
-# enforcing an instantiation order
-class MessagePrinter
-  def initialize(container)
-    @message = container.resolve(:message)
-    @time = Time.now
-  end
-
-  def print
-    puts "#{@message} at #{@time}"
-  end
-end
-
-container.register(:message_printer, -> { MessagePrinter.new(container) }, memoize: true)
-container.register(:message, 'Hello, world!')
-container.resolve(:message_printer).print
-# => Hello, world! at 2016-08-30 05:32:12 -0700
-
-# Same instance is reused next time
-container.resolve(:message_printer).print
-# => Hello, world! at 2016-08-30 05:32:12 -0700
-```
-
-You can also get container behaviour at both the class and instance level via the mixin:
-
-```ruby
-class Container
-  extend Dry::Container::Mixin
-end
-Container.register(:item, :my_item)
-Container.resolve(:item)
-# => :my_item
-
-class ContainerObject
-  include Dry::Container::Mixin
-end
-container = ContainerObject.new
-container.register(:item, :my_item)
-container.resolve(:item)
-# => :my_item
-```
-### Using a custom registry/resolver
-
-You can configure how items are registered and resolved from the container:
-
-```ruby
-Dry::Container.configure do |config|
-  config.registry = ->(container, key, item, options) { container[key] = item }
-  config.resolver = ->(container, key) { container[key] }
-end
-
-class Container
-  extend Dry::Container::Mixin
-
-  configure do |config|
-    config.registry = ->(container, key, item, options) { container[key] = item }
-    config.resolver = ->(container, key) { container[key] }
-  end
-end
-
-class ContainerObject
-  include Dry::Container::Mixin
-
-  configure do |config|
-    config.registry = ->(container, key, item, options) { container[key] = item }
-    config.resolver = ->(container, key) { container[key] }
-  end
-end
-```
+## Links
 
-This allows you to customise the behaviour of Dry::Container, for example, the default registry (Dry::Container::Registry) will raise a Dry::Container::Error exception if you try to register under a key that is already used, you may want to just overwrite the existing value in that scenario, configuration allows you to do so.
+[Documentation](http://dry-rb.org/gems/dry-container/)
 
 ## License
 

data/dry-container.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 require File.expand_path('../lib/dry/container/version', __FILE__)
 
 Gem::Specification.new do |spec|
@@ -7,7 +6,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Andy Holland']
   spec.email         = ['andyholland1991@aol.com']
   spec.summary       = 'A simple container intended for use as an IoC container'
-  spec.homepage      = 'https://github.com/dryrb/dry-container'
+  spec.homepage      = 'https://github.com/dry-rb/dry-container'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -15,7 +14,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = ">= 2.0.0"
+  spec.required_ruby_version = '>= 2.3.0'
 
   spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
   spec.add_runtime_dependency 'dry-configurable', '~> 0.1', '>= 0.1.3'

data/lib/dry/container.rb

@@ -1,7 +1,5 @@
-require 'concurrent'
 require 'dry-configurable'
 require 'dry/container/error'
-require 'dry/container/item'
 require 'dry/container/namespace'
 require 'dry/container/registry'
 require 'dry/container/resolver'

data/lib/dry/container/error.rb

@@ -1,6 +1,6 @@
 module Dry
   class Container
     # @api public
-    class Error < ::StandardError; end
+    Error = Class.new(StandardError)
   end
 end

data/lib/dry/container/item.rb

@@ -1,42 +1,47 @@
 module Dry
   class Container
-    # Container class
+    # Base class to abstract Memoizable and Callable implementations
+    #
+    # @api abstract
     #
-    # @private
     class Item
-      attr_reader :item, :options, :memoize, :memoize_mutex
+      # @return [Mixed] the item to be solved later
+      attr_reader :item
+
+      # @return [Hash] the options to memoize, call or no.
+      attr_reader :options
 
+      # @api abstract
       def initialize(item, options = {})
         @item = item
         @options = {
           call: item.is_a?(::Proc) && item.parameters.empty?
         }.merge(options)
-
-        if options[:memoize] == true
-          raise(
-            ::Dry::Container::Error,
-            'Memoize only supported for a block or a proc'
-          ) unless item.is_a?(::Proc)
-          @memoize = true
-          @memoize_mutex = ::Mutex.new
-        end
       end
 
+      # @api abstract
       def call
-        return memoized_item if memoize
+        raise NotImplementedError
+      end
 
-        if options[:call] == true
-          item.call
-        else
-          item
-        end
+      # @private
+      def value?
+        !callable?
       end
 
-      private
+      # @private
+      def callable?
+        options[:call]
+      end
 
-      def memoized_item
-        memoize_mutex.synchronize do
-          @memoized_item ||= item.call
+      # Build a new item with transformation applied
+      #
+      # @private
+      def map(func)
+        if callable?
+          self.class.new(-> { func.(item.call) }, options)
+        else
+          self.class.new(func.(item), options)
         end
       end
     end

data/lib/dry/container/item/callable.rb

@@ -0,0 +1,20 @@
+require 'dry/container/item'
+
+module Dry
+  class Container
+    class Item
+      # Callable class to returns a item call
+      #
+      # @api public
+      #
+      class Callable < Item
+        # Returns the result of item call or item
+        #
+        # @return [Mixed]
+        def call
+          callable? ? item.call : item
+        end
+      end
+    end
+  end
+end

data/lib/dry/container/item/factory.rb

@@ -0,0 +1,24 @@
+require 'dry/container/item/memoizable'
+require 'dry/container/item/callable'
+
+module Dry
+  class Container
+    class Item
+      # Factory for create an Item to register inside of container
+      #
+      # @api public
+      class Factory
+        # Creates an Item Memoizable or Callable
+        # @param [Mixed] item
+        # @param [Hash] options
+        #
+        # @raise [Dry::Container::Error]
+        #
+        # @return [Dry::Container::Item::Base]
+        def call(item, options = {})
+          options[:memoize] ? Memoizable.new(item, options) : Callable.new(item, options)
+        end
+      end
+    end
+  end
+end

data/lib/dry/container/item/memoizable.rb

@@ -0,0 +1,49 @@
+require 'dry/container/item'
+
+module Dry
+  class Container
+    class Item
+      # Memoizable class to store and execute item calls
+      #
+      # @api public
+      #
+      class Memoizable < Item
+        # @return [Mutex] the stored mutex
+        attr_reader :memoize_mutex
+
+        # Returns a new Memoizable instance
+        #
+        # @param [Mixed] item
+        # @param [Hash] options
+        #
+        # @raise [Dry::Container::Error]
+        #
+        # @return [Dry::Container::Item::Base]
+        def initialize(item, options = {})
+          super
+          raise_not_supported_error unless callable?
+
+          @memoize_mutex = ::Mutex.new
+        end
+
+        # Returns the result of item call using a syncronized mutex
+        #
+        # @return [Dry::Container::Item::Base]
+        def call
+          memoize_mutex.synchronize do
+            @memoized_item ||= item.call
+          end
+        end
+
+        private
+
+        # @private
+        def raise_not_supported_error
+          raise ::Dry::Container::Error, 'Memoize only supported for a block or a proc'.freeze
+        end
+      end
+    end
+  end
+end
+
+

data/lib/dry/container/mixin.rb

@@ -1,8 +1,14 @@
+
+require 'concurrent/hash'
+
 module Dry
   class Container
-    PREFIX_NAMESPACE = ->(namespace, key, config) do
+    PREFIX_NAMESPACE = lambda do |namespace, key, config|
       [namespace, key].join(config.namespace_separator)
     end
+
+    EMPTY_HASH = {}.freeze
+
     # Mixin to expose Inversion of Control (IoC) container behaviour
     #
     # @example
@@ -87,7 +93,7 @@ module Dry
       # @return [Dry::Container::Mixin] self
       #
       # @api public
-      def register(key, contents = nil, options = {}, &block)
+      def register(key, contents = nil, options = EMPTY_HASH, &block)
         if block_given?
           item = block
           options = contents if contents.is_a?(::Hash)
@@ -104,12 +110,15 @@ module Dry
       #
       # @param [Mixed] key
       #   The key for the item you wish to resolve
+      # @yield
+      #   Fallback block to call when a key is missing. Its result will be returned
+      # @yieldparam [Mixed] key Missing key
       #
       # @return [Mixed]
       #
       # @api public
-      def resolve(key)
-        config.resolver.call(_container, key)
+      def resolve(key, &block)
+        config.resolver.call(_container, key, &block)
       end
 
       # Resolve an item from the container
@@ -129,8 +138,7 @@ module Dry
       #
       # @param [Dry::Container] other
       #   The other container to merge in
-      # @param [Hash] options
-      # @option options [Symbol] :namespace
+      # @param [Symbol, nil] namespace
       #   Namespace to prefix other container items with, defaults to nil
       #
       # @return [Dry::Container::Mixin] self
@@ -150,7 +158,7 @@ module Dry
         self
       end
 
-      # Check whether an items is registered under the given key
+      # Check whether an item is registered under the given key
       #
       # @param [Mixed] key
       #   The key you wish to check for registration with
@@ -198,6 +206,29 @@ module Dry
         config.resolver.each(_container, &block)
       end
 
+      # Decorates an item from the container with specified decorator
+      #
+      # @return [Dry::Container::Mixin] self
+      #
+      # @api public
+      def decorate(key, with: nil, &block)
+        key = key.to_s
+        original = _container.delete(key) do
+          raise Error, "Nothing registered with the key #{key.inspect}"
+        end
+
+        if with.is_a?(Class)
+          decorator = with.method(:new)
+        elsif block.nil? && !with.respond_to?(:call)
+          raise Error, "Decorator needs to be a Class, block, or respond to the `call` method"
+        else
+          decorator = with || block
+        end
+
+        _container[key] = original.map(decorator)
+        self
+      end
+
       # Evaluate block and register items in namespace
       #
       # @param [Mixed] namespace
@@ -231,10 +262,35 @@ module Dry
         self
       end
 
+      # Freeze the container. Nothing can be registered after freezing
+      #
+      # @api public
+      def freeze
+        super
+        _container.freeze
+        self
+      end
+
       # @private no, really
       def _container
         @_container
       end
+
+      # @api public
+      def dup
+        copy = super
+        copy.instance_variable_set(:@_container, _container.dup)
+        copy
+      end
+
+      # @api public
+      def clone
+        copy = super
+        unless copy.frozen?
+          copy.instance_variable_set(:@_container, _container.dup)
+        end
+        copy
+      end
     end
   end
 end

data/lib/dry/container/namespace_dsl.rb

@@ -1,3 +1,5 @@
+require 'delegate'
+
 module Dry
   class Container
     # @api private
@@ -43,6 +45,10 @@ module Dry
         self
       end
 
+      def resolve(key)
+        super(namespaced(key))
+      end
+
       private
 
       def namespaced(key)

data/lib/dry/container/registry.rb

@@ -1,3 +1,5 @@
+require 'dry/container/item/factory'
+
 module Dry
   class Container
     # Default registry for registering items with the container
@@ -34,9 +36,13 @@ module Dry
             raise Error, "There is already an item registered with the key #{key.inspect}"
           end
 
-          container[key] = ::Dry::Container::Item.new(item, options)
+          container[key] = factory.call(item, options)
         end
       end
+
+      def factory
+        @factory ||= ::Dry::Container::Item::Factory.new
+      end
     end
   end
 end

data/lib/dry/container/resolver.rb

@@ -10,16 +10,24 @@ module Dry
       #   The container
       # @param [Mixed] key
       #   The key for the item you wish to resolve
+      # @yield
+      #   Fallback block to call when a key is missing. Its result will be returned
+      # @yieldparam [Mixed] key Missing key
       #
       # @raise [Dry::Conainer::Error]
-      #   If the given key is not registered with the container
+      #   If the given key is not registered with the container (and no block provided)
+      #
       #
       # @return [Mixed]
       #
       # @api public
       def call(container, key)
         item = container.fetch(key.to_s) do
-          raise Error, "Nothing registered with the key #{key.inspect}"
+          if block_given?
+            return yield(key)
+          else
+            raise Error, "Nothing registered with the key #{key.inspect}"
+          end
         end
 
         item.call
@@ -48,7 +56,6 @@ module Dry
         container.keys
       end
 
-
       # Calls block once for each key in container, passing the key as a parameter.
       #
       # If no block is given, an enumerator is returned instead.

data/lib/dry/container/stub.rb

@@ -5,12 +5,16 @@ module Dry
       #
       # @api public
       def resolve(key)
-        _stubs.fetch(key) { super }
+        _stubs.fetch(key.to_s) { super }
       end
 
       # Add a stub to the container
       def stub(key, value, &block)
-        _stubs[key] = value
+        unless key?(key)
+          raise ArgumentError, "cannot stub #{ key.to_s.inspect } - no such key in container"
+        end
+
+        _stubs[key.to_s] = value
 
         if block
           yield
@@ -23,11 +27,12 @@ module Dry
       # Remove stubbed keys from the container
       def unstub(*keys)
         keys = _stubs.keys if keys.empty?
-        keys.each { |key| _stubs.delete(key) }
+        keys.each { |key| _stubs.delete(key.to_s) }
       end
 
       # Stubs have already been enabled turning this into a noop
       def enable_stubs!
+        # DO NOTHING
       end
 
       private

data/lib/dry/container/version.rb

@@ -1,6 +1,6 @@
 module Dry
   class Container
     # @api public
-    VERSION = '0.6.0'.freeze
+    VERSION = '0.7.2'.freeze
   end
 end

data/spec/integration/mixin_spec.rb

@@ -25,7 +25,7 @@ RSpec.describe Dry::Container::Mixin do
       end
 
       it 'does not fail on missing member variable' do
-        expect { container.register :key, ->{} }.to_not raise_error
+        expect { container.register :key, -> {} }.to_not raise_error
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,11 +1,23 @@
-if ENV['COVERAGE'] == 'true' && RUBY_ENGINE == 'ruby' && RUBY_VERSION == '2.3.1'
-  require 'simplecov'
+# require 'pathname'
 
-  SimpleCov.start do
-    add_filter '/spec/'
+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|
@@ -43,7 +55,7 @@ RSpec.configure do |config|
   # 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"
+  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:

data/spec/support/shared_examples/container.rb

@@ -130,7 +130,7 @@ RSpec.shared_examples 'a container' do
           end
 
           it 'does not call a proc on resolving if one accepts an arbitrary number of keyword arguments' do
-            container.register(:item) { |**kw| 'item' }
+            container.register(:item) { |*| 'item' }
 
             expect(container.resolve(:item)).to be_a_kind_of Proc
             expect(container.resolve(:item).call).to eq('item')
@@ -383,6 +383,98 @@ RSpec.shared_examples 'a container' do
       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
@@ -427,6 +519,21 @@ RSpec.shared_examples 'a container' 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
@@ -499,5 +606,59 @@ RSpec.shared_examples 'a container' do
         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

metadata

@@ -1,31 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: dry-container
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.2
 platform: ruby
 authors:
 - Andy Holland
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-12-09 00:00:00.000000000 Z
+date: 2019-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-  type: :runtime
+  name: concurrent-ruby
   prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: dry-configurable
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -34,8 +33,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.3
-  type: :runtime
+  name: dry-configurable
   prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -45,48 +45,48 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.1.3
 - !ruby/object:Gem::Dependency
-  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  name: bundler
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  name: rake
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  name: rspec
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - andyholland1991@aol.com
 executables: []
@@ -100,6 +100,7 @@ files:
 - ".rubocop_todo.yml"
 - ".travis.yml"
 - CHANGELOG.md
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE
 - README.md
@@ -109,6 +110,9 @@ files:
 - lib/dry/container.rb
 - lib/dry/container/error.rb
 - lib/dry/container/item.rb
+- lib/dry/container/item/callable.rb
+- lib/dry/container/item/factory.rb
+- lib/dry/container/item/memoizable.rb
 - lib/dry/container/mixin.rb
 - lib/dry/container/namespace.rb
 - lib/dry/container/namespace_dsl.rb
@@ -121,11 +125,11 @@ files:
 - spec/integration/mixin_spec.rb
 - spec/spec_helper.rb
 - spec/support/shared_examples/container.rb
-homepage: https://github.com/dryrb/dry-container
+homepage: https://github.com/dry-rb/dry-container
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -133,16 +137,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.7.9
+signing_key:
 specification_version: 4
 summary: A simple container intended for use as an IoC container
 test_files: