little_boxes 0.1.0 → 0.3.7

data/lib/little_boxes/entry.rb

@@ -0,0 +1,30 @@
+module LittleBoxes
+  class Entry
+    attr_accessor :name, :memo, :box, :eager, :block, :configure, :then_block, :mutex
+
+    def initialize(name:, eager:, memo:, box:, block:, configure:, then_block:)
+      self.name = name
+      self.memo = memo
+      self.box = box
+      self.eager = eager
+      self.configure = configure
+      self.then_block = then_block
+      self.block = block
+      self.mutex = Mutex.new if @memo
+    end
+
+    def value
+      if @memo
+        @mutex.synchronize { @block.call(@box) }
+      else
+        @block.call(@box)
+      end
+    end
+
+    def block= block
+      @block = Strategy.for(
+        block, memo: @memo, configure: @configure, then_block: @then_block
+      )
+    end
+  end
+end

data/lib/little_boxes/entry_definition.rb

@@ -0,0 +1,28 @@
+module LittleBoxes
+  class EntryDefinition
+    attr_accessor :name, :eager, :memo, :block, :configure
+
+    def initialize(name, eager: false, memo: false, configure: false, then_block: nil, &block)
+      self.name = name
+      self.memo = memo
+      self.eager = eager
+      self.configure = configure
+      self.block = block
+    end
+
+    def eager!
+      self.eager = true
+    end
+
+    def for(box)
+      Entry.new(
+        name: name, box: box, block: block, memo: memo,
+        configure: configure, eager: eager, then_block: @then_block
+      )
+    end
+
+    def then(&block)
+      @then_block = block
+    end
+  end
+end

data/lib/little_boxes/strategy.rb

@@ -0,0 +1,79 @@
+module LittleBoxes
+  module Strategy
+    module_function
+
+    def for(block, memo: false, configure: false, then_block: nil)
+      case [memo, configure, !!then_block]
+      when [true, true, true]
+        memo_configure_then(block, then_block)
+      when [true, true, false]
+        memo_configure(block)
+      when [true, false, true]
+        memo_then(block, then_block)
+      when [true, false, false]
+        memo(block)
+      when [false, true, true]
+        configure_then(block, then_block)
+      when [false, true, false]
+        configure(block)
+      when [false, false, true]
+        then_block(block, then_block)
+      else
+        default(block)
+      end
+    end
+
+    def memo_configure(block)
+      value = nil
+      -> (bx) { value ||= do_configure(block.call(bx), bx) }
+    end
+
+    def memo_then(block, then_block)
+      value = nil
+      -> (bx) { value ||= block.call(bx).tap { |v| then_block.call v, bx } }
+    end
+
+    def memo_configure_then(block, then_block)
+      value = nil
+      -> (bx) do
+        value ||= do_configure(block.call(bx), bx)
+          .tap{ |v| then_block.call v, bx }
+      end
+    end
+
+    def memo(block)
+      value = nil
+      -> (bx) { value ||= block.call(bx) }
+    end
+
+    def configure(block)
+      -> (bx) { do_configure(block.call(bx), bx) }
+    end
+
+    def then_block(block, then_block)
+      -> (bx) { block.call(bx).tap { |v| then_block.call v, bx } }
+    end
+
+    def configure_then(block, then_block)
+      -> (bx) do
+        do_configure(block.call(bx), bx).tap{ |v| then_block.call v, bx }
+      end
+    end
+
+    def default(block)
+      block
+    end
+
+    def do_configure(subject, box)
+      config = {box: box}
+
+      config.default_proc = Proc.new do |h, name|
+        h[name] = h[:box][name]
+      end
+
+      subject.config = config
+
+      subject
+    end
+  end
+end

data/lib/little_boxes/version.rb

@@ -1,3 +1,3 @@
 module LittleBoxes
-  VERSION = "0.1.0"
+  VERSION = "0.3.7"
 end

data/little_boxes.gemspec

@@ -22,6 +22,4 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_runtime_dependency "forwarding_dsl"
-  spec.add_runtime_dependency "mini_object"
 end

data/spec/benchmarks_spec.rb

@@ -0,0 +1,162 @@
+require_relative 'spec_helper'
+require 'benchmark'
+require'logger'
+
+RSpec.describe 'Benchmark the speed', benchmark: true do
+  def define_class name, &block
+    stub_const(name, Class.new).tap do |c|
+      c.class_eval(&block)
+    end
+  end
+
+  def iterations
+    100000
+  end
+
+  def test_name
+    @__inspect_output.
+      gsub(/^"/,'').
+      gsub(/" \([^\(]+\)/,'')
+  end
+
+  def measure
+    b = Benchmark.measure{ iterations.times { yield } }
+    @results << {name: test_name, time: b.real}
+  end
+
+  before :all do
+    @results = []
+  end
+
+  after :all do
+    File.open 'tmp/benchmarks.log', 'w' do |r|
+      @results.sort_by{|res| res[:time] }.each do |res|
+        r.puts "#{'%0.4f' % res[:time]}s #{res[:name]}"
+      end
+    end
+
+    puts File.read 'tmp/benchmarks.log' if ENV['BENCH_OUT']
+  end
+
+  it '.config -> @config -> .port -> @port' do
+    define_class 'Server' do
+      def port
+        config.port
+      end
+
+      def config
+        @config ||= Configuration.new
+      end
+    end
+
+    define_class 'Configuration' do
+      def port
+        @port ||= 80
+      end
+    end
+
+    server = Server.new
+
+    measure { server.port }
+  end
+
+  it '.config -> @config -> [:port]' do
+    define_class 'Server' do
+      def port
+        config[:port]
+      end
+
+      def config
+        @config ||= {port: 80}
+      end
+    end
+
+    server = Server.new
+
+    measure { server.port }
+  end
+
+  it '.port_proc -> @port_proc -> .call' do
+    define_class 'Server' do
+      def port
+        port_proc.call
+      end
+
+      def port_proc
+        @port_proc ||= lambda { 90 }
+      end
+    end
+
+    server = Server.new
+
+    measure { server.port }
+  end
+
+  it '.port -> @port' do
+    define_class 'Server' do
+      def port
+        the_port
+      end
+
+      def the_port
+        @port ||= 80
+      end
+    end
+
+    server = Server.new
+
+    measure { server.port }
+  end
+
+  it '@port' do
+    define_class 'Server' do
+      def initialize
+        @port = 80
+      end
+
+      def port
+        @port
+      end
+    end
+
+    server = Server.new
+
+    measure { server.port }
+  end
+
+  it 'Port' do
+    define_class 'Server' do
+      Port = 80
+
+      def port
+        Port
+      end
+    end
+
+    server = Server.new
+
+    measure { server.port }
+  end
+
+  it '@config[:port]' do
+    define_class 'Server' do
+      def port
+        @config[:port]
+      end
+
+      def initialize
+        @config = begin
+                      Hash.new.tap do |h|
+                        h.default_proc = lambda do |hash, key|
+                          h[:port] = 80
+                        end
+                      end
+                    end
+      end
+    end
+
+    server = Server.new
+
+    measure { server.port }
+  end
+end

data/spec/docs/readme_spec.rb

@@ -0,0 +1,32 @@
+require_relative '../spec_helper'
+
+RSpec.describe 'README.md examples', :docs do
+  before { stub_const 'MyApp', Module.new }
+
+  describe 'Minimal example' do
+    it 'has a basic example' do
+      module MyApp
+        class MainBox
+          include LittleBoxes::Box
+
+          let(:port) { 80 }
+          letc(:server) { Server.new }
+        end
+
+        class Server
+          include LittleBoxes::Configurable
+
+          dependency :port
+        end
+      end
+
+      box = MyApp::MainBox.new
+      # => #<MyBox :server, :logger, :log_path>
+
+      box.server.port
+      # => 80
+
+      expect(box.server.port).to eq 80
+    end
+  end
+end

data/spec/integration/thread_safety_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+RSpec.describe "[Integration] Thread safety" do
+  let(:configurable) { Struct.new(:config) }
+  let(:dependency_block) do
+    ->(box) do
+      sleep 0.1
+      configurable.new
+    end
+  end
+  let(:box) { box_class.new }
+
+  describe 'LittleBoxes::Box#let' do
+    let(:box_class) do
+      _dependency_block = dependency_block
+
+      Class.new do
+        include LittleBoxes::Box
+        let :dependency, &_dependency_block
+      end
+    end
+
+    it 'is thread safe' do
+      expect(dependency_block).to receive(:call).once.and_call_original
+      20.times.map { Thread.new { box.dependency } }.each(&:join)
+    end
+  end
+
+  describe 'LittleBoxes::Box#letc' do
+    let(:box_class) do
+      _dependency_block = dependency_block
+
+      Class.new do
+        include LittleBoxes::Box
+        letc :dependency, &_dependency_block
+      end
+    end
+
+    it 'is thread safe' do
+      expect(dependency_block).to receive(:call).once.and_call_original
+      20.times.map { Thread.new { box.dependency } }.each(&:join)
+    end
+  end
+
+  describe 'LittleBoxes::Box#get' do
+    let(:box_class) do
+      _dependency_block = dependency_block
+
+      Class.new do
+        include LittleBoxes::Box
+        get :dependency, &_dependency_block
+      end
+    end
+
+    it 'does not use a mutex' do
+      expect_any_instance_of(Mutex).to_not receive(:synchronize)
+      20.times.map { Thread.new { box.dependency } }.each(&:join)
+    end
+  end
+
+  describe 'LittleBoxes::Box#getc' do
+    let(:box_class) do
+      _dependency_block = dependency_block
+
+      Class.new do
+        include LittleBoxes::Box
+        getc :dependency, &_dependency_block
+      end
+    end
+
+    it 'does not use a mutex' do
+      expect_any_instance_of(Mutex).to_not receive(:synchronize)
+      20.times.map { Thread.new { box.dependency } }.each(&:join)
+    end
+  end
+end

data/spec/little_boxes/box_spec.rb

@@ -1,341 +1,329 @@
 require_relative '../spec_helper'
-require 'ostruct'
 
-describe LittleBoxes::Box do
-  subject{ described_class.new }
+RSpec.describe 'Box' do
+  def define_class name, &block
+    stub_const(name.to_s, Class.new).tap do |c|
+      c.class_eval(&block)
+    end
+  end
 
-  describe '#customize' do
-    it 'allows customizing dependencies' do
-      subject.let(:loglevel) { 0 }
-      subject.let(:logger) { double('logger', loglevel: loglevel) }
+  before do
+    define_class :FoldersBox do
+      include Box
 
-      subject.customize(:logger) do |l|
-        l.let(:loglevel) { 1 }
-      end
-
-      expect(subject.logger.loglevel).to eq 1
+      letc(:collection) { FoldersCollection.new }
+      get(:some_other_logger) { SomeOtherLogger.new }
     end
 
-    it 'supports overriding lets attributes from the outside' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        dependency :logger
-      end
+    define_class :MainBox do
+      include Box
 
-      subject.let(:logger) { :logger }
+      let(:logger) { |c| Logger.new level: c.log_level }
+      get(:log_level) { 'INFO' }
+      letc(:server) { Server.new }
+      getc(:users_collection) { UsersCollection.new }
+      letc(:users_api) { UsersApi }
 
-      subject.let(:server) { server_class.new }
-
-      subject.customize(:server) do
-        let(:logger) { :new_logger }
+      letc(:task) { Task.new }.then do |task, box|
+        task.logger = :specific_logger
+        task.log_level = box.log_level
+      end
+      import FoldersBox
+
+      eagerc(:http_client) { HttpClient }
+      eager(:api_client) { |b| ApiClient.tap { |ac| ac.logger = b.logger } }
+      letc(:some_client) { SomeClient }
+      box(:folders, FoldersBox)
+      box(:files) do
+        eagerc(:rest_client) { RestClient }
       end
 
-      expect(subject.server.logger).to be :new_logger
+      letc(:client_with_defaults) { |b| b.client_with_defaults_class.new }
+      letc(:client_with_defaults_class) { ClientWithDefaults }
+      let(:client_with_class_defaults) { |b| b.client_with_class_defaults_class.new }
+      letc(:client_with_class_defaults_class) { ClientWithClassDefaults }
     end
-  end
 
-  describe '#let' do
-    it 'has freely defined registers with just a lambda' do
-      subject.let(:loglevel) { 0 }
-      expect(subject.loglevel).to eq 0
+    define_class :Server do
+      include Configurable
+
+      dependency :logger
+      public :logger
     end
 
-    it 'memoizes the result' do
-      n = 0
-      subject.let(:loglevel) { n = n + 1 }
+    define_class :Logger do
+      attr_accessor :level
 
-      expect(subject.loglevel).to eq 1
-      expect(subject.loglevel).to eq 1
+      def initialize(attrs)
+        @level = attrs[:level]
+      end
     end
 
-    it 'allows referencing other dependencies within such lambda' do
-      subject.let(:loglevel) { 0 }
-      subject.let(:logger) { double('logger', loglevel: loglevel) }
-      expect(subject.logger.loglevel).to eq 0
+    define_class :SomeOtherLogger do
     end
 
-    it 'has instances that have dependencies' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        dependency :logger
-      end
+    define_class :UsersCollection do
+      include Configurable
 
-      subject.let(:logger) { double('logger') }
-      subject.let(:server) { server_class.new }
-      expect(subject.server.logger).to be subject.logger
+      dependency :logger
+      public :logger
     end
 
-    it 'unknown dependencies raise exception' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        dependency :unknown_dep
-      end
+    define_class :FoldersCollection do
+      include Configurable
 
-      subject.let(:server) { server_class.new }
-      expect{ subject.server.unknown_dep }.to raise_error(LittleBoxes::MissingDependency)
+      dependency :logger
+      public :logger
     end
 
-    it 'has classes that have class dependencies' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        class_dependency :host
-      end
+    define_class :UsersApi do
+      include Configurable
 
-      subject.let(:host) { 'localhost' }
-      subject.let(:server_class) { server_class }
-      expect(subject.server_class.host).to eq 'localhost'
+      class_dependency :logger
+      public_class_method :logger
     end
 
-    it 'supports defaults' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        dependency :log, default: ->(d){ d.logger }
+    define_class :Task do
+      include Configurable
+
+      def logger= value
+        @config[:logger] = value
       end
 
-      subject.let(:logger) { :logger }
+      dependency :logger
+      public :logger
 
-      subject.let(:server) { server_class.new }
+      def log_level= value
+        @config[:log_level] = value
+      end
 
-      expect(subject.server.log).to be :logger
+      dependency :log_level
+      public :log_level
     end
 
-    it 'assigns dependencies with lambdas' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-
-        dependency :logger
-      end
+    define_class :HttpClient do
+      include Configurable
 
-      subject.let(:server) { server_class.new }
+      class_dependency :logger
+      public_class_method :logger
+    end
 
-      subject.let(:logger) { :old }
-      expect(subject.server.logger).to be :old
+    define_class :RestClient do
+      include Configurable
 
-      subject.let(:logger) { :new }
-      expect(subject.server.logger).to be :new
+      class_dependency :logger
+      public_class_method :logger
     end
 
-    it 'supports overriding specific attributes' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        dependency :logger
+    define_class :ApiClient do
+      class << self
+        attr_accessor :logger
       end
+    end
 
-      subject.let(:logger) { :logger }
-      subject.let(:new_logger) { :new_logger }
-
-      subject.let(:server) do
-        build { server_class.new }
-        let(:logger) { new_logger }
-      end
+    define_class :SomeClient do
+      include Configurable
 
-      expect(subject.server.logger).to be :new_logger
+      class_dependency :idontexist
+      public_class_method :idontexist
     end
-  end
 
-  describe '#obtain' do
-    it 'does not memoize the result' do
-      n = 0
-      subject.obtain(:loglevel) { n = n + 1 }
+    define_class :ClientWithDefaults do
+      include Configurable
 
-      expect(subject.loglevel).to eq 1
-      expect(subject.loglevel).to eq 2
+      dependency(:dep_with_default) { |b| b.object_id }
+      class_dependency(:class_dep_with_default) { |b| b.object_id }
+      class_dependency(:another_class_dep_with_default) { |b| b.object_id }
     end
 
-    it 'doesn not inject anything' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        dependency :logger
-      end
+    define_class :ClientWithClassDefaults do
+      include Configurable
 
-      subject.let(:logger) { double('logger') }
-      subject.obtain(:server) { server_class.new.tap { |s| s.logger = :old_logger } }
-      expect(subject.server.logger).to be :old_logger
+      class_dependency(:another_class_dep_with_default) { |b| b.object_id }
     end
   end
 
-  describe '#define' do
-    it 'does not memoize the result' do
-      n = 0
-      subject.define(:loglevel) { n = n + 1 }
-
-      expect(subject.loglevel).to eq 1
-      expect(subject.loglevel).to eq 2
+  let(:box) { MainBox.new }
+  define_method(:logger) { box.logger }
+  define_method(:server) { box.server }
+  define_method(:log_level) { box.log_level }
+  define_method(:users_collection) { box.users_collection }
+  define_method(:users_api) { box.users_api }
+  define_method(:task) { box.task }
+  define_method(:http_client) { HttpClient }
+  define_method(:rest_client) { RestClient }
+  define_method(:api_client) { ApiClient }
+  define_method(:some_client) { box.some_client }
+
+  describe 'box' do
+    it 'memoizes' do
+      expect(logger).to be logger
     end
 
-    it 'has instances that have dependencies' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        dependency :logger
-      end
-
-      subject.let(:logger) { double('logger') }
-      subject.define(:server) { server_class.new }
-      expect(subject.server.logger).to be subject.logger
+    it 'doesn\'t share between instances' do
+      expect(logger).not_to be MainBox.new.logger
     end
+  end
 
-    it 'unknown dependencies raise exception' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        dependency :unknown_dep
-      end
-
-      subject.define(:server) { server_class.new }
-      expect{ subject.server.unknown_dep }.to raise_error(LittleBoxes::MissingDependency)
+  describe 'logger' do
+    it 'is a new instance every time (get)' do
+      expect(log_level).to eq 'INFO'
+      expect(log_level).not_to be log_level
     end
 
-    it 'has classes that have class dependencies' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        class_dependency :host
-      end
+    it 'has the log_level (relying on other deps)' do
+      expect(logger.level).to eq log_level
+    end
 
-      subject.let(:host) { 'localhost' }
-      subject.define(:server_class) { server_class }
-      expect(subject.server_class.host).to eq 'localhost'
+    it 'has memoized log_level (let memoizes)' do
+      expect(logger.level).to be logger.level
     end
+  end
 
-    it 'supports defaults' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        dependency :log, default: ->(d){ d.logger }
-      end
+  describe 'server (letc)' do
+    it 'is configured' do
+      expect(server.logger).to be logger
+    end
 
-      subject.let(:logger) { :logger }
+    it 'is memoized' do
+      expect(server).to be server
+    end
 
-      subject.define(:server) { server_class.new }
+    it 'respects previously configured dependencies' do
+      expect(task.logger).to be :specific_logger
+    end
 
-      expect(subject.server.log).to be :logger
+    it 'has access to the box' do
+      expect(task.log_level).to eq box.log_level
     end
 
-    it 'assigns dependencies with lambdas' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
+    pending 'test for get, getc, let'
+  end
 
-        dependency :logger
-      end
+  describe 'users_collection (getc)' do
+    it 'doesn\'t memoize' do
+      expect(users_collection).not_to be users_collection
+    end
 
-      subject.define(:server) { server_class.new }
+    it 'has a logger' do
+      expect(users_collection.logger).to be_a Logger
+    end
 
-      subject.let(:logger) { :old }
-      expect(subject.server.logger).to be :old
+    it 'is main box\'s logger' do
+      expect(users_collection.logger).to be logger
+    end
 
-      subject.let(:logger) { :new }
-      expect(subject.server.logger).to be :new
+    it 'memoizes the logger' do
+      expect(users_collection.logger).to be users_collection.logger
     end
   end
 
-  describe '#box' do
-    it 'supports boxes' do
-      subject.box :loggers do
-        let(:null) { :null_logger }
-        let(:file) { :file_logger }
-      end
-
-      expect(subject.loggers.null).to be :null_logger
+  describe 'users_api (class configurable)' do
+    it 'has a logger' do
+      expect(users_api.logger).to be_a Logger
     end
 
-    it 'supports finding dependencies upwards in the ancestry' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        dependency :logger
-      end
-
-      subject.let(:logger) { :logger }
-
-      subject.box :servers do
-        let(:one) { server_class.new }
-      end
-
-      expect(subject.servers.one.logger).to be :logger
+    it 'is main box\'s logger' do
+      expect(users_api.logger).to be logger
     end
+  end
 
-    it 'defaults within boxes' do
-      server_class = Class.new do
-        include LittleBoxes::Dependant
-        dependency :log, default: ->(a){ a.logger }
-      end
-
-      subject.let(:logger) { :logger }
-
-      subject.box :servers do
-        let(:apache) { server_class.new }
-      end
+  describe 'http_client (configured eager loading)' do
+    it 'loads on box initialization' do
+      box
+      expect(http_client.logger).to be_a Logger
+    end
 
-      expect(subject.servers.apache.log).to be :logger
+    it 'doesn\'t eager load the dependencies' do
+      expect(box).not_to receive(:logger)
+      box
     end
   end
 
-  describe '#inspect' do
-    it 'has nice inspect' do
-      subject.let(:loglevel) { 0 }
-      subject.let(:logger) { 0 }
-      expect(subject.inspect).to eq "<LittleBoxes::Box box: loglevel logger>"
+  describe 'api_client (configured eager loading)' do
+    it 'loads on box initialization' do
+      box
+      expect(api_client.logger).to be_a Logger
     end
-  end
-  
-  describe '#path' do
-    it 'has a path' do
-      subject.box :second do
-        box :third do
-        end
-      end
 
-      expect(subject.second.third.path).to eq [subject, subject.second, subject.second.third]
+    it 'doesn\'t eager load the dependencies' do
+      expect(box).not_to receive(:logger)
+      box
     end
   end
 
-  describe '#name' do
-    it 'names boxes' do
-      subject.name = :first
-
-      subject.box :second do
-        box :third do
-        end
-      end
-
-      expect(subject.second.third.path.map(&:name)).to eq [:first, :second, :third]
+  describe 'error handling (unmet dependency)' do
+    it 'sends a pretty error' do
+      expect { some_client.idontexist }.to raise_error(
+        LittleBoxes::DependencyNotFound,
+        'Dependency idontexist not found'
+      )
     end
   end
 
-  describe '#reset' do
-    it 'has a reset' do
-      first = subject
+  describe 'nested boxes' do
+    describe 'given a box' do
+      it 'initializes second level box on first level box initialization' do
+        expect(FoldersBox).to receive(:new)
+        box
+      end
 
-      first.box :second do
-        let(:logger) { Object.new }
+      it 'allows to navigate to element of second level box' do
+        expect(box.folders.collection).to be_a FoldersCollection
       end
 
-      old_logger = first.second.logger
+      it 'configures looking up the tree' do
+        expect(box.folders.collection.logger).to be(logger)
+      end
 
-      first.reset
-      expect(first.second.logger).not_to be old_logger
+      it 'has access to parent' do
+        expect(box.folders.parent).to be(box)
+      end
+    end
+
+    describe 'inline box' do
+      it 'eager loads eager loadable stuff on the second level' do
+        box
+        expect(rest_client.logger).to be logger
+      end
     end
   end
 
-  describe '#root' do
-    it 'has a root' do
-      first = subject
+  describe 'imported boxes' do
+    describe 'given a box' do
+      it 'imports entries' do
+        expect(box.collection).to be_a(FoldersCollection)
+      end
+
+      it 'keeps memoization options' do
+        expect(box.collection).to be(box.collection)
+      end
 
-      first.box :second do
-        box(:third) { }
+      it 'keeps configuration options' do
+        expect(box.collection.logger).to be_a Logger
       end
 
-      expect(first.second.third.root).to eq first
+      it 'does not run entries procs' do
+        expect(SomeOtherLogger).not_to receive(:new)
+        box
+      end
     end
   end
 
-  describe '.new' do
-    it 'executes block on initialize' do
-      subject = described_class.new do
-        let(:loglevel) { 0 }
-      end
+  describe 'defaults' do
+    it 'is supported at instance level' do
+      client = box.client_with_defaults
+      expect(client.dep_with_default).to eq box.object_id
+    end
 
-      expect(subject.loglevel).to eq 0
+    it 'is supported at class level' do
+      client_class = box.client_with_defaults_class
+      expect(client_class.class_dep_with_default).to eq box.object_id
     end
 
-    it 'can build instances' do
-      expect(subject).to be_a(described_class)
+    it 'is supported at class level and accessible at instance level' do
+      client = box.client_with_class_defaults
+      expect(client.another_class_dep_with_default).to eq box.object_id
     end
   end
 end