dependency_injection 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ab031c6a6cfce9dd524b8f57851aa6b0ac19ed47
+  data.tar.gz: e3e3f3bf5b38432373e2352bca3e3790c342ce0c
+SHA512:
+  metadata.gz: 8ab8a953e957e6578c159a09a648a2914447e35ed10153d67b8a7774bfd7479817b60bab6a2db733557e9dfec41daa3677f1090c9151ed48f09e6f59febb4ffb
+  data.tar.gz: 46c38816ad28d38c93ad1de72cc770e5113df3cc2900f71754dfeacf1b244093cf077d8ff6f4385c0fc78190a2eeaf6c4601ed98b2da2e22f3d33918460d4517

data/.gitignore

@@ -0,0 +1 @@
+coverage

data/.ruby-gemset

@@ -0,0 +1 @@
+dependency_injection

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0

data/.travis.yml

@@ -0,0 +1,8 @@
+language: 'ruby'
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - jruby-19mode
+  - rbx-19mode
+  - 2.0.0
+script: 'bundle exec rake test'

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'coveralls'
+gem 'minitest'
+gem 'mocha'
+gem 'rake'

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    dependency_injection (0.1.0)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.14)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    colorize (0.5.8)
+    coveralls (0.6.7)
+      colorize
+      multi_json (~> 1.3)
+      rest-client
+      simplecov (>= 0.7)
+      thor
+    i18n (0.6.4)
+    metaclass (0.0.1)
+    mime-types (1.23)
+    minitest (5.0.6)
+    mocha (0.14.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.7.8)
+    rake (10.1.0)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    thor (0.18.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  coveralls
+  dependency_injection!
+  minitest
+  mocha
+  rake

data/README.md

@@ -0,0 +1,6 @@
+# Dependency Injection for Ruby
+[![Build Status](https://travis-ci.org/kdisneur/dependency_injection-ruby.png?branch=master)](https://travis-ci.org/kdisneur/dependency_injection-ruby) [![Coverage Status](https://coveralls.io/repos/kdisneur/dependency_injection-ruby/badge.png?branch=master)](https://coveralls.io/r/kdisneur/dependency_injection-ruby?branch=master) [![Code Climate](https://codeclimate.com/github/kdisneur/dependency_injection-ruby.png)](https://codeclimate.com/github/kdisneur/dependency_injection-ruby)
+
+It's a WIP for now.
+
+You can find some examples in the [examples folder](https://github.com/kdisneur/dependency_injection-ruby/tree/master/examples)

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |test|
+  test.libs   << 'test'
+  test.pattern = 'test/**/test_*.rb'
+end

data/dependency_injection.gemspec

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+require 'dependency_injection/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dependency_injection'
+  spec.version       = DependencyInjection::VERSION
+  spec.summary       = 'Dependency Injection system for Ruby'
+  spec.description   = 'A fully customizable Dependency injection system for Ruby'
+  spec.homepage      = 'https://github.com/kdisneur/dependency_injection'
+  spec.license       = 'MIT'
+  spec.authors       = ['Kevin Disneur']
+  spec.email         = 'kevin@koboyz.org'
+  spec.files         = `git ls-files`.split($/)
+  spec.require_paths = %w(lib)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+
+  spec.add_dependency('activesupport')
+end

data/examples/basic_usage.rb

@@ -0,0 +1,63 @@
+require 'dependency_injection/container'
+
+c = DependencyInjection::Container.new
+
+# 1 - No specific class initialization
+class Mailer
+  def send_mail(message)
+    puts "mail sent: #{message}"
+  end
+end
+
+c.register('mailer', 'Mailer')
+c.get('mailer').send_mail('Hello World')
+# => mail sent: Hello World
+
+Object.instance_eval { remove_const(:Mailer) }
+
+# 2 - constructor specific class initialization
+class Mailer
+  def initialize(transport)
+    @transport = transport
+  end
+
+  def send_mail(message)
+    puts "mail sent via #{@transport}: #{message}"
+  end
+end
+
+c.register('mailer', 'Mailer').add_argument('send_mail')
+c.get('mailer').send_mail('Hello World')
+# => mail sent via send_mail: Hello World
+
+Object.instance_eval { remove_const(:Mailer) }
+
+# 3 - method specific class initialization
+class Mailer
+  attr_accessor :transport
+
+  def send_mail(message)
+    puts "mail sent via #{self.transport}: #{message}"
+  end
+end
+
+c.register('mailer', 'Mailer').add_method_call('transport=', 'send_mail')
+c.get('mailer').send_mail('Hello World')
+# => mail sent via send_mail: Hello World
+
+# 4 - Mix of constructor and method specific class initialization
+class Mailer
+  attr_accessor :transport
+
+  def initialize(from)
+    @from = from
+  end
+
+  def send_mail(message)
+    puts "mail sent by #{@from} via #{self.transport}: #{message}"
+  end
+end
+
+c.register('mailer', 'Mailer').add_argument('jon@doe.com').add_method_call('transport=', 'send_mail')
+c.get('mailer').send_mail('Hello World')
+# => mail sent by jon@doe.com via send_mail: Hello World

data/examples/global_container_parameter.rb

@@ -0,0 +1,35 @@
+require 'dependency_injection/container'
+
+c = DependencyInjection::Container.new
+c.add_parameter('mailer.transport', 'sendmail')
+
+class Mailer
+  attr_accessor :transport
+
+  def send_mail(message)
+    puts "mail sent via #{transport}: #{message}"
+  end
+end
+
+# 1 - Simple global parameter
+c.register('mailer', 'Mailer').add_method_call('transport=', '%mailer.transport%')
+c.get('mailer').send_mail('Hello World')
+# => mail sent via send_mail: Hello World
+
+# 2 - Complex global parameter
+class NewsletterManager
+  def initialize(mailer)
+    @mailer = mailer
+  end
+
+  def send_mail(message)
+    puts 'newsletter'
+    @mailer.send_mail(message)
+  end
+end
+
+c.add_parameter('my.mailer', '@mailer')
+c.register('newsletter', 'NewsletterManager').add_argument('%my.mailer%')
+c.get('newsletter').send_mail('Hello World')
+# => newsletter
+#    mail sent via send_mail: Hello World

data/examples/inject_a_reference_to_another_dependency.rb

@@ -0,0 +1,48 @@
+require 'dependency_injection/container'
+
+c = DependencyInjection::Container.new
+
+# 1 - constructor specific class initialization
+class NewsletterManager
+  def initialize(mailer)
+    @mailer = mailer
+  end
+
+  def send_mail(message)
+    @mailer.send_mail(message)
+  end
+end
+
+class Mailer
+  def send_mail(message)
+    puts "mail sent: #{message}"
+  end
+end
+
+c.register('my.mailer', 'Mailer')
+c.register('newsletter', 'NewsletterManager').add_argument('@my.mailer')
+
+c.get('newsletter').send_mail('Hello World')
+# => mail sent: Hello World
+
+Object.instance_eval { remove_const(:NewsletterManager) }
+
+# 2 - method specific class initialization
+class NewsletterManager
+  attr_accessor :mailer, :from
+
+  def send_mail(message)
+    puts "mail sent by #{@from}"
+    @mailer.send_mail(message)
+  end
+end
+
+c.register('my.mailer', 'Mailer')
+c.register('newsletter', 'NewsletterManager')
+  .add_method_call('mailer=', '@my.mailer')
+  .add_method_call('from=', 'john@doe.com')
+
+c.get('newsletter').send_mail('Hello World')
+# => mail sent: Hello World
+
+Object.instance_eval { remove_const(:Mailer) }

data/examples/services.yml

@@ -0,0 +1,11 @@
+parameters:
+  mailer.transport: sendmail
+services:
+  my.mailer:
+    class: Mailer
+    calls:
+      - ['transport=', '%mailer.transport%']
+  newsletter:
+    class: NewsletterManager
+    arguments:
+      - '@my.mailer'

data/examples/yaml_configuration_file.rb

@@ -0,0 +1,29 @@
+require 'dependency_injection/container'
+require 'dependency_injection/loaders/yaml'
+
+c = DependencyInjection::Container.new
+loader = DependencyInjection::Loaders::Yaml.new(c)
+loader.load(File.join(File.dirname(File.expand_path(__FILE__)), 'services.yml'))
+
+class NewsletterManager
+  def initialize(mailer)
+    @mailer = mailer
+  end
+
+  def send_mail(message)
+    puts 'newletter'
+    @mailer.send_mail(message)
+  end
+end
+
+class Mailer
+  attr_accessor :transport
+
+  def send_mail(message)
+    puts "mail sent via #{self.transport}: #{message}"
+  end
+end
+
+c.get('newsletter').send_mail('Hello World')
+# => newletter
+#    mail sent via sendmail: Hello World

data/lib/dependency_injection/container.rb

@@ -0,0 +1,26 @@
+require 'dependency_injection/definition'
+
+module DependencyInjection
+  class Container
+    attr_reader :definitions, :parameters
+
+    def initialize
+      @definitions = {}
+      @parameters  = {}
+    end
+
+    def add_parameter(name, value)
+      @parameters[name] = value
+    end
+
+    def get(name)
+      if (definition = @definitions[name])
+        definition.object
+      end
+    end
+
+    def register(name, klass_name)
+      @definitions[name] = Definition.new(klass_name, self)
+    end
+  end
+end

data/lib/dependency_injection/definition.rb

@@ -0,0 +1,69 @@
+require 'active_support/core_ext/string/inflections'
+
+module DependencyInjection
+  class Definition
+    attr_accessor :klass_name, :arguments, :method_calls
+
+    def initialize(klass_name, container)
+      @container        = container
+      self.arguments    = []
+      self.klass_name   = klass_name
+      self.method_calls = {}
+    end
+
+    def add_argument(argument)
+      self.add_arguments(argument)
+    end
+
+    def add_arguments(*arguments)
+      self.arguments += arguments
+
+      self
+    end
+
+    def add_method_call(method_name, *arguments)
+      self.method_calls[method_name] = arguments
+
+      self
+    end
+
+    def klass
+      self.klass_name.constantize
+    end
+
+    def object
+      return @object if @object
+
+      @object = self.klass.new(*resolve(self.arguments))
+      self.method_calls.each { |method_name, arguments| @object.send(method_name, *resolve(arguments)) }
+
+      @object
+    end
+
+  private
+
+    def resolve(arguments)
+      resolve_references(resolve_container_parameters(arguments))
+    end
+
+    def resolve_container_parameters(arguments)
+      arguments.map do |argument|
+        if /^%(?<parameter_name>.*)%$/ =~ argument
+          @container.parameters[parameter_name]
+        else
+          argument
+        end
+      end
+    end
+
+    def resolve_references(arguments)
+      arguments.map do |argument|
+        if /^@(?<reference_name>.*)/ =~ argument
+          @container.get(reference_name)
+        else
+          argument
+        end
+      end
+    end
+  end
+end

data/lib/dependency_injection/loaders/yaml.rb

@@ -0,0 +1,35 @@
+require 'yaml'
+
+module DependencyInjection
+  module Loaders
+    class Yaml
+      def initialize(container)
+        @container = container
+      end
+
+      def load(filename)
+        file = YAML::load_file(filename)
+        add_parameters(file['parameters']) if file['parameters']
+        add_services(file['services']) if file['services']
+      end
+
+    private
+
+      def add_parameters(parameters)
+        parameters.each { |name, value| @container.add_parameter(name, value) }
+      end
+
+      def add_services(services)
+        services.each { |name, parameters| add_service(name, parameters) }
+      end
+
+      def add_service(name, parameters)
+        definition = @container.register(name, parameters['class'])
+        definition.add_arguments(*parameters['arguments']) if parameters['arguments']
+        if parameters['calls']
+          parameters['calls'].each { |method_name, arguments| definition.add_method_call(method_name, *arguments) }
+        end
+      end
+    end
+  end
+end

data/lib/dependency_injection/version.rb

@@ -0,0 +1,3 @@
+module DependencyInjection
+  VERSION = '0.1.0'
+end

data/test/dependency_injection/loaders/test_yaml.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+require 'dependency_injection/loaders/yaml'
+
+class TestYaml < Minitest::Test
+  def setup
+    @container   = mock
+    @yaml_loader = DependencyInjection::Loaders::Yaml.new(@container)
+  end
+
+  def test_loading_file_without_parameters
+    YAML.stubs(:load_file).with('services.yml').returns({ 'services' => [] })
+    @yaml_loader.expects(:add_parameters).never
+
+    @yaml_loader.load('services.yml')
+  end
+
+  def test_loading_file_with_parameters
+    YAML.stubs(:load_file).with('services.yml').returns({'parameters' => { 'key_1' => 'value_1' }, 'services' => [] })
+    @yaml_loader.expects(:add_parameters).with({ 'key_1' => 'value_1' })
+
+    @yaml_loader.load('services.yml')
+  end
+
+  def test_loading_file_without_services
+    YAML.stubs(:load_file).with('services.yml').returns({ 'parameters' => [] })
+    @yaml_loader.expects(:add_services).never
+
+    @yaml_loader.load('services.yml')
+  end
+
+  def test_loading_file_with_services
+    YAML.stubs(:load_file).with('services.yml').returns({ 'parameters' => {}, 'services' => { 'service_1' => { 'class' => 'MyKlass' }}})
+    @yaml_loader.expects(:add_services).with({ 'service_1' => { 'class' => 'MyKlass' }})
+
+    @yaml_loader.load('services.yml')
+  end
+
+  def test_adding_parameters
+    @container.expects(:add_parameter).with('key_1', 'value_1')
+    @container.expects(:add_parameter).with('key_2', 'value_2')
+
+    @yaml_loader.send(:add_parameters, { 'key_1' => 'value_1', 'key_2' => 'value_2' })
+  end
+
+  def test_adding_services
+    @yaml_loader.expects(:add_service).with('key_1', { 'param_1' => 'value_1', 'param_2' => 'value_2' })
+    @yaml_loader.expects(:add_service).with('key_2', { 'param_1' => 'value_1' })
+
+    @yaml_loader.send(:add_services, { 'key_1' => { 'param_1' => 'value_1', 'param_2' => 'value_2' },
+                                       'key_2' => { 'param_1' => 'value_1' }})
+  end
+
+  def test_adding_service_without_parameters
+    definition = mock
+    @container.stubs(:register).with('key_1', 'MyKlass').returns(definition)
+    definition.expects(:add_arguments).never
+
+    @yaml_loader.send(:add_service, 'key_1', { 'class' => 'MyKlass' })
+  end
+
+  def test_adding_service_with_parameters
+    definition = mock
+    @container.stubs(:register).with('key_1', 'MyKlass').returns(definition)
+    definition.expects(:add_arguments).with('arg_1', 'arg_2')
+
+    @yaml_loader.send(:add_service, 'key_1', { 'class' => 'MyKlass', 'arguments' => ['arg_1', 'arg_2'] })
+  end
+
+  def test_adding_service_without_method_calls
+    definition = mock
+    @container.stubs(:register).with('key_1', 'MyKlass').returns(definition)
+    definition.expects(:add_method_call).never
+
+    @yaml_loader.send(:add_service, 'key_1', { 'class' => 'MyKlass' })
+  end
+
+  def test_adding_service_with_method_calls
+    definition = mock
+    @container.stubs(:register).with('key_1', 'MyKlass').returns(definition)
+    definition.expects(:add_method_call).with('method_1', 'arg_1')
+    definition.expects(:add_method_call).with('method_2', 'arg_1', 'arg_2')
+    definition.expects(:add_method_call).with('method_3', %w(arg_1 arg_2))
+
+    @yaml_loader.send(:add_service, 'key_1', { 'class' => 'MyKlass', 'calls' => { 'method_1' => ['arg_1'],
+                                                                                  'method_2' => ['arg_1', 'arg_2'],
+                                                                                  'method_3' => [['arg_1', 'arg_2']] }})
+  end
+end

data/test/dependency_injection/test_container.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+require 'dependency_injection/container'
+
+class TestContainer < Minitest::Test
+  def setup
+    @container    = DependencyInjection::Container.new
+    @final_object = mock
+    @definition   = mock
+    @definition.stubs(:object).returns(@final_object)
+    @another_definition = mock
+    DependencyInjection::Definition.stubs(:new).with('MyDefinition', @container).returns(@definition)
+    DependencyInjection::Definition.stubs(:new).with('MyOtherDefinition', @container).returns(@another_definition)
+  end
+
+  def test_adding_new_parameter
+    @container.add_parameter('my.parameter', 'value')
+    assert_equal({ 'my.parameter' => 'value' }, @container.parameters)
+  end
+
+  def test_adding_an_already_existing_parameter
+    @container.add_parameter('my.parameter', 'value')
+    assert_equal({ 'my.parameter' => 'value' }, @container.parameters)
+
+    @container.add_parameter('my.parameter', 'other value')
+    assert_equal({ 'my.parameter' => 'other value' }, @container.parameters)
+  end
+
+  def test_getting_a_registered_definition_returns_an_object
+    @container.register('my_definition', 'MyDefinition')
+    assert_equal(@final_object, @container.get('my_definition'))
+  end
+
+  def test_getting_a_not_registered_definition_returns_nil
+    assert_equal(nil, @container.get('my_definition'))
+  end
+
+  def test_registering_a_definition
+    @container.register('my_definition', 'MyDefinition')
+
+    assert_equal({ 'my_definition' => @definition }, @container.definitions)
+  end
+
+  def test_registering_a_class_return_a_definition_object
+    assert_equal(@definition, @container.register('my_definition', 'MyDefinition'))
+  end
+
+  def test_registering_an_already_existing_definition_replace_it
+    @container.register('my_definition', 'MyDefinition')
+    assert_equal({ 'my_definition' => @definition }, @container.definitions)
+
+    @container.register('my_definition', 'MyOtherDefinition')
+    assert_equal({ 'my_definition' => @another_definition }, @container.definitions)
+  end
+end

data/test/dependency_injection/test_definition.rb

@@ -0,0 +1,134 @@
+require 'test_helper'
+require 'dependency_injection/definition'
+
+class TestDefinition < Minitest::Test
+  def setup
+    @container  = mock
+    @definition = DependencyInjection::Definition.new('MyClass', @container)
+  end
+
+  def test_adding_an_argument
+    @definition.add_argument('new argument')
+
+    assert_equal(['new argument'], @definition.arguments)
+  end
+
+  def test_adding_an_argument_returns_definition_object
+    assert_equal(@definition, @definition.add_argument('new argument'))
+  end
+
+  def test_adding_several_arguments
+    @definition.add_arguments('first', 'second')
+
+    assert_equal(%w(first second), @definition.arguments)
+  end
+
+  def test_adding_several_arguments_returns_definition_object
+    assert_equal(@definition, @definition.add_arguments('first', 'second'))
+  end
+
+  def test_adding_additional_arguments
+    @definition.add_arguments('first')
+    assert_equal(%w(first), @definition.arguments)
+
+    @definition.add_arguments('second', 'third')
+    assert_equal(%w(first second third), @definition.arguments)
+  end
+
+  def test_adding_a_method_call_without_parameters
+    @definition.add_method_call('my_method')
+
+    assert_equal({ 'my_method' => [] }, @definition.method_calls)
+  end
+
+  def test_adding_a_method_call_with_parameters
+    @definition.add_method_call('my_method=', 'value')
+
+    assert_equal({ 'my_method=' => %w(value) }, @definition.method_calls)
+  end
+
+  def test_adding_a_method_call_returns_definition_object
+    assert_equal(@definition, @definition.add_method_call('my_method'))
+  end
+
+  def test_getting_klass
+    klass      = mock
+    klass_name = 'MyClass'
+    @definition.stubs(:klass_name).returns(klass_name)
+    klass_name.stubs(:constantize).returns(klass)
+
+    assert_equal(klass, @definition.klass)
+  end
+
+  def test_getting_object_with_arguments
+    final_object = mock
+    final_class  = mock
+    @definition.stubs(:klass).returns(final_class)
+    @definition.add_arguments('first', 'second')
+    final_class.stubs(:new).with('first', 'second').returns(final_object)
+
+    assert_equal(final_object, @definition.object)
+  end
+
+  def test_getting_object_without_arguments
+    final_object = mock
+    final_class  = mock
+    @definition.stubs(:klass).returns(final_class)
+    final_class.stubs(:new).with.returns(final_object)
+
+    assert_equal(final_object, @definition.object)
+  end
+
+  def test_getting_object_with_method_calls
+    final_object = mock
+    final_class  = mock
+    @definition.stubs(:klass).returns(final_class)
+    final_class.stubs(:new).with.returns(final_object)
+    final_object.expects(:method_1).with
+    final_object.expects(:method_2).with('value')
+
+    @definition.add_method_call('method_1')
+    @definition.add_method_call('method_2', 'value')
+
+    @definition.object
+  end
+
+  def test_resolving_first_container_parameters
+    changed_arguments = mock
+    arguments         = mock
+    @definition.stubs(:resolve_references).returns(changed_arguments)
+    @definition.expects(:resolve_container_parameters).with(arguments)
+
+    @definition.send(:resolve, arguments)
+  end
+
+  def test_resolving_references_after_container_parameters
+    changed_arguments = mock
+    arguments         = mock
+    @definition.stubs(:resolve_container_parameters).with(arguments).returns(changed_arguments)
+    @definition.expects(:resolve_references).with(changed_arguments)
+
+    @definition.send(:resolve, arguments)
+  end
+
+  def test_resolving_container_parameters_without_parameters
+    assert_equal(%w(first, second), @definition.send(:resolve_container_parameters, %w(first, second)))
+  end
+
+  def test_resolving_container_parameters_with_parameters
+    @container.stubs(:parameters).returns({ 'parameter' => 'value' })
+
+    assert_equal(['first', 'value'], @definition.send(:resolve_container_parameters, %w(first %parameter%)))
+  end
+
+  def test_resolving_references_without_references
+    assert_equal(%w(first second), @definition.send(:resolve_references, %w(first second)))
+  end
+
+  def test_resolving_references_with_references
+    referenced_object = mock
+    @container.stubs(:get).with('reference.name').returns(referenced_object)
+
+    assert_equal(['first', referenced_object], @definition.send(:resolve_references, %w(first @reference.name)))
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'coveralls'
+Coveralls.wear! do
+  add_filter '/test/'
+end
+
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'mocha/setup'
+

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: dependency_injection
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kevin Disneur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A fully customizable Dependency injection system for Ruby
+email: kevin@koboyz.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-gemset
+- .ruby-version
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- dependency_injection.gemspec
+- examples/basic_usage.rb
+- examples/global_container_parameter.rb
+- examples/inject_a_reference_to_another_dependency.rb
+- examples/services.yml
+- examples/yaml_configuration_file.rb
+- lib/dependency_injection/container.rb
+- lib/dependency_injection/definition.rb
+- lib/dependency_injection/loaders/yaml.rb
+- lib/dependency_injection/version.rb
+- test/dependency_injection/loaders/test_yaml.rb
+- test/dependency_injection/test_container.rb
+- test/dependency_injection/test_definition.rb
+- test/test_helper.rb
+homepage: https://github.com/kdisneur/dependency_injection
+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.0.6
+signing_key: 
+specification_version: 4
+summary: Dependency Injection system for Ruby
+test_files:
+- test/dependency_injection/loaders/test_yaml.rb
+- test/dependency_injection/test_container.rb
+- test/dependency_injection/test_definition.rb
+- test/test_helper.rb