ioc 4.1.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: beb7d05c11433d3fd20a45084e0c41ff64f166cf
-  data.tar.gz: cb699ee843c95a790b4af1b16d547f7d4e21ad79
+  metadata.gz: 45cfdeec3bba0d8515b0cb35b5237b66a028ce85
+  data.tar.gz: 13fcee15a0d44787e8f79017ec0c5cb81c0bf126
 SHA512:
-  metadata.gz: f0a1c1617334862a57ae5e65e86d8cd23ad7aaeae8b47b0b5f9ae5e3b450ddd4e16fa8999d055b9a227d3f630be94715424e3d0112ec0d663fc8e8543266d82e
-  data.tar.gz: 2f4aeb3e70503c3746ba63f5eb71870be9a17567be715ba4f091551d25cf9733e644ba290e62f753e8c41d7acc059e0bb5cc20e02dcc85b835e7e9d35f65fadb
+  metadata.gz: 8b880eeb06d15ddf14edcc384ba270d0ec8d7c23364a043a43af2a1211889909d42531d05bb0cbe7f012489c2407f06bc5af8ce1a831751a3bd708930a051326
+  data.tar.gz: 21b1a31d877de30d7fac725a40208c2e1eeecce806f1e0812eaedd992f95fedad60b68f55bc4c073c3afd5be38334403e88553b836227434cec4d46966823d69

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Erik Lott
+Copyright (c) 2015 Erik Lott
 
 MIT License
 
@@ -19,4 +19,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,6 +1,8 @@
 # IOC
 
-TODO: Write a gem description
+Minimal dependency injection container for ruby.
+
+Tested on the following Rubies: MRI 2.2.1, 2.0.0, 1.9.3
 
 ## Installation
 
@@ -17,8 +19,77 @@ Or install it yourself as:
     $ gem install ioc
 
 ## Usage
+### Block Registration
+This example illustrates how to register a service/component with the container by passing a block to the register method.
+```ruby
+require "ioc"
+
+class AccountRepository
+  def initialize(database, logger)
+    @database = database
+    @logger = logger
+  end
+  # ... some store & finder methods here
+end
+
+class UserRepository
+  def initialize(database, logger)
+    @database = database
+    @logger = logger
+  end
+  # ... some store & finder methods here
+end
+
+class CreateAccountService
+  def initialize(account_repository, user_repository, logger)
+    @account_repository = account_repository
+    @user_repository = user_repository
+    @logger = logger
+  end
+  
+  def call(req, res)
+    # ... create account code
+  end
+end
+
+# Register Services
+container = IOC::Container.new
+container.register(:create_account_service) do |c|
+  CreateAccountService.new(c.account_repository, c.user_repository, c.logger)
+end
+container.register(:user_repository) do |c|
+  UserRepository.new(c.database, c.logger)
+end
+container.register(:account_repository) do |c|
+  AccountRepository.new(c.database, c.logger)
+end
+container.register(:logger){|c| Logger.new}
+container.register(:database){|c| DB}
+
+# Resolve Service
+container.resolve(:create_account_service).call(req, res)
+
+# Release the object graph for garbage collection
+container.release
+```
+### Automatic Dependency Resolution
+Rather than assigning each service's dependencies manually like in the example above, we can allow the container to build and inject each service's dependencies automatically.
+```ruby
+# Register Services
+container = IOC::Container.new
+container.register(:create_account_service, CreateAccountService)
+container.register(:user_repository, UserRepository)
+container.register(:account_repository, AccountRepository)
+container.register(:logger){|c| Logger.new}
+container.register(:database){|c| DB}
+
+# Resolve Service
+container.resolve(:create_account_service).call(req, res)
+
+# Release the object graph for garbage collection
+container.release
+```
 
-TODO: Write usage instructions here
 
 ## Contributing
 

data/ioc.gemspec

@@ -1,19 +1,20 @@
 # coding: utf-8
 
 Gem::Specification.new do |spec|
-  spec.name          = 'ioc'
-  spec.version       = '4.1.0'
-  spec.authors       = ['Erik Lott']
-  spec.email         = ['erik.lott@kodio.io']
-  spec.summary       = 'Minimal inversion of control container for Ruby'
-  spec.homepage      = ''
-  spec.license       = 'MIT'
-  spec.files          = ['LICENSE.txt', 'README.md', 'Rakefile', 'ioc.gemspec']
-  spec.files         += Dir.glob('lib/**/*.rb')
-  spec.files         += Dir.glob('spec/**/*')
-  spec.test_files     = Dir.glob('spec/**/*')
+  spec.name          = "ioc"
+  spec.version       = "6.0.0"
+  spec.authors       = ["Erik Lott"]
+  spec.email         = ["erik.lott@kodio.io"]
+  spec.summary       = "Minimal dependency injection container for Ruby"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+  spec.files          = ["LICENSE.txt", "README.md", "Rakefile", "ioc.gemspec"]
+  spec.files         += Dir.glob("lib/**/*.rb")
+  spec.files         += Dir.glob("spec/**/*")
+  spec.test_files     = Dir.glob("spec/**/*")
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
 end

data/lib/ioc.rb

@@ -1 +1,37 @@
-require "ioc/container"
+module IOC
+  class IOCError < ::StandardError; end
+  class DuplicateServiceError < IOCError; end
+  class RegistrationError < IOCError; end
+  class UnknownServiceError < IOCError; end
+
+  class Container
+    def initialize
+      @services = {}
+      @cache = {}
+    end
+    
+    def register(key, klass=nil, &block)
+      raise(DuplicateServiceError, "Service '#{key}' has already been registered") if @services.key?(key)
+      raise(RegistrationError, "expected class or block") unless klass || block_given?
+      @services[key] = klass ? klass : block
+    end
+
+    def resolve(key)
+      return @cache[key] if @cache.key?(key)
+      raise(UnknownServiceError, "Service '#{key}' not registered") unless @services.key?(key)
+      
+      @cache[key] = 
+        if @services[key].is_a?(Proc)
+          @services[key].call(self)
+        else
+          dependencies = @services[key].instance_method(:initialize).parameters.map(&:last)
+          resolved_dependencies = dependencies.map{|dependency| resolve(dependency)}
+          @services[key].new(*resolved_dependencies)
+        end
+    end
+
+    def release
+      @cache = {}
+    end
+  end
+end

data/spec/ioc_spec.rb

@@ -0,0 +1,59 @@
+require "minitest"
+require "minitest/autorun"
+require "ioc"
+
+class CarFixture
+  attr_reader :engine
+  def initialize(engine)
+    @engine = engine
+  end
+end
+
+class EngineFixture; end
+
+describe IOC do
+  it "can resolve a service class" do
+    container = IOC::Container.new
+    container.register(:myclass, EngineFixture)
+    inst = container.resolve(:myclass)
+    inst.must_be_instance_of(EngineFixture)
+  end
+
+  it "can resolve a service classes dependencies" do
+    container = IOC::Container.new
+    container.register(:engine, EngineFixture)
+    container.register(:car, CarFixture)
+    car = container.resolve(:car)
+    car.engine.must_be_instance_of(EngineFixture)
+  end
+
+  it "caches resolved services" do
+    container = IOC::Container.new
+    container.register(:engine, EngineFixture)
+    engine1 = container.resolve(:engine)
+    engine2 = container.resolve(:engine)
+    (engine1 === engine2).must_equal(true)
+  end
+
+  it "can resolve a service block" do
+    myobject = "mystring"
+    container = IOC::Container.new
+    container.register(:myobject){|c| myobject }
+    container.resolve(:myobject).must_equal(myobject)
+  end
+
+  it "complains when resolving unknown service" do
+    container = IOC::Container.new
+    proc { 
+      container.resolve(:some_unknown_service) 
+    }.must_raise(IOC::UnknownServiceError)
+  end
+
+  it "complains when service name registered more than once" do
+    container = IOC::Container.new
+    container.register(:myclass, EngineFixture)
+    proc { 
+      container.register(:myclass, EngineFixture) 
+    }.must_raise(IOC::DuplicateServiceError)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ioc
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Erik Lott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-07 00:00:00.000000000 Z
+date: 2015-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - erik.lott@kodio.io
@@ -50,12 +64,7 @@ files:
 - Rakefile
 - ioc.gemspec
 - lib/ioc.rb
-- lib/ioc/container.rb
-- lib/ioc/service_block.rb
-- lib/ioc/service_class.rb
-- lib/ioc/unresolvable_container.rb
-- spec/container_spec.rb
-- spec/spec_helper.rb
+- spec/ioc_spec.rb
 homepage: ''
 licenses:
 - MIT
@@ -76,10 +85,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: Minimal inversion of control container for Ruby
+summary: Minimal dependency injection container for Ruby
 test_files:
-- spec/container_spec.rb
-- spec/spec_helper.rb
+- spec/ioc_spec.rb

data/lib/ioc/container.rb

@@ -1,41 +0,0 @@
-require "ioc/service_class"
-require "ioc/service_block"
-require "ioc/unresolvable_container"
-
-module IOC
-  class Container
-    def initialize(parent=UnresolvableContainer.new, &block)
-      @services = {}
-      @cache = {}
-      @parent = parent
-
-      self.instance_eval(&block) if block_given?
-    end
-    
-    def register(service_name, klass=nil, &block)
-      raise(ArgumentError, "Service '#{service_name}' has already been registered") if @services.key?(service_name)
-      @services[service_name] = 
-        if klass
-          ServiceClass.new(klass)
-        elsif block_given?
-          ServiceBlock.new(block)
-        else
-          raise(ArgumentError, "expected service")
-        end
-    end
-
-    def resolve(name)
-      @cache[name] ||= service_locator(name)
-    end
-
-    def [](key)
-      resolve(key)
-    end
-
-    private
-
-    def service_locator(name)
-      @services.key?(name) ? @services[name].resolve(self) : @parent.resolve(name)
-    end
-  end
-end

data/lib/ioc/service_block.rb

@@ -1,11 +0,0 @@
-module IOC
-  class ServiceBlock
-    def initialize(block)
-      @block = block
-    end
-
-    def resolve(container)
-      @block.call(container)
-    end
-  end
-end

data/lib/ioc/service_class.rb

@@ -1,16 +0,0 @@
-module IOC
-  class ServiceClass
-    def initialize(klass) 
-      klass.instance_method(:initialize)
-      @klass = klass
-    rescue NoMethodError => e
-      raise(ArgumentError, "Expected initialize method on registered service")
-    end
-
-    def resolve(container)
-      dependencies = @klass.instance_method(:initialize).parameters.map(&:last)
-      resolved_dependencies = dependencies.map{ |dependency| container.resolve(dependency) }
-      @klass.new(*resolved_dependencies)
-    end
-  end
-end

data/lib/ioc/unresolvable_container.rb

@@ -1,7 +0,0 @@
-module IOC
-  class UnresolvableContainer
-    def resolve(name)
-      raise(ArgumentError, "Service '#{name}' not registered")
-    end
-  end
-end

data/spec/container_spec.rb

@@ -1,130 +0,0 @@
-require "spec_helper"
-require "ioc"
-
-describe IOC::Container do
-  context "when class is registered" do
-    it "resolves a class instance" do
-      container = define_container
-      myclass = define_class
-      container.register(:myclass, myclass)
-      inst = container.resolve(:myclass)
-      inst.must_be_instance_of(myclass)
-    end
-
-    it "caches resolved instance" do
-      container = define_container
-      myclass = define_class
-      container.register(:myclass, myclass)
-      inst1 = container.resolve(:myclass)
-      inst2 = container.resolve(:myclass)
-      inst1.must_equal(inst2)
-    end
-
-    context "when class has dependencies" do
-      it "injects dependencies into instance" do
-        container = define_container
-        
-        engine_class = define_class
-        container.register(:engine, engine_class)
-
-        car_class = define_class_with_engine_dependency
-        container.register(:car, car_class)
-
-        car = container.resolve(:car)
-        car.engine.must_be_instance_of(engine_class)
-      end
-
-      it "caches dependencies" do
-        container = define_container
-        
-        engine_class = define_class
-        container.register(:engine, engine_class)
-
-        car_class = define_class_with_engine_dependency
-        container.register(:car, car_class)
-
-        car = container.resolve(:car)
-        engine = container.resolve(:engine)
-
-        car.engine.must_equal(engine)
-      end
-    end
-  end
-
-  context "when block is registered" do
-    it "returns result of block" do
-      myobject = "a string object"
-      container = define_container
-      container.register(:myobject){|c| myobject }
-      container.resolve(:myobject).must_equal(myobject)
-    end
-  end
-
-  it "raises error when service not found" do
-    container = define_container
-    proc { 
-      container.resolve(:some_service) 
-    }.must_raise(ArgumentError)
-  end
-
-  it "raises error when service registered more than once" do
-    myclass = define_class
-    container = define_container
-    container.register(:myclass, myclass)
-    proc { 
-      container.register(:myclass, myclass) 
-    }.must_raise(ArgumentError)
-  end
-
-  it "raises error when object registered as class" do
-    myclass = define_class
-    myobject = myclass.new
-    container = define_container
-    proc { 
-      container.register(:myclass, myobject)
-    }.must_raise(ArgumentError)
-  end
-
-  it "supports resolving via hash syntax" do
-    container = define_container
-    myclass = Class.new
-    container.register(:myclass, myclass)
-    inst = container[:myclass]
-    inst.must_be_instance_of(myclass)
-  end
-
-  it "can resolve service from parent container" do
-    myobject = Object.new
-    parent_container = define_container
-    parent_container.register(:myobject){ myobject }
-
-    child_container = define_container(parent_container)
-    child_container.resolve(:myobject).must_equal(myobject)
-  end
-
-  it "can be initialized with a block" do
-    myobject = "a string object"
-    container = define_container do
-      register(:myobject){|c| myobject }
-    end
-    container.resolve(:myobject).must_equal(myobject)
-  end
-
-  def define_container(*args, &block)
-    IOC::Container.new(*args, &block)
-  end
-
-  def define_class_with_engine_dependency
-    Class.new do
-      attr_reader :engine
-
-      def initialize(engine)
-        @engine = engine
-      end
-    end
-  end
-
-  def define_class
-    Class.new
-  end
-end

data/spec/spec_helper.rb

@@ -1,5 +0,0 @@
-require "minitest/autorun"
-
-def context *args, &block
-  describe *args, &block
-end