Add the ability to declare a service as an alias for another

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

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'

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

lib/dependency_injection/container.rb

@@ -1,3 +1,4 @@
+require 'dependency_injection/alias_definition'
 require 'dependency_injection/definition'
 
 module DependencyInjection
@@ -22,5 +23,9 @@ def get(name)
     def register(name, klass_name)
       @definitions[name] = Definition.new(klass_name, self)
     end
+
+    def register_alias(name, alias_definition_name)
+      @definitions[name] = AliasDefinition.new(alias_definition_name, self)
+    end
   end
 end

lib/dependency_injection/loaders/yaml.rb

@@ -15,6 +15,10 @@ def load(filename)
 
     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,6 +28,14 @@ def add_services(services)
       end
 
       def add_service(name, parameters)
+        if parameters['alias']
+          add_aliased_service(name, parameters['alias'])
+        else
+          add_standard_service(name, parameters)
+        end
+      end
+
+      def add_standard_service(name, parameters)
         definition = @container.register(name, parameters['class'])
         definition.add_arguments(*parameters['arguments']) if parameters['arguments']
         if (configurator = parameters['configurator'])

test/dependency_injection/loaders/test_yaml.rb

@@ -35,6 +35,12 @@ def test_loading_file_with_services
     @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,55 +56,69 @@ def test_adding_services
                                        '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_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' })
+    @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)
     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)
     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)
     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_service_without_configurator
+  def test_adding_standard_service_without_configurator
     definition = mock
     @container.stubs(:register).with('key_1', 'MyKlass').returns(definition)
     definition.expects(:add_configurator).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_configurator
+  def test_adding_standard_service_with_configurator
     definition = mock
     @container.stubs(:register).with('key_1', 'MyKlass').returns(definition)
     definition.expects(:add_configurator).with('ConfiguratorKlass', 'method_name')
 
-    @yaml_loader.send(:add_service, 'key_1', { 'class' => 'MyKlass', 'configurator' => ['ConfiguratorKlass', 'method_name'] })
+    @yaml_loader.send(:add_standard_service, 'key_1', { 'class' => 'MyKlass', 'configurator' => ['ConfiguratorKlass', 'method_name'] })
   end
 end

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

test/dependency_injection/test_container.rb

@@ -3,13 +3,17 @@
 
 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
@@ -51,4 +55,16 @@ def test_registering_an_already_existing_definition_replace_it
     @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