injectable 0.0.1

data/README.md

@@ -0,0 +1,128 @@
+Injectable [![Build Status](https://secure.travis-ci.org/durran/injectable.png?branch=master&.png)](http://travis-ci.org/durran/injectable) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/durran/injectable)
+========
+
+Injectable is an extremely simple dependency injection framework for Ruby. It's
+stupid simple and experimental so don't expect support for now - but may turn out
+to be something in the future.
+
+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.
+
+```ruby
+class User; end
+class FacebookService; end
+
+class UserService
+  include Injectable
+  dependencies :user, :facebook_service
+end
+```
+
+The `UserService` would then get a constructor defined that takes a `User` and
+`FacebookService` as its arguments:
+
+```ruby
+user = User.new
+facebook_service = FacebookService.new
+user_service = UserService.new(user, facebook_service)
+```
+
+Reader methods are also automatically provided for each dependency:
+
+```ruby
+user_service.user
+user_service.facebook_service
+```
+
+Say we just want to throw a bunch of objects in a container, and ask for an
+object of a specific type and let the container figure out the dependencies:
+
+```ruby
+user = User.new
+facebook_service = FacebookService.new
+container = Injectable::Container.new(user, facebook_service)
+user_service = container.get(UserService)
+```
+
+Since `User` and `FacebookService` take no arguments, we don't even need to
+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)
+```
+
+Polymorphism is not supported since we don't have interfaces in Ruby. Setter
+injection is also not supported.
+
+How about the real world
+------------------------
+
+Let's look at the above classes, but say we're in a Rails application:
+
+```ruby
+class User < ActiveRecord::Base
+end
+
+class FacebookService
+  def post_to_wall(id, message)
+    # ...
+  end
+end
+
+class UserService
+  include Injectable
+  dependencies :user, :facebook_service
+
+  def post_to_wall(message)
+    facebook_service.post_to_wall(user.id, message)
+  end
+end
+```
+
+Now in our controller, we can just create a new container the user we find
+and then ask the container to do all the other work. This is more closely
+related to what one might do in a real application.
+
+```ruby
+class UsersController < ApplicationController
+
+  def post_to_wall
+    container.get(UserService).post_to_wall(params[:message])
+    respond_with container.get(User)
+  end
+
+  private
+
+  def container
+    @container ||= Injectable::Container.new(User.find(params[:id]))
+  end
+end
+```
+
+Copyright (c) 2012 Durran Jordan
+
+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/Rakefile

@@ -0,0 +1,30 @@
+require "bundler"
+Bundler.setup
+
+require "rake"
+require "rspec/core/rake_task"
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "injectable/version"
+
+task :gem => :build
+task :build do
+  system "gem build injectable.gemspec"
+end
+
+task :install => :build do
+  system "sudo gem install injectable-#{Injectable::VERSION}.gem"
+end
+
+task :release => :build do
+  system "git tag -a v#{Injectable::VERSION} -m 'Tagging #{Injectable::VERSION}'"
+  system "git push --tags"
+  system "gem push injectable-#{Injectable::VERSION}.gem"
+  system "rm injectable-#{Injectable::VERSION}.gem"
+end
+
+RSpec::Core::RakeTask.new("spec") do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :spec

data/lib/injectable/container.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+module Injectable
+
+  # A simple container that can resolve dependencies.
+  #
+  # @since 0.0.0
+  class Container
+
+    # Get an instance of an object from the container with the provided class.
+    #
+    # @example Get an instance of an object for class UserService.
+    #   container.get(UserService)
+    #
+    # @param [ Class ] klass The type of the object to return.
+    #
+    # @return [ Object ] The instantiated object.
+    #
+    # @since 0.0.0
+    def get(klass)
+      if instantiated_objects.has_key?(klass)
+        instantiated_objects[klass]
+      else
+        instantiated_objects[klass] = instantiate(klass)
+      end
+    end
+
+    # Create a new container with the objects needed to resolve dependencies
+    # and create new objects.
+    #
+    # @example Create the new container.
+    #   Injectable::Container.new(user, user_finder)
+    #
+    # @param [ Array<Object> ] objects The dependencies.
+    #
+    # @since 0.0.0
+    def initialize(*objects)
+      objects.each do |object|
+        instantiated_objects[object.class] = object
+      end
+    end
+
+    private
+
+    def dependencies(klass)
+      (Registry.signature(klass) || []).map do |dependency|
+        get(dependency)
+      end
+    end
+
+    def instantiate(klass)
+      klass.new(*dependencies(klass))
+    end
+
+    def instantiated_objects
+      @instantiated_objects ||= {}
+    end
+  end
+end

data/lib/injectable/macros.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+module Injectable
+
+  # Provides class level macros for setting up dependencies.
+  #
+  # @since 0.0.0
+  module Macros
+
+    # Sets up the dependencies for the class.
+    #
+    # @example Define a UserService that has two dependencies.
+    #   class User; end
+    #   class UserFinder; end
+    #
+    #   class UserService
+    #     include Injectable
+    #     dependencies :user, :user_finder
+    #   end
+    #
+    # @note A constructor will get created for the object that takes the same
+    #   number or arguments as provided to the dependencies macro. The types
+    #   of these arguments must match the "classified" name of the provided
+    #   symbol. For example :user would be a User class, :user_finder would be
+    #   a UserFinder class. Order matters.
+    #
+    # @param [ Array<Symbol> ] injectables The dependency list.
+    #
+    # @since 0.0.0
+    def dependencies(*injectables)
+      define_constructor(*injectables)
+      define_readers(*injectables)
+      Registry.add(self, injectables)
+    end
+
+    private
+
+    def define_constructor(*injectables)
+      names = names(*injectables)
+      class_eval <<-CONST
+        def initialize(#{names})
+          #{ivars(*injectables)} = #{names}
+        end
+      CONST
+    end
+
+    def define_readers(*injectables)
+      injectables.each do |dependency|
+        attr_reader(dependency)
+      end
+    end
+
+    def ivars(*injectables)
+      injectables.map { |name| "@#{name}" }.join(",")
+    end
+
+    def names(*injectables)
+      injectables.join(",")
+    end
+  end
+end

data/lib/injectable/registry.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module Injectable
+
+  # The registry keeps track of all objects and their dependencies that need
+  # to be injected at construction.
+  #
+  # @since 0.0.0
+  module Registry
+    extend self
+
+    # Add a constructor method signature to the registry.
+    #
+    # @example Add a signature.
+    #   Injectable::Registry.add(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 }
+    end
+
+    # Get the constructor method signature for the provided class.
+    #
+    # @example Get the constructor signature.
+    #   Injectable::Registry.signature(UserService)
+    #
+    # @param [ Class ] klass The class to get the signature for.
+    #
+    # @return [ Array<Class> ] The constructor signature.
+    #
+    # @since 0.0.0
+    def signature(klass)
+      signatures[klass]
+    end
+
+    private
+
+    def signatures
+      @signatures ||= {}
+    end
+  end
+end

data/lib/injectable/version.rb

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

data/lib/injectable.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require "active_support/inflector"
+require "injectable/container"
+require "injectable/macros"
+require "injectable/registry"
+
+# Objects that include Injectable can have their dependencies satisfied by the
+# container, and removes some basic boilerplate code of creating basic
+# constructors that set instance variables on the class. Constructor injection
+# is the only available option here.
+#
+# @since 0.0.0
+module Injectable
+
+  class << self
+
+    # Including the Injectable module will extend the class with the necessary
+    # macros.
+    #
+    # @example Include the module.
+    #   class UserService
+    #     include Injectable
+    #   end
+    #
+    # @param [ Class ] klass The including class.
+    #
+    # @since 0.0.0
+    def included(klass)
+      klass.extend(Macros)
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: injectable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Durran Jordan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Dead simple Ruby dependency injection
+email:
+- durran@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/injectable/container.rb
+- lib/injectable/macros.rb
+- lib/injectable/registry.rb
+- lib/injectable/version.rb
+- lib/injectable.rb
+- README.md
+- Rakefile
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3211559438392956621
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3211559438392956621
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Dead simple Ruby dependency injection
+test_files: []