injectable 0.0.1 → 0.0.2

data/README.md

@@ -10,12 +10,17 @@ Usage
 
 Say we have a `UserService` that has some basic logic for performing operations
 related to a `User` and a `FacebookService`. We can tell the `UserService` what
-its dependencies are via `Injectable` (Objects that have no dependencies do not)
-need to include the module.
+its dependencies are via `Injectable`. Note that as of `0.0.2` all objects that
+can be injecteed into others must include the `Injectable` module.
 
 ```ruby
-class User; end
-class FacebookService; end
+class User
+  include Injectable
+end
+
+class FacebookService
+  include Injectable
+end
 
 class UserService
   include Injectable
@@ -46,7 +51,7 @@ object of a specific type and let the container figure out the dependencies:
 user = User.new
 facebook_service = FacebookService.new
 container = Injectable::Container.new(user, facebook_service)
-user_service = container.get(UserService)
+user_service = container.get(:user_service)
 ```
 
 Since `User` and `FacebookService` take no arguments, we don't even need to
@@ -54,12 +59,30 @@ pass them into the container - it will automatically instantiate new ones:
 
 ```ruby
 container = Injectable::Container.new
-user = container.get(User)
-user_service = container.get(UserService)
+user = container.get(:user)
+user_service = container.get(:user_service)
 ```
 
-Polymorphism is not supported since we don't have interfaces in Ruby. Setter
-injection is also not supported.
+Injectable also supports depending on roles rather than concrete classes by
+allowing the registration of classes whose instances perform that role:
+
+```ruby
+container = Injectable::Container.new
+container.register_implementation(:facebook_service, DifferentFacebookService)
+user_service = container.get(:user_service)
+# `user_service`'s facebook_service will be an instance of DifferentFacebookService
+```
+
+You can also define concrete implementations at the global level:
+
+```ruby
+Injectable::Registry.register_implementation(:facebook_service, DifferentFacebookService)
+container = Injectable::Container.new
+user_service = container.get(:user_service)
+# `user_service`'s facebook_service will be an instance of DifferentFacebookService
+```
+
+Setter injection is not supported.
 
 How about the real world
 ------------------------
@@ -68,9 +91,12 @@ Let's look at the above classes, but say we're in a Rails application:
 
 ```ruby
 class User < ActiveRecord::Base
+  include Injectable
 end
 
 class FacebookService
+  include Injectable
+
   def post_to_wall(id, message)
     # ...
   end

data/lib/injectable/container.rb

@@ -11,12 +11,16 @@ module Injectable
     # @example Get an instance of an object for class UserService.
     #   container.get(UserService)
     #
-    # @param [ Class ] klass The type of the object to return.
+    # @param [ Symbol ] name the role which the returned object should perform.
     #
     # @return [ Object ] The instantiated object.
     #
+    # @raise [ Injectable::RoleNotRegistered ] if queried for a role which is not
+    #   registered
+    #
     # @since 0.0.0
-    def get(klass)
+    def get(name)
+      klass = implementing_class(name)
       if instantiated_objects.has_key?(klass)
         instantiated_objects[klass]
       else
@@ -39,6 +43,21 @@ module Injectable
       end
     end
 
+    # Register that instances of klass will perform the given role in this
+    # container context.
+    #
+    # @example Register that the user_finder role will be performed by
+    #   instances of DatabaseUserFinder
+    #   container.register_implementation(:user_finder, DatabaseUserFinder)
+    #
+    # @param [ Symbol ] name The name of the role.
+    # @param [ Class ] klass The name of the class performing this role.
+    #
+    # @since 0.0.1
+    def register_implementation(name, klass)
+      implementing_classes[name] = klass
+    end
+
     private
 
     def dependencies(klass)
@@ -54,5 +73,13 @@ module Injectable
     def instantiated_objects
       @instantiated_objects ||= {}
     end
+
+    def implementing_class(name)
+      implementing_classes[name] || Registry.implementation(name)
+    end
+
+    def implementing_classes
+      @implementing_classes ||= {}
+    end
   end
 end

data/lib/injectable/macros.rb

@@ -29,7 +29,7 @@ module Injectable
     def dependencies(*injectables)
       define_constructor(*injectables)
       define_readers(*injectables)
-      Registry.add(self, injectables)
+      Registry.register_signature(self, injectables)
     end
 
     private

data/lib/injectable/registry.rb

@@ -8,18 +8,49 @@ module Injectable
   module Registry
     extend self
 
+    # Get an implementation for the provided name.
+    #
+    # @example Get an implementation.
+    #   Injectable::Registry.implementation(:persistable)
+    #
+    # @param [ Symbol ] name The name of the implementation.
+    #
+    # @return [ Class ] The implementing class.
+    #
+    # @since 0.0.2
+    def implementation(name)
+      implementations[name] || raise(NotRegistered.new(name))
+    end
+
+    # Add an implementing class for a name to the registry.
+    #
+    # @example Add an implementation.
+    #   Injectable::Registry.register_implementation(
+    #     :persistable, User
+    #   )
+    #
+    # @param [ Symbol ] name The name of the implementation.
+    # @param [ Class ] klass The implementing class.
+    #
+    # @since 0.0.2
+    def register_implementation(name, klass)
+      implementations[name] = klass
+    end
+
     # Add a constructor method signature to the registry.
     #
     # @example Add a signature.
-    #   Injectable::Registry.add(UserService, [ :user, :user_finder ])
+    #   Injectable::Registry.register_signature(
+    #     UserService, [ :user, :user_finder ]
+    #   )
     #
     # @param [ Class ] klass The class to set the constructor signature for.
     # @param [ Array<Symbol> ] dependencies The dependencies of the
     #   constructor.
     #
     # @since 0.0.0
-    def add(klass, dependencies)
-      signatures[klass] = dependencies.map { |name| name.to_s.classify.constantize }
+    def register_signature(klass, dependencies)
+      signatures[klass] = dependencies.map { |name| name }
     end
 
     # Get the constructor method signature for the provided class.
@@ -36,8 +67,35 @@ module Injectable
       signatures[klass]
     end
 
+    # This error is raised when asking for an implementing class that is not
+    # registered in the registry.
+    #
+    # @since 0.0.2
+    class NotRegistered < Exception
+
+      # @attribute [r] name The name of the requested implementation.
+      attr_reader :name
+
+      # Initialize the new error.
+      #
+      # @example Initialize the error.
+      #   NotRegistered.new(:persistable)
+      #
+      # @param [ Symbol ] name The name of the implementation.
+      #
+      # @since 0.0.2
+      def initialize(name)
+        @name = name
+        super("No implementation registered for name: #{name.inspect}.")
+      end
+    end
+
     private
 
+    def implementations
+      @implementations ||= {}
+    end
+
     def signatures
       @signatures ||= {}
     end

data/lib/injectable/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Injectable
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/injectable.rb

@@ -26,6 +26,7 @@ module Injectable
     #
     # @since 0.0.0
     def included(klass)
+      Registry.register_implementation(klass.name.underscore.to_sym, klass)
       klass.extend(Macros)
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: injectable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-20 00:00:00.000000000 Z
+date: 2012-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -55,7 +55,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3211559438392956621
+      hash: -1472989141403557370
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -64,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3211559438392956621
+      hash: -1472989141403557370
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24