iocx 6.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 82a9ec97d0e22a0a328dfbffd7115e4e9adf7e027f19503629748b1d17ab7d9b
+  data.tar.gz: 687b1bc094499627b70f44cac1c2431b4666d9c8ab03a5a09e8bda82315d70bf
+SHA512:
+  metadata.gz: 27d5a48b9ac4876f2bc3a1d5c1039984fed74b05ab0beba43577d77587f6f87b4ff8f86286f62ae37d1bb470f5bae2f83f7ddb0aaecff08c99f372ce4e4a9a11
+  data.tar.gz: 2ab2c70e746926c77cb1f9e17134209ae94b73a445087e7250a30148c71c0d2d59e50a28a19691290cd85d8286dae8d95469e93002de878c487f21b28dd62b3d

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Erik Lott
+
+MIT License
+
+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/README.md

@@ -0,0 +1,100 @@
+# IOC
+
+Minimal dependency injection container for ruby.
+
+Tested on the following Rubies: MRI 2.2.1, 2.0.0, 1.9.3
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'iocx'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install iocx
+
+## 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
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/iocx.gemspec

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name          = "iocx"
+  spec.version       = "6.5.0"
+  spec.authors       = ["Erik Lott"]
+  spec.email         = ["mreriklott@gmail.com"]
+  spec.summary       = "Minimal dependency injection container for Ruby"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+  spec.files          = ["LICENSE.txt", "README.md", "Rakefile", "iocx.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", "~> 2.1.4"
+  spec.add_development_dependency "rake", "~> 13.0.1"
+  spec.add_development_dependency "minitest", "~> 5.14.1"
+end

data/lib/iocx.rb

@@ -0,0 +1,68 @@
+module IOC
+  class IOCError < ::StandardError; end
+  class DuplicateServiceError < IOCError; end
+  class RegistrationError < IOCError; end
+  class UnknownServiceError < IOCError; end
+  class MissingDependenciesError < 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)
+      raise(UnknownServiceError, "Service '#{key}' not registered") unless @services.key?(key)
+      
+      return @cache[key] if @cache.key?(key)
+      
+      @cache[key] = 
+        if @services[key].is_a?(Proc)
+          @services[key].call(self)
+        else
+          dependencies = get_dependencies(@services[key])
+          resolved_dependencies = dependencies.map{|dependency| resolve(dependency)}
+          @services[key].new(*resolved_dependencies)
+        end
+    end
+
+    def resolve_by_type(type)
+      key, service = @services.find{|key, service| !service.is_a?(Proc) && service <= type}
+      key ? resolve(key) : raise(UnknownServiceError, "Service of type '#{type}' not registered")
+    end
+
+    def release
+      @cache = {}
+    end
+
+    def validate!
+      missing = []
+      class_services = @services.values.reject{|service| service.is_a?(Proc)}
+      class_services.each do |service|
+        dependencies = get_dependencies(service)
+        dependencies.each do |dependency|
+          unless @services.key?(dependency)
+            missing << dependency
+          end
+        end
+      end
+      missing.uniq!
+
+      unless missing.empty?
+        raise(MissingDependenciesError, "missing dependencies: '#{missing.join(', ')}'")
+      end
+    end
+
+    private
+
+    def get_dependencies(service)
+      service.instance_method(:initialize).parameters.map(&:last)
+    end
+  end
+end

data/spec/ioc_spec.rb

@@ -0,0 +1,71 @@
+require "minitest"
+require "minitest/autorun"
+require "iocx"
+
+class CarFixture
+  attr_reader :engine
+  def initialize(engine)
+    @engine = engine
+  end
+end
+
+class PropulsionFixture; end
+class EngineFixture < PropulsionFixture; end
+class MotorFixture < PropulsionFixture; 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
+
+  describe "#validate!" do
+    it "complains if dependencies are missing" do
+      container = IOC::Container.new
+      container.register(:car, CarFixture)
+      _(proc {
+        container.validate!
+      }).must_raise(IOC::MissingDependenciesError)
+    end
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: iocx
+version: !ruby/object:Gem::Version
+  version: 6.5.0
+platform: ruby
+authors:
+- Erik Lott
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.1
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.14.1
+description:
+email:
+- mreriklott@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- iocx.gemspec
+- lib/iocx.rb
+- spec/ioc_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: Minimal dependency injection container for Ruby
+test_files:
+- spec/ioc_spec.rb