encase 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MjY0NjkwNmNhNzFmNjhiY2IyZmVhYjU2YjE4OGU2MTcwMTkxZmY0ZA==
+  data.tar.gz: !binary |-
+    MjgzYTUxZjNmMTgxNTA1NTVlN2Y4MDA5MWExYmE2NjFkYmNlNGUzNw==
+SHA512:
+  metadata.gz: !binary |-
+    MDllY2FhYmFmZTQ2YTUxNWU4NDVlMTZlMjNmMmM4M2QwMTkzNzYzMjQ4Njk3
+    ZWRkZDg4OWU5YzQxNWQ4YTQ0NjliZGY1MWQzNzZhYThmZjAzNzVmZmQxMjM5
+    MzE1ZTY5ZGE3MjFmODRkM2Y3NjJiMzk3MDBjOTg3Y2YxODNmNmY=
+  data.tar.gz: !binary |-
+    YjIzNWQ5MmQ2YjM2Y2Y1N2M1M2JmOGNkNmMwNzQ0N2NmMmQ4MDhmZWFiNWZh
+    ZmIzOTdiYzkzMjg0ZDRhYjU3MWY1MjgyN2U3MDk4MWE4NjA5ZmUxMzliZTY4
+    ZGVkMjE4ZGExMGIwOTZhOGViMTk3ZTY5NmI2YmZkYmNjZjMwZjU=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+### 0.1.0
+
+* Initial Release
+

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Darshan Sawardekar
+
+MIT License
+
+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 the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,291 @@
+## Encase [![Build Status][1]][2] [![Code Climate][3]][4] [![Dependency Status][5]][6]
+
+### Lightweight IOC Container for ruby.
+
+Encase is a library for using dependency injection within ruby
+applications. It provides a lightweight IOC Container that manages
+dependencies between your classes. It was written to assist with wiring
+of domain objects outside Rails applications to enable faster test
+suites.
+
+# Features
+
+* Stores objects, factories, and singletons
+* Declarative syntax for specifying dependencies
+* Simple DSL for configuring the container
+* Support for nested containers
+* Support for lazy initialization
+
+## Usage
+
+Consider a `Worker` class that has a dependency on a `Logger`. We would
+like this dependency to be available to the worker when it is created.
+
+First we create a container object and declare the dependencies.
+
+```ruby
+require 'encase/container'
+
+container = Container.new
+container.configure do
+  object :logger, Logger.new
+  factory :worker, Worker
+end
+```
+
+Then we declare the `logger` dependency in the Worker class by including
+the `Encase` module into it and using the `needs` declaration.
+
+```ruby
+require 'encase'
+
+class Worker
+  include Encase
+
+  needs :logger
+end
+```
+
+That's it! Now we can create a new `Worker` by looking up the `:worker`
+key on the Container.
+
+```ruby
+my_worker = container.lookup('worker')
+my_worker.logger.is_a?(Logger) # true
+```
+
+## Container Configuration
+
+Containers are configured using a mini DSL in a `configure` method.
+Container items are stored with ruby `symbols` and are used to later lookup the object.
+
+```ruby
+container.configure do
+  # declarations go here
+end
+```
+
+The declarations supported are listed below.
+
+### Object
+
+Objects are pre existing entities that have already been created in your
+system. They are stored and returned as is without any modification. To
+store objects use the `object` declaration.
+
+```ruby
+container.configure do
+  object :key, value
+end
+```
+
+### Factory
+
+A Factory can be stored with the container to create instances of a
+class with it's dependencies auto-injected. On every lookup a new
+instance of that class will be returned.
+
+```ruby
+container.configure do
+  factory :key, TheClass
+end
+```
+
+### Singleton
+
+A Singleton is similar to a Factory. However it caches the instance
+created on the first lookup and returns that instance on every
+subsequent lookups.
+
+```ruby
+container.configure do
+  singleton :key, TheSingletonClass
+end
+```
+
+## Declaring Dependencies
+
+To specify dependencies of a class, you use the `needs` declaration. It
+takes an array of symbols corresponding to the keys of the dependencies
+stored in the container. Multiple `needs` declarations are also supported.
+
+```ruby
+require 'encase'
+
+class Worker
+  include Encase
+
+  needs :a, :b, :c
+  needs :one
+  needs :two
+  needs :three
+end
+```
+
+## Lazy Initialization
+
+Encase allows storage of dependencies lazily. This can be useful if the
+dependencies aren't ready at the time of container configuration. But
+will ready before lookup.
+
+Lazy initialization is done by passing a `block` to the DSL declaration
+instead of a value. Here `:key`'s block will be evaluated before the
+first lookup.
+
+```ruby
+container.configure do
+  object :key do
+    value
+  end
+end
+```
+
+The block can optionally take an argument equal to the container object
+itself. You can use this to conditionally resolve the value based on
+other objects in the container or elsewhere.
+
+```ruby
+container.configure do
+  object :key do |c|
+    value
+  end
+end
+```
+
+## Nested Containers
+
+Containers can also be nested within other containers. This allows grouping
+dependencies within different contexts of your application. When looking
+up keys, parent containers are queried when a key is not found in a
+child container.
+
+```ruby
+parent_container = Container.new
+parent_container.configure do
+  object :logger, Logger.new
+  factory :worker, Worker
+end
+
+child_container = parent_container.child
+child_container.configure do
+  factory :worker, CustomWorker
+end
+
+child_container.lookup(:logger) # from parent_container
+child_container.lookup(:worker) # CustomWorker
+```
+
+Here the `child_container` will use `CustomWorker` for resolving
+`:worker`. While the `:logger` will be looked up from the
+`parent_container`
+
+## Accessors
+
+Encase creates `accessor` methods corresponding to each declared `need`
+in the class. A `container` accessor is also injected into the class for
+looking up other dependencies at runtime.
+
+```ruby
+class Worker
+  include Encase
+
+  needs :one, :two, :three
+end
+
+worker = container.lookup('worker')
+worker.one
+worker.two
+worker.three
+worker.container
+```
+
+## Lifecycle
+
+An `on_inject` event hook is provided to container items after their
+dependencies are injected. Any post injection initialization can be
+carried out here.
+
+```ruby
+class Worker
+  include Encase
+
+  needs :logger
+
+  def on_inject
+    logger.log('Worker is ready')
+  end
+end
+```
+
+## Testing
+
+Encase significantly simplifies testability of objects. In the earlier
+example in order to test that the logger is indeed called by the worker
+we can register the worker as a `mock`. Then verify that this mock was called.
+
+```ruby
+describe Worker do
+  let(:container) {
+    container = Container.new
+    container.configure do
+      factory :worker, Worker
+    end
+
+    container
+  }
+
+  it 'logs message to the logger' do
+    logger = double()
+    logger.should_receive(:log).with(anything())
+
+    container.object logger, double(:log => true)
+
+    worker = container.lookup(:worker)
+    worker.start()
+  end
+end
+```
+
+Using the Encase created `accessor` methods it is also possible to
+manually assign the dependencies. Below `logger` is directly assigned to
+the `worker` without requiring a container.
+
+```ruby
+  it 'logs message to the logger' do
+    logger = double()
+    logger.should_receive(:log).with(anything())
+
+    worker = Worker.new
+    worker.logger = logger
+    worker.start()
+  end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'encase'
+
+And then execute:
+
+    $ bundle install
+
+# System Requirements
+
+Encase has been tested to work on these platforms.
+
+* ruby 1.9.2
+* ruby 1.9.3
+* ruby 2.0.0
+
+## Contributing
+
+See contributing guidelines for Portkey.
+
+[1]: https://travis-ci.org/dsawardekar/encase.png
+[2]: https://travis-ci.org/dsawardekar/encase
+[3]: https://codeclimate.com/github/dsawardekar/encase.png
+[4]: https://codeclimate.com/github/dsawardekar/encase
+[5]: https://gemnasium.com/dsawardekar/encase.png
+[6]: https://gemnasium.com/dsawardekar/encase

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Run rspec'
+RSpec::Core::RakeTask.new(:spec)
+
+desc 'Default task :test'
+task :default => :test
+
+desc 'Run tests'
+task :test => :spec

data/encase.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'encase/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "encase"
+  spec.version       = Encase::VERSION
+  spec.authors       = ["Darshan Sawardekar"]
+  spec.email         = ["darshan@sawardekar.org"]
+  spec.summary       = %q{Lightweight IOC Container for ruby.}
+  spec.description   = %q{Encase is a library for using dependency injection within ruby applications. It provides a lightweight IOC Container that manages dependencies between your classes. It was written to assist with wiring of domain objects outside Rails applications to enable faster test suites.}
+  spec.homepage      = "https://github.com/dsawardekar/encase"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+end

data/lib/encase.rb

@@ -0,0 +1,8 @@
+require 'encase/version'
+require 'encase/encaseable'
+
+module Encase
+  def self.included(base)
+    base.extend Encaseable
+  end
+end

data/lib/encase/container.rb

@@ -0,0 +1,80 @@
+require 'encase/container_item_factory'
+
+module Encase
+  class Container
+    attr_accessor :parent
+
+    def initialize(parent = nil)
+      @parent = parent
+      @items = {}
+    end
+
+    def contains?(key)
+      @items.key?(key)
+    end
+
+    def inject(object)
+      klass = object.class
+      if klass.respond_to?(:needs_to_inject)
+        needs_to_inject = klass.needs_to_inject
+        needs_to_inject.each do |need|
+          object.instance_variable_set(
+            "@#{need}", lookup(need)
+          )
+        end
+
+        object.container = self if object.respond_to?(:container)
+        object.on_inject() if object.respond_to?(:on_inject)
+
+        true
+      else
+        false
+      end
+    end
+
+    def register(type, key, value, block)
+      item = ContainerItemFactory.build(type, self)
+      item.store(key, value || block)
+      @items[key] = item
+    end
+
+    def unregister(key)
+      @items.delete(key)
+    end
+
+    def clear
+      @items.clear
+    end
+
+    def object(key, value = nil, &block)
+      register('object', key, value, block)
+    end
+
+    def factory(key, value = nil, &block)
+      register('factory', key, value, block)
+    end
+
+    def singleton(key, value = nil, &block)
+      register('singleton', key, value, block)
+    end
+
+    def lookup(key)
+      if contains?(key)
+        item = @items[key]
+        item.instance
+      elsif !parent.nil?
+        parent.lookup(key)
+      else
+        raise KeyError.new("Key:#{key} not found in container.")
+      end
+    end
+
+    def configure(&block)
+      instance_exec(&block)
+    end
+
+    def child
+      Container.new(self)
+    end
+  end
+end

data/lib/encase/container_item.rb

@@ -0,0 +1,55 @@
+module Encase
+  class ContainerItem
+    attr_accessor :container
+    attr_accessor :key
+    attr_accessor :value
+    attr_accessor :reified_value
+
+    def initialize(container)
+      self.container = container
+    end
+
+    def store(key, value)
+      self.key = key
+      self.value = value
+    end
+
+    def inject(object)
+      self.container.inject(object)
+    end
+
+    def reify
+      return false if reified?
+
+      if value.is_a? Proc
+        if value.arity == 1
+          self.reified_value = value.call(container)
+        else
+          self.reified_value = value.call
+        end
+      else
+        self.reified_value = value
+      end
+
+      true
+    end
+
+    def reified?
+      !self.reified_value.nil?
+    end
+
+    # returns just the reified value by default
+    def fetch
+      reified_value
+    end
+
+    # public api
+    def instance
+      reify unless reified?
+      object = fetch
+      inject(object)
+
+      object
+    end
+  end
+end

data/lib/encase/container_item_factory.rb

@@ -0,0 +1,21 @@
+module Encase
+  require_relative 'object_item'
+  require_relative 'factory_item'
+  require_relative 'singleton_item'
+
+  class ContainerItemFactory
+    def self.build(type, container)
+      container_item_for(type).new(container)
+    end
+
+    def self.container_item_for(type)
+      case type
+      when 'object' then ObjectItem
+      when 'factory' then FactoryItem
+      when 'singleton' then SingletonItem
+      else
+        ContainerItem
+      end
+    end
+  end
+end

data/lib/encase/encaseable.rb

@@ -0,0 +1,22 @@
+module Encase
+  module Encaseable
+    def needs(*deps)
+      if @needs_to_inject
+        @needs_to_inject.concat(deps)
+      else
+        @needs_to_inject = deps
+        attr_accessor :container
+      end
+
+      attr_accessor *deps
+    end
+
+    def needs_to_inject
+      @needs_to_inject
+    end
+
+    def needs_to_inject=(value)
+      @needs_to_inject = value
+    end
+  end
+end

data/lib/encase/factory_item.rb

@@ -0,0 +1,9 @@
+module Encase
+  require_relative 'container_item'
+
+  class FactoryItem < ContainerItem
+    def fetch
+      reified_value.new
+    end
+  end
+end

data/lib/encase/object_item.rb

@@ -0,0 +1,15 @@
+module Encase
+  require_relative 'container_item'
+
+  class ObjectItem < ContainerItem
+    attr_accessor :injected
+
+    def inject(object)
+      if self.injected
+        false
+      else
+        self.injected = super(object)
+      end
+    end
+  end
+end

data/lib/encase/singleton_item.rb

@@ -0,0 +1,12 @@
+module Encase
+  require_relative 'factory_item'
+
+  class SingletonItem < FactoryItem
+    attr_accessor :singleton
+
+    def fetch
+      self.singleton = super unless self.singleton
+      self.singleton
+    end
+  end
+end

data/lib/encase/version.rb

@@ -0,0 +1,3 @@
+module Encase
+  VERSION = "0.1.0"
+end

data/portkey.json

@@ -0,0 +1,10 @@
+{
+  "lib/encase/*.rb": {
+    "type": "container",
+    "test": "spec/lib/encase/%s_spec.rb"
+  },
+  "spec/lib/encase/*_spec.rb": {
+    "type": "spec",
+    "alternate": "lib/encase/%s.rb"
+  }
+}

data/spec/lib/encase/container_item_factory_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'encase/container_item_factory'
+require 'encase/container_item'
+require 'encase/object_item'
+require 'encase/factory_item'
+require 'encase/singleton_item'
+
+module Encase
+  shared_examples "a container_item_factory" do
+    it 'finds container_item\'s constructor' do
+      expect(
+        ContainerItemFactory.container_item_for(type)
+      ).to eq(type_constructor)
+    end
+
+    it 'builds container_item' do
+      expect(
+        ContainerItemFactory.build(type, container)
+      ).to be_a(type_constructor)
+    end
+  end
+
+  describe ContainerItemFactory do
+    let(:container) { double() }
+
+    context 'with object type' do
+      let(:type) { 'object' }
+      let(:type_constructor) { ObjectItem }
+
+      it_behaves_like 'a container_item_factory'
+    end
+
+    context 'with factory type' do
+      let(:type) { 'factory' }
+      let(:type_constructor) { FactoryItem }
+
+      it_behaves_like 'a container_item_factory'
+    end
+
+    context 'with singleton type' do
+      let(:type) { 'singleton' }
+      let(:type_constructor) { SingletonItem }
+
+      it_behaves_like 'a container_item_factory'
+    end
+  end
+end
+
+

data/spec/lib/encase/container_item_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'encase/container_item'
+
+module Encase
+  shared_examples 'a container_item' do
+    it 'stores container' do
+      expect(container_item.container).to eq(container)
+    end
+
+    it 'stores item key - value pair' do
+      expect(container_item.key).to eq(container_item_key)
+      expect(container_item.value).to eq(container_item_value)
+    end
+
+    it 'reifies value' do
+      container_item.reify()
+      expect(container_item.reified_value).to eq(container_item_value_reified)
+    end
+
+    it 'does not reify if already reified' do
+      container_item.reify()
+      expect(container_item.reified?).to be_true
+
+      expect(container_item.reify()).to be_false
+      expect(container_item.reified?).to be_true
+    end
+
+    it 'applies injection using container' do
+      container_item.reify()
+      expect(container_item.inject(container_item_value_reified)).to be_true
+    end
+
+    it 'applies injection before returning instance' do
+      container.stub(:inject) do |value|
+        expect(value).to eq(container_item_value_reified)
+      end
+
+      container_item.instance()
+    end
+
+    it 'returns instance for item' do
+      expect(container_item.instance).to eq(container_item_value_reified)
+    end
+  end
+
+  describe ContainerItem do
+    let(:container) do
+      c = double()
+      c.stub(:inject).with(anything()) { true }
+      c
+    end
+
+    let(:container_item_key) { :lorem }
+    let(:container_item_value) { 'lorem' }
+    let(:container_item_value_reified) { 'lorem' }
+    let(:container_item) {
+      c = ContainerItem.new(container)
+      c.store(container_item_key, container_item_value)
+      c
+    }
+
+    context 'without proc' do
+      it_behaves_like "a container_item"
+    end
+
+    context 'with proc' do
+      context 'without argument' do
+        let(:container_item_value) {
+          Proc.new do
+            'lorem'
+          end
+        }
+
+        it_behaves_like 'a container_item'
+      end
+
+      context 'with argument' do
+        let(:container_item_value) {
+          Proc.new do |c|
+            expect(c).to eq(container)
+            'lorem'
+          end
+        }
+
+        it_behaves_like 'a container_item'
+      end
+    end
+  end
+end

data/spec/lib/encase/container_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+require 'encase/container'
+require 'encase'
+
+module Encase
+  class Lorem
+  end
+
+  class MyBox
+    include Encase
+
+    needs :apples, :mangoes
+    needs :oranges
+  end
+
+  describe Container do
+    let(:container) {
+      Container.new
+    }
+
+    it 'can store objects' do
+      container.object(:lorem, 'lorem')
+      expect(container.lookup(:lorem)).to eq('lorem')
+    end
+
+    it 'can store factories' do
+      container.factory(:lorem, Lorem)
+      expect(container.lookup(:lorem)).to be_a(Lorem)
+    end
+
+    it 'can store singletons' do
+      container.singleton(:lorem, Lorem)
+      instance1 = container.lookup(:lorem)
+      instance2 = container.lookup(:lorem)
+
+      expect(instance1).to eq(instance2)
+    end
+
+    it 'can be configured with a DSL' do
+      container.configure do
+        object :lorem, 'lorem'
+        factory :lipsum, Lorem
+        singleton :dolor, Lorem
+      end
+
+      expect(container.lookup(:lorem)).to eq('lorem')
+      expect(container.lookup(:lipsum)).to be_a(Lorem)
+
+      instance1 = container.lookup(:dolor)
+      instance2 = container.lookup(:dolor)
+
+      expect(instance1).to eq(instance2)
+    end
+
+    it 'raises a KeyError for unknown keys' do
+      expect {
+        container.lookup(:unknown_key)
+      }.to raise_error(KeyError)
+    end
+
+    it 'can create nested containers' do
+      child = container.child()
+      grand_child = child.child()
+
+      expect(grand_child.parent).to eq(child)
+      expect(child.parent).to eq(container)
+      expect(container.parent).to be_nil
+    end
+
+    it 'can lookup values from nested containers' do
+      child = container.child()
+      grand_child = child.child()
+
+      container.object(:lorem, 'in_container')
+      child.object(:lorem, 'in_child')
+      grand_child.object(:lorem, 'in_grand_child')
+
+      expect(grand_child.lookup(:lorem)).to eq('in_grand_child')
+
+      grand_child.unregister(:lorem)
+      expect(grand_child.lookup(:lorem)).to eq('in_child')
+
+      child.unregister(:lorem)
+      expect(grand_child.lookup(:lorem)).to eq('in_container')
+    end
+
+    it 'can clear the container store' do
+      container.object(:lorem, 'lorem')
+      container.object(:ipsum, 'ipsum')
+      container.object(:dolor, 'dolor')
+
+      container.clear
+
+      expect(container.contains?(:lorem)).to be_false
+      expect(container.contains?(:ipsum)).to be_false
+      expect(container.contains?(:dolor)).to be_false
+    end
+
+    it 'can inject dependencies' do
+      container.configure do
+        object :apples, 10
+        object :mangoes, 20
+        object :oranges, 30
+        factory :box, MyBox
+      end
+
+      box = container.lookup(:box)
+      expect(box.apples).to eq(10)
+      expect(box.mangoes).to eq(20)
+      expect(box.oranges).to eq(30)
+    end
+
+    it 'can inject dependencies lazily' do
+      container.configure do
+        object :apples, -> { 10 }
+        object :mangoes, -> { 20 }
+        object :oranges, -> { 30 }
+        factory :box, -> { MyBox }
+      end
+
+      box = container.lookup(:box)
+      expect(box.apples).to eq(10)
+      expect(box.mangoes).to eq(20)
+      expect(box.oranges).to eq(30)
+    end
+
+    it 'assigns container on injection' do
+      class DummyObjectToBeInjected
+        include Encase
+        needs :lorem
+      end
+
+      container.object(:lorem, 'lorem')
+      container.factory(:dummy, DummyObjectToBeInjected)
+
+      dummy = container.lookup(:dummy)
+      expect(dummy.container).to eq(container)
+    end
+
+    it 'call on_inject hook after injection' do
+      class DummyWithOnInject
+        include Encase
+        needs :lorem
+        attr_accessor :injected
+
+        def on_inject
+          self.injected = true
+        end
+      end
+
+      container.object(:lorem, 'lorem')
+      container.factory(:dummy, DummyWithOnInject)
+
+      dummy = container.lookup(:dummy)
+      expect(dummy.injected).to be_true
+    end
+
+    context 'Performance', :benchmark => true do
+      require 'benchmark'
+
+      it 'can store 100s of dependencies quickly' do
+        runtime = Benchmark.realtime do
+          container.configure do
+            10000.times do |i|
+              item = "item#{i}"
+              object item.to_sym, item
+            end
+          end
+        end
+
+        expect(runtime).to be < 0.1
+      end
+
+      it 'can lookup 100s of dependencies quickly' do
+        class ClassWithManyDeps
+          include Encase
+
+          100.times do |i|
+            needs "item#{i}".to_sym
+          end
+        end
+
+        container.configure do
+          100.times do |i|
+            item = "item#{i}"
+            object item.to_sym, item
+          end
+
+          factory :lorem, ClassWithManyDeps
+        end
+
+        runtime = Benchmark.realtime do
+          100.times do |i|
+            container.lookup(:lorem)
+          end
+        end
+
+        expect(runtime).to be < 0.1
+      end
+    end
+  end
+end

data/spec/lib/encase/encaseable_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'encase'
+
+class EmptyBox
+end
+
+class Box
+  include Encase
+
+  needs :apples, :mangoes
+  needs :oranges
+end
+
+describe 'Encaseable' do
+  let(:box) { Box.new }
+  let(:empty_box) { EmptyBox.new }
+
+  it 'creates accessors if needs are specified' do
+    expect(Box).to respond_to(:needs_to_inject)
+    expect(box).to respond_to(:container)
+    expect(box).to respond_to(:apples)
+    expect(box).to respond_to(:mangoes)
+    expect(box).to respond_to(:oranges)
+  end
+
+  it 'does not create accessors if needs are not specified' do
+    expect(EmptyBox).to_not respond_to(:needs_to_inject)
+    expect(empty_box).to_not respond_to(:container)
+    expect(empty_box).to_not respond_to(:apples)
+    expect(empty_box).to_not respond_to(:mangoes)
+    expect(empty_box).to_not respond_to(:oranges)
+  end
+
+  it 'stores provided dependencies for later lookup' do
+    expect(box.class.needs_to_inject).to match_array([:apples, :mangoes, :oranges])
+  end
+end

data/spec/lib/encase/factory_item_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'encase/factory_item'
+
+module Encase
+  class MyClass
+  end
+
+  describe FactoryItem do
+    let(:container) {
+      c = double()
+      c.stub(:inject).with(anything()) { true }
+      c
+    }
+
+    let(:factory_item) {
+      f = FactoryItem.new(container)
+      f.store(:lorem, MyClass)
+      f
+    }
+
+    it 'creates a new instance on every fetch' do
+      factory_item.reify()
+
+      instance1 = factory_item.fetch()
+      instance2 = factory_item.fetch()
+
+      expect(instance1).to_not eq(instance2)
+    end
+
+    it 'applies injection on created instance' do
+      container.stub(:inject) do |to_inject|
+        expect(to_inject).to be_a(MyClass)
+        true
+      end
+
+      factory_item.instance
+    end
+  end
+end

data/spec/lib/encase/object_item_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'encase/object_item'
+
+module Encase
+  describe ObjectItem do
+    let(:container) {
+      c = double()
+      c.stub(:inject).with(anything()) { true }
+      c
+    }
+
+    let(:object_item) {
+      o = ObjectItem.new(container)
+      o.store(:lorem, 'lorem')
+      o
+    }
+
+    it 'applies injection if not injected' do
+      expect(object_item.inject('lorem')).to be_true
+      expect(object_item.injected).to be_true
+    end
+
+    it 'does not apply injection if already injected' do
+      object_item.inject('lorem')
+
+      expect(object_item.inject('lorem')).to be_false
+      expect(object_item.injected).to be_true
+    end
+  end
+end

data/spec/lib/encase/singleton_item_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'encase/singleton_item'
+
+module Encase
+  class MySingletonClass
+  end
+
+  describe SingletonItem do
+    let(:container) {
+      c = double()
+      c.stub(:inject).with(anything()) { true }
+      c
+    }
+
+    let(:singleton_item) {
+      s = SingletonItem.new(container)
+      s.store(:lorem, MySingletonClass)
+      s
+    }
+
+    it 'returns the same object on every fetch' do
+      singleton_item.reify()
+
+      instance1 = singleton_item.fetch()
+      instance2 = singleton_item.fetch()
+
+      expect(instance1).to eq(instance2)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH << '../lib'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: encase
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Darshan Sawardekar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  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: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+description: Encase is a library for using dependency injection within ruby applications.
+  It provides a lightweight IOC Container that manages dependencies between your classes.
+  It was written to assist with wiring of domain objects outside Rails applications
+  to enable faster test suites.
+email:
+- darshan@sawardekar.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- encase.gemspec
+- lib/encase.rb
+- lib/encase/container.rb
+- lib/encase/container_item.rb
+- lib/encase/container_item_factory.rb
+- lib/encase/encaseable.rb
+- lib/encase/factory_item.rb
+- lib/encase/object_item.rb
+- lib/encase/singleton_item.rb
+- lib/encase/version.rb
+- portkey.json
+- spec/lib/encase/container_item_factory_spec.rb
+- spec/lib/encase/container_item_spec.rb
+- spec/lib/encase/container_spec.rb
+- spec/lib/encase/encaseable_spec.rb
+- spec/lib/encase/factory_item_spec.rb
+- spec/lib/encase/object_item_spec.rb
+- spec/lib/encase/singleton_item_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dsawardekar/encase
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Lightweight IOC Container for ruby.
+test_files:
+- spec/lib/encase/container_item_factory_spec.rb
+- spec/lib/encase/container_item_spec.rb
+- spec/lib/encase/container_spec.rb
+- spec/lib/encase/encaseable_spec.rb
+- spec/lib/encase/factory_item_spec.rb
+- spec/lib/encase/object_item_spec.rb
+- spec/lib/encase/singleton_item_spec.rb
+- spec/spec_helper.rb