dependency_injection 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b69c7250ff09cc0ce7a0fc71f5de27823bfe809
-  data.tar.gz: 4eedfaf5417c9d83c05ede482a292c759dd9cdf7
+  metadata.gz: 2116ad6a0f9eb9fef58b268cd9413aa4fd8177c3
+  data.tar.gz: ed1755da4b8037d366fc95c3693c86ac9b346b28
 SHA512:
-  metadata.gz: 554a7b44ab7fa02021a1d562af254ef30571f78bde1e785b1eb0f5d76d5d20d4d6a6d2b262fcac162fc3fe6689ce5c6684315833e6020acc1d41826e0ef566c1
-  data.tar.gz: af2fcf51496d158883be89afbc4a34eff33b835742c210401b7b16187d6aa1ec9f13c2ba237230d57397e18405bc87e779ee2fc4ddf7298b9e6e692b34ff338c
+  metadata.gz: ab60bdcc326a550b133d8406c459d072670af4f259a50eb5cc5c1c9edf33b671d6e544f1871e27b88e90027befeb0477c1c681e43a3f6de7a0ec52f2a913110a
+  data.tar.gz: 770dcddd3fe38639736abae27599ef504934050f29b3766ca79efba18b5fbcdb0c5c56ffda141485f2d52fb6990060073ac657f61be6fbd7a440af6ff3c97223

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dependency_injection (0.1.1)
+    dependency_injection (0.2.0)
       activesupport
 
 GEM

data/examples/alias_definitions.rb

@@ -0,0 +1,19 @@
+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__)), 'alias_definitions.yml'))
+
+class Mailer
+  attr_accessor :transport
+
+  def send_mail(message)
+    puts "mail sent via #{self.transport}: #{message}"
+  end
+end
+
+puts c.get('my.mailer').class
+# => Mailer
+puts c.get('aliased.mailer').class
+# => Mailer

data/examples/alias_definitions.yml

@@ -0,0 +1,8 @@
+parameters:
+  mailer.transport: sendmail
+services:
+  my.mailer:
+    class: Mailer
+    method_call: ['transport=', '%mailer.transport%']
+  aliased.mailer:
+    alias: 'my.mailer'

data/examples/configurator_usage.rb

@@ -0,0 +1,27 @@
+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__)), 'configurator_usage.yml'))
+
+class MailerConfigurator
+  def initialize(transport)
+    @transport = transport
+  end
+
+  def configure(mailer)
+    mailer.transport = @transport
+  end
+end
+
+class Mailer
+  attr_accessor :transport
+
+  def send_mail(message)
+    puts "mail sent via #{self.transport}: #{message}"
+  end
+end
+
+c.get('my.mailer').send_mail('Hello World')
+#    mail sent via sendmail: Hello World

data/examples/configurator_usage.yml

@@ -0,0 +1,10 @@
+parameters:
+  mailer.transport: sendmail
+services:
+  mailer_configurator:
+    class: MailerConfigurator
+    arguments:
+      - '%mailer.transport%'
+  my.mailer:
+    class: Mailer
+    configurator: ['@mailer_configurator', 'configure']

data/examples/lazy_load_object.rb

@@ -0,0 +1,37 @@
+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__)), 'lazy_load_object.yml'))
+
+class NewsletterManager
+  def initialize(mailer)
+    @mailer = mailer
+  end
+
+  def send_mail(message)
+    puts 'newletter'
+    @mailer.send_mail(message)
+  end
+end
+
+class Mailer
+  def initialize
+    puts 'mailer loaded'
+  end
+
+  def send_mail(message)
+    puts "mail sent via: #{message}"
+  end
+end
+
+puts c.get('my.mailer').class
+# => ProxyObject
+puts c.get('my.newsletter_manager').class
+# => NewsletterManager
+
+c.get('my.newsletter_manager').send_mail('Hello World')
+# => newsletter
+#    mailer loaded
+#    mail sent : Hello World

data/examples/lazy_load_object.yml

@@ -0,0 +1,8 @@
+services:
+  my.mailer:
+    class: Mailer
+    lazy: true
+  my.newsletter_manager:
+    class: NewsletterManager
+    arguments:
+      - '@my.mailer'

data/examples/yaml_configuration_file.rb

@@ -3,7 +3,7 @@ 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'))
+loader.load(File.join(File.dirname(File.expand_path(__FILE__)), 'yaml_configuration_file.yml'))
 
 class NewsletterManager
   def initialize(mailer)

data/lib/dependency_injection/alias_definition.rb

@@ -0,0 +1,14 @@
+module DependencyInjection
+  class AliasDefinition
+    attr_accessor :alias_definition_name
+
+    def initialize(alias_definition_name, container)
+      @container                 = container
+      self.alias_definition_name = alias_definition_name
+    end
+
+    def object
+      @container.get(self.alias_definition_name)
+    end
+  end
+end

data/lib/dependency_injection/container.rb

@@ -1,4 +1,6 @@
+require 'dependency_injection/alias_definition'
 require 'dependency_injection/definition'
+require 'dependency_injection/lazy_definition'
 
 module DependencyInjection
   class Container
@@ -19,8 +21,13 @@ module DependencyInjection
       end
     end
 
-    def register(name, klass_name)
-      @definitions[name] = Definition.new(klass_name, self)
+    def register(name, klass_name, lazy=false)
+      definition = lazy ? LazyDefinition.new(klass_name, self) : Definition.new(klass_name, self)
+      @definitions[name] =definition
+    end
+
+    def register_alias(name, alias_definition_name)
+      @definitions[name] = AliasDefinition.new(alias_definition_name, self)
     end
   end
 end

data/lib/dependency_injection/definition.rb

@@ -2,7 +2,7 @@ require 'active_support/core_ext/string/inflections'
 
 module DependencyInjection
   class Definition
-    attr_accessor :klass_name, :arguments, :method_calls
+    attr_accessor :arguments, :configurator, :klass_name, :method_calls
 
     def initialize(klass_name, container)
       @container        = container
@@ -21,6 +21,12 @@ module DependencyInjection
       self
     end
 
+    def add_configurator(name, method_name)
+      self.configurator = [name, method_name]
+
+      self
+    end
+
     def add_method_call(method_name, *arguments)
       self.method_calls[method_name] = arguments
 
@@ -36,6 +42,11 @@ module DependencyInjection
 
       @object = self.klass.new(*resolve(self.arguments))
       self.method_calls.each { |method_name, arguments| @object.send(method_name, *resolve(arguments)) }
+      if self.configurator
+        name, method_name   = self.configurator
+        configurator_object = resolve([name]).first
+        configurator_object.send(method_name, @object)
+      end
 
       @object
     end

data/lib/dependency_injection/lazy_definition.rb

@@ -0,0 +1,12 @@
+require 'dependency_injection/definition'
+require 'dependency_injection/proxy_object'
+
+module DependencyInjection
+  class LazyDefinition < Definition
+    def object
+      return @proxy_object if @proxy_object
+
+      @proxy_object = ProxyObject.new { super }
+    end
+  end
+end

data/lib/dependency_injection/loaders/yaml.rb

@@ -15,6 +15,10 @@ module DependencyInjection
 
     private
 
+      def add_aliased_service(name, aliased_service_name)
+        @container.register_alias(name, aliased_service_name)
+      end
+
       def add_parameters(parameters)
         parameters.each { |name, value| @container.add_parameter(name, value) }
       end
@@ -24,8 +28,20 @@ module DependencyInjection
       end
 
       def add_service(name, parameters)
-        definition = @container.register(name, parameters['class'])
+        if parameters['alias']
+          add_aliased_service(name, parameters['alias'])
+        else
+          add_standard_service(name, parameters)
+        end
+      end
+
+      def add_standard_service(name, parameters)
+        lazy_load  = parameters['lazy'] || false
+        definition = @container.register(name, parameters['class'], lazy_load)
         definition.add_arguments(*parameters['arguments']) if parameters['arguments']
+        if (configurator = parameters['configurator'])
+          definition.add_configurator(configurator[0], configurator[1])
+        end
         if parameters['calls']
           parameters['calls'].each { |method_name, arguments| definition.add_method_call(method_name, *arguments) }
         end

data/lib/dependency_injection/proxy_object.rb

@@ -0,0 +1,11 @@
+module DependencyInjection
+  class ProxyObject
+    def initialize(&block)
+      @object = block
+    end
+
+    def method_missing(method_name, *args)
+      @object.call.send(method_name, *args)
+    end
+  end
+end

data/lib/dependency_injection/version.rb

@@ -1,3 +1,3 @@
 module DependencyInjection
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/test/dependency_injection/loaders/test_yaml.rb

@@ -35,6 +35,12 @@ class TestYaml < Minitest::Test
     @yaml_loader.load('services.yml')
   end
 
+  def test_adding_aliased_service
+    @container.expects(:register_alias).with('my_alias', 'my_definition')
+
+    @yaml_loader.send(:add_aliased_service, 'my_alias', 'my_definition')
+  end
+
   def test_adding_parameters
     @container.expects(:add_parameter).with('key_1', 'value_1')
     @container.expects(:add_parameter).with('key_2', 'value_2')
@@ -50,39 +56,84 @@ class TestYaml < Minitest::Test
                                        'key_2' => { 'param_1' => 'value_1' }})
   end
 
-  def test_adding_service_without_parameters
+  def test_adding_service_without_alias_parameters
+    @yaml_loader.expects(:add_aliased_service).never
+    @yaml_loader.expects(:add_standard_service).with('my_definition', { 'class' => 'MyKlass' })
+
+    @yaml_loader.send(:add_service, 'my_definition', { 'class' => 'MyKlass' })
+  end
+
+  def test_adding_service_with_alias_parameters
+    @yaml_loader.expects(:add_aliased_service).with('my_alias', 'my_definition')
+    @yaml_loader.expects(:add_standard_service).never
+
+    @yaml_loader.send(:add_service, 'my_alias', { 'alias' => 'my_definition' })
+  end
+
+  def test_adding_standard_service_as_lazy
+    @container.expects(:register).with('my_lazy_definition', 'MyLazyDefinition', true)
+    @yaml_loader.send(:add_standard_service, 'my_lazy_definition', { 'class' => 'MyLazyDefinition', 'lazy' => true })
+  end
+
+  def test_adding_standard_service_as_not_lazy
+    @container.expects(:register).with('my_definition', 'MyDefinition', false)
+    @yaml_loader.send(:add_standard_service, 'my_definition', { 'class' => 'MyDefinition', 'lazy' => false })
+  end
+
+  def test_adding_standard_service_with_default_lazy_value
+    @container.expects(:register).with('my_definition', 'MyDefinition', false)
+    @yaml_loader.send(:add_standard_service, 'my_definition', { 'class' => 'MyDefinition' })
+  end
+
+  def test_adding_standard_service_without_parameters
     definition = mock
-    @container.stubs(:register).with('key_1', 'MyKlass').returns(definition)
+    @container.stubs(:register).with('key_1', 'MyKlass', false).returns(definition)
     definition.expects(:add_arguments).never
 
-    @yaml_loader.send(:add_service, 'key_1', { 'class' => 'MyKlass' })
+    @yaml_loader.send(:add_standard_service, 'key_1', { 'class' => 'MyKlass' })
   end
 
-  def test_adding_service_with_parameters
+  def test_adding_standard_service_with_parameters
     definition = mock
-    @container.stubs(:register).with('key_1', 'MyKlass').returns(definition)
+    @container.stubs(:register).with('key_1', 'MyKlass', false).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'] })
+    @yaml_loader.send(:add_standard_service, 'key_1', { 'class' => 'MyKlass', 'arguments' => ['arg_1', 'arg_2'] })
   end
 
-  def test_adding_service_without_method_calls
+  def test_adding_standard_service_without_method_calls
     definition = mock
-    @container.stubs(:register).with('key_1', 'MyKlass').returns(definition)
+    @container.stubs(:register).with('key_1', 'MyKlass', false).returns(definition)
     definition.expects(:add_method_call).never
 
-    @yaml_loader.send(:add_service, 'key_1', { 'class' => 'MyKlass' })
+    @yaml_loader.send(:add_standard_service, 'key_1', { 'class' => 'MyKlass' })
   end
 
-  def test_adding_service_with_method_calls
+  def test_adding_standard_service_with_method_calls
     definition = mock
-    @container.stubs(:register).with('key_1', 'MyKlass').returns(definition)
+    @container.stubs(:register).with('key_1', 'MyKlass', false).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'],
+    @yaml_loader.send(:add_standard_service, 'key_1', { 'class' => 'MyKlass', 'calls' => { 'method_1' => ['arg_1'],
                                                                                   'method_2' => ['arg_1', 'arg_2'],
                                                                                   'method_3' => [['arg_1', 'arg_2']] }})
   end
+
+  def test_adding_standard_service_without_configurator
+    definition = mock
+    @container.stubs(:register).with('key_1', 'MyKlass', false).returns(definition)
+    definition.expects(:add_configurator).never
+
+    @yaml_loader.send(:add_standard_service, 'key_1', { 'class' => 'MyKlass' })
+  end
+
+  def test_adding_standard_service_with_configurator
+    definition = mock
+    @container.stubs(:register).with('key_1', 'MyKlass', false).returns(definition)
+    definition.expects(:add_configurator).with('ConfiguratorKlass', 'method_name')
+
+    @yaml_loader.send(:add_standard_service, 'key_1', { 'class' => 'MyKlass', 'configurator' => ['ConfiguratorKlass', 'method_name'] })
+  end
 end

data/test/dependency_injection/test_alias_definition.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+require 'dependency_injection/alias_definition'
+
+class TestAliasDefinition < Minitest::Test
+  def setup
+    @container        = mock
+    @alias_definition = DependencyInjection::AliasDefinition.new('my_definition', @container)
+  end
+
+  def test_getting_object_to_container
+    @container.expects(:get).with('my_definition')
+
+    @alias_definition.object
+  end
+end

data/test/dependency_injection/test_container.rb

@@ -3,13 +3,17 @@ require 'dependency_injection/container'
 
 class TestContainer < Minitest::Test
   def setup
-    @container    = DependencyInjection::Container.new
-    @final_object = mock
-    @definition   = mock
+    @container     = DependencyInjection::Container.new
+    @alias         = mock
+    @another_alias = mock
+    @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)
+    DependencyInjection::AliasDefinition.stubs(:new).with('my_definition', @container).returns(@alias)
+    DependencyInjection::AliasDefinition.stubs(:new).with('my_other_definition', @container).returns(@another_alias)
   end
 
   def test_adding_new_parameter
@@ -40,6 +44,11 @@ class TestContainer < Minitest::Test
     assert_equal({ 'my_definition' => @definition }, @container.definitions)
   end
 
+  def test_registering_a_lazy_definition
+    DependencyInjection::LazyDefinition.stubs(:new).with('MyLazyDefinition', @container)
+    @container.register('my_lazy_definition', 'MyLazyDefinition', true)
+  end
+
   def test_registering_a_class_return_a_definition_object
     assert_equal(@definition, @container.register('my_definition', 'MyDefinition'))
   end
@@ -51,4 +60,16 @@ class TestContainer < Minitest::Test
     @container.register('my_definition', 'MyOtherDefinition')
     assert_equal({ 'my_definition' => @another_definition }, @container.definitions)
   end
+
+  def test_registering_an_alias_returns_an_alias_definition_object
+    assert_equal(@alias, @container.register_alias('my_alias', 'my_definition'))
+  end
+
+  def test_registering_an_already_existing_alias_definition_replace_it
+    @container.register_alias('my_alias', 'my_definition')
+    assert_equal({ 'my_alias' => @alias }, @container.definitions)
+
+    @container.register_alias('my_alias', 'my_other_definition')
+    assert_equal({ 'my_alias' => @another_alias }, @container.definitions)
+  end
 end

data/test/dependency_injection/test_definition.rb

@@ -35,6 +35,16 @@ class TestDefinition < Minitest::Test
     assert_equal(%w(first second third), @definition.arguments)
   end
 
+  def test_adding_configurator
+    @definition.add_configurator('ConfiguratorKlass', 'method_name')
+
+    assert_equal(%w(ConfiguratorKlass method_name), @definition.configurator)
+  end
+
+  def test_adding_configurator_returns_definition_object
+    assert_equal(@definition, @definition.add_configurator('ConfiguratorKlass', 'method_name'))
+  end
+
   def test_adding_a_method_call_without_parameters
     @definition.add_method_call('my_method')
 
@@ -93,6 +103,33 @@ class TestDefinition < Minitest::Test
     @definition.object
   end
 
+  def test_getting_object_without_configurator
+    configurator_object = mock
+    final_object        = mock
+    final_class         = mock
+    @definition.stubs(:klass).returns(final_class)
+    @definition.stubs(:resolve).with([]).returns([])
+    @definition.stubs(:resolve).with(['ConfiguratorKlass']).returns([configurator_object])
+    configurator_object.expects(:send).never
+    final_class.stubs(:new).with.returns(final_object)
+
+    @definition.object
+  end
+
+  def test_getting_object_with_configurator
+    configurator_object = mock
+    final_object        = mock
+    final_class         = mock
+    @definition.stubs(:klass).returns(final_class)
+    @definition.stubs(:resolve).with([]).returns([])
+    @definition.stubs(:resolve).with(['ConfiguratorKlass']).returns([configurator_object])
+    @definition.add_configurator('ConfiguratorKlass', 'method_name')
+    configurator_object.expects(:send).with('method_name', final_object)
+    final_class.stubs(:new).with.returns(final_object)
+
+    @definition.object
+  end
+
   def test_resolving_first_container_parameters
     changed_arguments = mock
     arguments         = mock

data/test/dependency_injection/test_lazy_definition.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+require 'dependency_injection/lazy_definition'
+
+class TestLazyDefinition < Minitest::Test
+  def setup
+    @container       = mock
+    @lazy_definition = DependencyInjection::LazyDefinition.new('MyKlass', @container)
+  end
+
+  def test_getting_object_returns_a_proxy_object
+    assert_equal(DependencyInjection::ProxyObject, @lazy_definition.object.class)
+  end
+end

data/test/dependency_injection/test_proxy_object.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+require 'dependency_injection/proxy_object'
+
+class TestProxyObject < Minitest::Test
+  def setup
+    @object       = mock
+    @proxy_object = DependencyInjection::ProxyObject.new { @object }
+  end
+
+  def test_calling_a_method_existing_on_object
+    @object.expects(:existing_method).with('arg_1', 'arg_2')
+
+    @proxy_object.existing_method('arg_1', 'arg_2')
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dependency_injection
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Kevin Disneur
@@ -39,18 +39,30 @@ files:
 - README.md
 - Rakefile
 - dependency_injection.gemspec
+- examples/alias_definitions.rb
+- examples/alias_definitions.yml
 - examples/basic_usage.rb
+- examples/configurator_usage.rb
+- examples/configurator_usage.yml
 - examples/global_container_parameter.rb
 - examples/inject_a_reference_to_another_dependency.rb
-- examples/services.yml
+- examples/lazy_load_object.rb
+- examples/lazy_load_object.yml
 - examples/yaml_configuration_file.rb
+- examples/yaml_configuration_file.yml
+- lib/dependency_injection/alias_definition.rb
 - lib/dependency_injection/container.rb
 - lib/dependency_injection/definition.rb
+- lib/dependency_injection/lazy_definition.rb
 - lib/dependency_injection/loaders/yaml.rb
+- lib/dependency_injection/proxy_object.rb
 - lib/dependency_injection/version.rb
 - test/dependency_injection/loaders/test_yaml.rb
+- test/dependency_injection/test_alias_definition.rb
 - test/dependency_injection/test_container.rb
 - test/dependency_injection/test_definition.rb
+- test/dependency_injection/test_lazy_definition.rb
+- test/dependency_injection/test_proxy_object.rb
 - test/test_helper.rb
 homepage: https://github.com/kdisneur/dependency_injection-ruby
 licenses:
@@ -78,6 +90,9 @@ specification_version: 4
 summary: Dependency Injection system for Ruby
 test_files:
 - test/dependency_injection/loaders/test_yaml.rb
+- test/dependency_injection/test_alias_definition.rb
 - test/dependency_injection/test_container.rb
 - test/dependency_injection/test_definition.rb
+- test/dependency_injection/test_lazy_definition.rb
+- test/dependency_injection/test_proxy_object.rb
 - test/test_helper.rb