pinball 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2cda464327444a1c7fd499861105269f0272f3f
-  data.tar.gz: b99ffa3a55fbd7a9b183e699fd44fdec4181f345
+  metadata.gz: a0a151b6a0ce9ddb00755568ae644cb809e6f13a
+  data.tar.gz: b842f2c2e9acacd61444d82fa411a03bd6769e47
 SHA512:
-  metadata.gz: df4f00d3febebbf691c82205ac77625c918c4afe07f0c57c839d3f7f9942e24d4d5fd098a5962f18367068c64a1c7337257212f78d28c62c1498919c64270659
-  data.tar.gz: 1a88d82d7c6e6ce0d10777a316eb82dc5fe8dd39c3eb47b21e202b86752693081e8f5e573cd3e20eb154f5b70b52fbc7889139e0bd7bec2c7d72f9845e44c75e
+  metadata.gz: 828227b6d3b7847301a7958d325e377ca2833c7f1e7eb55af04dfe16b1eed7d3c4615511fa74ca2bebfbb9e9b8792298828da307c481f30e45cbd402f98a095f
+  data.tar.gz: b2d9c11f9848feb81f5ccf1b22933e84a5a413abb8fc2133854c6a46c8f362bb31da6afb544c95500181b19127efba41662ba915cd639d9d71acfe2c2321d52d

data/README.md

@@ -0,0 +1,127 @@
+## Pinball [![Build Status](https://travis-ci.org/zhulik/pinball.svg?branch=master)](https://travis-ci.org/zhulik/pinball) [![Coverage Status](https://img.shields.io/coveralls/zhulik/pinball.svg)](https://coveralls.io/r/zhulik/pinball?branch=master) [![Code Climate](https://codeclimate.com/github/zhulik/pinball.png)](https://codeclimate.com/github/zhulik/pinball)
+
+### Simple IOC Container and DI tool for ruby.
+
+Pinball is a library for using dependency injection within Ruby
+applications. It provides a clear IOC Container that manages
+dependencies between your classes.
+
+# Features
+
+* Stores objects, classes(as factories) and blocks
+* Can inject dependencies to classes and instances
+* Simple DSL for configuring the container
+* Stored block will be call in dependent class instance
+* You can describe any context-dependent code in blocks
+
+## Usage
+
+### Class injection
+
+Consider a `Service` class that has a dependency on a `Repository`. We would
+like this dependency to be available to the service when it is created.
+
+First we create a container object and declare the dependencies.
+
+```ruby
+require 'pinball'
+
+Pinball::Container.configure do
+  define :repository, Repository
+end
+```
+
+Then we declare the `repository` dependency in the Service class by
+using the `inject` declaration.
+
+```ruby
+class Service
+  inject :repository
+end
+```
+
+Now we can instantiate Service object and `repository` method will
+be already accessible in it's constructor! In this case *repository*
+method will return the instance of Repository.
+**Notice:** each call of `repository` will create new instance of `Repository`.
+
+### Object injection
+
+Also you can inject any already existed object
+
+```ruby
+require 'pinball'
+
+Pinball::Container.configure do
+  define :string, 'any pre-defined string'
+end
+```
+
+In this case `string` method will return 'any pre-defined string'
+
+### Block injection
+
+The most powerful feature of pinball is block injection.
+For example, you have `FirstService` class, that dependent on
+`SecondService` class, but for instantiating `SecondService` you need
+to pass `@current_user` from `FirstService` to it's constructor:
+
+```ruby
+class FirstService
+  inject :second_service
+
+  def initialize(current_user)
+    @current_user = current_user
+  end
+end
+
+class SecondService
+  def initialize(current_user)
+    @current_user = current_user
+  end
+end
+```
+
+Simple defining of `SecondService` dependency will not work here.
+So we can define dependency with a block:
+
+```ruby
+Pinball::Container.configure do
+  define :second_service do
+    SecondService.new(@current_user)
+  end
+end
+```
+
+This block will be executed it `FirstService` instance context where
+`@current_user` will be accessible.
+**Notice:** each call of `second_service` will call this block over and over again.
+
+### class_inject
+
+Sometimes you need to inject dependency to class, when it must be available in
+class methods. For this purpose Pinball has `class_inject` declaration:
+
+```ruby
+  class Foo
+    class_inject :baz
+  end
+
+  Foo.baz
+```
+
+## Future plans
+
+* Rails integration
+* Dependency lifecycle managing in Rails context
+* Smart caching
+
+## 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
+
+Inspired by [Encase gem](https://github.com/dsawardekar/encase "Encase gem")

data/lib/pinball/class.rb

@@ -21,6 +21,7 @@ class Class
   def check_pinball
     unless self.is_a? Pinball
       self.extend Pinball
+      self.send(:include, Pinball::Methods)
     end
   end
 end

data/lib/pinball/container.rb

@@ -44,7 +44,7 @@ module Pinball
     def inject(target)
       target.class.dependencies.each do |dep|
         target.define_singleton_method dep do
-          Container.instance.items[dep].fetch(self)
+          Container.instance.items.merge(overridden_dependencies)[dep].fetch(self)
         end
       end
     end

data/lib/pinball/version.rb

@@ -1,3 +1,3 @@
 module Pinball
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/pinball.rb

@@ -3,14 +3,24 @@ require 'pinball/container'
 require 'pinball/class'
 
 module Pinball
+  module Methods
+    attr_reader :overridden_dependencies
+
+    def override_dependency(key, value = nil, &block)
+      @overridden_dependencies[key] = ContainerItem.new(value || block)
+      Container.instance.inject(self)
+      self
+    end
+  end
+
+  attr_reader :dependencies
+
+
   def new(*args)
     object = allocate
     Container.instance.inject(object)
     object.send(:initialize, *args)
+    object.instance_variable_set(:@overridden_dependencies, {})
     object
   end
-
-  def dependencies
-    @dependencies
-  end
 end

data/spec/lib/pinball/class_spec.rb

@@ -45,4 +45,25 @@ describe Class do
       expect(foo.baz).to eq(0)
     end
   end
+
+  describe '#override_dependency' do
+    let!(:foo_instance) { foo.inject :baz ; foo.new }
+
+    subject { foo_instance.override_dependency(:baz, 1) }
+
+    it 'adds overridden dependency' do
+      subject
+      expect(foo_instance.overridden_dependencies[:baz]).not_to be_nil
+      #expect(foo_instance.baz).to eq(1)
+    end
+
+    it 'resolves overridden dependency' do
+      subject
+      expect(foo_instance.baz).to eq(1)
+    end
+
+    it 'returns self' do
+      expect(subject).to eq(foo_instance)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pinball
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Gleb Sinyavsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-09 00:00:00.000000000 Z
+date: 2014-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler