dependor 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+*.gem
+.bundle
+.rvmrc
+tags

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - jruby-19mode
+  - rbx-19mode
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dependor.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    dependor (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    ffi (1.0.11)
+    growl (1.0.3)
+    guard (1.0.1)
+      ffi (>= 0.5.0)
+      thor (~> 0.14.6)
+    guard-rspec (0.6.0)
+      guard (>= 0.10.0)
+    libnotify (0.7.2)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    thor (0.14.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  dependor!
+  growl
+  guard
+  guard-rspec
+  libnotify
+  rspec

data/Guardfile

@@ -0,0 +1,18 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+end

data/MIT-LICENSE

@@ -0,0 +1,7 @@
+Copyright (C) 2012 Adam Pohorecki
+
+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,286 @@
+# Dependor 
+
+[![build status](https://secure.travis-ci.org/psyho/dependor.png)](http://travis-ci.org/psyho/dependor)
+
+## What is Dependor
+
+Dependor is a set of helpers that make writing Ruby apps that use the dependency injection pattern easier.
+It comes as a set of modules, which you can selectively add to your project.
+It is designed do play nice with Rails and similar frameworks.
+
+## Manual Dependency Injection
+
+```ruby
+class Foo
+  def do_foo
+    "foo"
+  end
+end
+
+class Bar
+  def initialize(foo)
+    @foo = foo
+  end
+
+  def do_bar
+    @foo.do_foo + "bar"
+  end
+end
+
+class Injector
+  def foo
+    Foo.new
+  end
+
+  def bar
+    Bar.new(foo)
+  end
+end
+
+class EntryPoint
+  def inject
+    @injector ||= Injector.new
+  end
+
+  def bar
+    inject.bar
+  end
+
+  def run
+    bar.do_bar
+  end
+end
+
+EntryPoint.new.run
+```
+
+## The same thing with Dependor
+
+```ruby
+require 'dependor'
+require 'dependor/shorty'
+
+class Foo
+  def do_foo
+    "foo"
+  end
+end
+
+class Bar
+  takes :foo
+
+  def do_bar
+    @foo.do_foo + "bar"
+  end
+end
+
+class Injector
+  include Dependor::AutoInject
+end
+
+class EntryPoint
+  include Dependor::Injectable
+  inject_from Injector
+  
+  inject :bar
+
+  def run
+    bar.do_bar
+  end
+end
+
+EntryPoint.new.run
+```
+
+## Dependor::AutoInject
+
+This is the core part of the library.
+It looks at the constructor of a class to find out it's dependencies and instantiates it's instances with proper objects injected.
+It looks up classes by name.
+
+AutoInject can also use the methods declared on injector as injection sources, which is quite useful for things like configuration.
+
+```ruby
+class Injector
+  include Dependor::AutoInject
+
+  attr_reader :session
+
+  def initialize(session)
+    @session = session
+  end
+
+  let(:current_user) { current_user_service.get }
+  let(:users_repository) { User }
+  let(:comments_repository) { Comment }
+end
+
+class CurrentUserService
+  takes :session, :users_repository
+
+  def get
+    @current_user ||= users_repository.find(session[:current_user_id])
+  end
+end
+
+class CreatesComments
+  takes :current_user, :comments_repository
+
+  def create
+    # ...
+  end
+end
+
+class User < ActiveRecord::Base
+end
+
+class Comment < ActiveRecord::Base
+end
+```
+
+## Dependor::Shorty
+
+This makes the constructor definition less verbose and includes Dependor::Let for shorter method definition syntax.
+
+```ruby
+class Foo
+  takes :foo, :bar, :baz
+  let(:hello) { "world" }
+end
+```
+
+is equivalent to:
+
+```ruby
+class Foo
+  attr_reader :foo, :bar, :baz
+
+  def initialize(foo, bar, baz)
+    @foo = foo
+    @bar = bar
+    @baz = baz
+  end
+
+  def hello
+    "world"
+  end
+end
+```
+
+## Dependor::Constructor
+
+Sometimes you don't want to pollute every class with a `takes` method.
+You can then shorten the class declaration with Dependor::Constructor.
+
+```ruby
+class Foo
+  include Dependor::Constructor(:foo, :bar, :baz)
+end
+```
+
+is equivalent to:
+
+```ruby
+class Foo
+  def initialize(foo, bar, baz)
+    @foo = foo
+    @bar = bar
+    @baz = baz
+  end
+end
+```
+
+## Dependor::Let
+
+It allows a simpler syntax to define getter methods.
+
+```ruby
+class Foo
+  def foo
+    do_something_or_other
+  end
+end
+```
+
+becomes:
+
+```ruby
+class Foo
+  extend Dependor::Let
+  let(:foo) { do_something_or_other }
+end
+```
+
+## Dependor::Injectable
+
+You can include this to make usage of the injector more convenient.
+This is used in the entry point of your application, typically a Rails controller.
+
+```ruby
+class MyInjector
+  def foo
+    "foo"
+  end
+end
+
+class ApplicationController
+  extend Dependor::Injectable
+  inject_from MyInjector
+end
+
+class PostsController < ApplicationController
+  inject :foo
+
+  def get
+    render text: foo
+  end
+end
+```
+
+Sometimes you might want to pass request, params or session to your injector.
+Here is an example, how to do it:
+
+```ruby
+require 'dependor/shorty'
+
+class MyInjector
+  include Dependor::AutoInject
+  
+  takes :params, :session, :request
+
+  def foo
+    session[:foo]
+  end
+end
+
+class ApplicationController
+  extend Dependor::Injectable
+
+  def injector
+    @injector ||= MyInjector.new(params, session, request)
+  end
+end
+
+class PostsController < ApplicationController
+  inject :foo
+
+  def get
+    render text: foo
+  end
+end
+```
+
+## License
+
+MIT. See the MIT-LICENSE file.
+
+## Author
+
+Adam Pohorecki
+
+## Acknowledgements
+
+Dependor::Shorty is inspired (or rather blatantly copied) from Gary Bernhardt's [Destroy All Software Screencast][das] ["Shorter Class Syntax"][shorter-syntax].
+
+[das]: http://www.destroyallsoftware.com
+[shorter-syntax]: https://www.destroyallsoftware.com/screencasts/catalog/shorter-class-syntax

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+  t.rspec_opts = ["--profile --color --format=documentation"]
+end
+
+task :default => :spec

data/dependor.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dependor/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dependor"
+  s.version     = Dependor::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Adam Pohorecki"]
+  s.email       = ["adam@pohorecki.pl"]
+  s.homepage    = "http://github.com/psyho/dependor"
+  s.summary     = %q{A couple of classes and modules that simplify dependency injection in Ruby.}
+  s.description = %q{Dependor is not a framework for Dependency Injection, but something thatt reduces duplication a little bit when doing manual dependency injection in settings like Rails apps.}
+
+  s.rubyforge_project = "dependor"
+
+  s.add_development_dependency 'rspec'
+
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-rspec'
+  s.add_development_dependency 'growl'
+  s.add_development_dependency 'libnotify'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/dependor.rb

@@ -0,0 +1,13 @@
+require 'dependor/constructor'
+
+module Dependor
+  autoload :AutoInject,        'dependor/auto_inject'
+  autoload :AutoInjector,      'dependor/auto_injector'
+  autoload :ClassNameResolver, 'dependor/class_name_resolver'
+  autoload :Injectable,        'dependor/injectable'
+  autoload :Instantiator,      'dependor/instantiator'
+  autoload :Let,               'dependor/let'
+  autoload :Shorty,            'dependor/shorty'
+  autoload :UnknownObject,     'dependor/exceptions'
+  autoload :VERSION,           'dependor/version'
+end

data/lib/dependor/auto_inject.rb

@@ -0,0 +1,35 @@
+module Dependor
+  module AutoInject
+
+    module ClassMethods
+      def look_in_modules(*modules)
+        search_modules.concat(modules)
+      end
+
+      def search_modules
+        @search_modules ||= []
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    def method_missing(name, *args, &block)
+      auto_injector.get(name)
+    end
+
+    def respond_to?(name)
+      auto_injector.resolvable?(name)
+    end
+
+    private
+
+    def auto_injector
+      @auto_injector ||= Dependor::AutoInjector.new(self, self.class.search_modules)
+    end
+
+  end
+
+end
+

data/lib/dependor/auto_injector.rb

@@ -0,0 +1,37 @@
+module Dependor
+  class AutoInjector
+
+    def initialize(injector, search_modules)
+      @injector = injector
+      @instantiator = Instantiator.new(self)
+      @class_name_resolver = ClassNameResolver.new(search_modules)
+    end
+
+    def get(name)
+      ensure_resolvable!(name)
+
+      return @injector.send(name) if method_exists?(name)
+
+      klass = @class_name_resolver.for_name(name)
+      @instantiator.instantiate(klass)
+    end
+
+    def resolvable?(name)
+      method_exists?(name) || !!@class_name_resolver.for_name(name)
+    end
+
+    private
+
+    def ensure_resolvable!(name)
+      unless resolvable?(name)
+        raise UnknownObject.new("Injector does not know how to create object: #{name}")
+      end
+    end
+
+    def method_exists?(name)
+      @injector.methods.include?(name)
+    end
+
+  end
+
+end

data/lib/dependor/class_name_resolver.rb

@@ -0,0 +1,30 @@
+module Dependor
+  class ClassNameResolver
+    attr_reader :search_modules
+
+    def initialize(search_modules)
+      @search_modules = search_modules
+    end
+
+    def for_name(name)
+      class_name = camelize(name)
+      modules = search_modules.concat([Object])
+      klass = nil
+
+      modules.each do |mod|
+        klass = mod.const_get(class_name) rescue nil
+        break if klass
+      end
+
+      klass
+    end
+
+    private
+
+    def camelize(symbol)
+      string = symbol.to_s
+      string = string.gsub(/_\w/) { |match| match[1].upcase }
+      return string.gsub(/^\w/) { |match| match.upcase }
+    end
+  end
+end

data/lib/dependor/constructor.rb

@@ -0,0 +1,13 @@
+module Dependor
+  def self.Constructor(*names)
+    eval <<-RUBY
+
+    Module.new do
+      def initialize(#{names.join(', ')})
+        #{names.map{ |name| "@#{name} = #{name}" }.join("\n") }
+      end
+    end
+
+    RUBY
+  end
+end

data/lib/dependor/exceptions.rb

@@ -0,0 +1,3 @@
+module Dependor
+  class UnknownObject < RuntimeError; end
+end

data/lib/dependor/injectable.rb

@@ -0,0 +1,17 @@
+module Dependor
+  module Injectable
+    def inject_from(klass)
+      define_method :injector do
+        @injector ||= klass.new
+      end
+    end
+
+    def inject(*names)
+      names.each do |name|
+        define_method name do
+          injector.send(name)
+        end
+      end
+    end
+  end
+end

data/lib/dependor/instantiator.rb

@@ -0,0 +1,14 @@
+module Dependor
+  class Instantiator
+    def initialize(injector)
+      @injector = injector
+    end
+
+    def instantiate(klass)
+      params = klass.instance_method(:initialize).parameters
+      dependency_names = params.select{|type, name| type == :req}.map{|type, name| name}
+      dependencies = dependency_names.map{|name| @injector.get(name)}
+      return klass.new(*dependencies)
+    end
+  end
+end

data/lib/dependor/let.rb

@@ -0,0 +1,7 @@
+module Dependor
+  module Let
+    def let(name, &block)
+      define_method(name, &block)
+    end
+  end
+end

data/lib/dependor/shorty.rb

@@ -0,0 +1,13 @@
+module Dependor
+  module Shorty
+    def takes(*names)
+      attr_reader *names
+      include Dependor::Constructor(*names)
+      extend Dependor::Let
+    end
+  end
+end
+
+class Object
+  extend Dependor::Shorty
+end

data/lib/dependor/version.rb

@@ -0,0 +1,3 @@
+module Dependor
+  VERSION = "0.0.1"
+end

data/spec/dependor/auto_inject_spec.rb

@@ -0,0 +1,79 @@
+require_relative '../spec_helper'
+
+require 'dependor/shorty'
+
+describe Dependor::AutoInject do
+  class SampleClassWithNoDependencies
+  end
+
+  class SampleClassWithDependency
+    takes :sample_class_with_no_dependencies
+  end
+
+  class SampleClassWithManualDependency
+    takes :manual_dep
+  end
+
+  module SomeModule
+    class SampleClassWithinSomeModule
+    end
+  end
+
+  class SampleInjector
+    include Dependor::AutoInject
+    look_in_modules SomeModule
+
+    def manual_dep
+      "manual dep"
+    end
+  end
+
+  let(:injector) { SampleInjector.new }
+
+  shared_examples_for 'dependency injector' do
+    it 'responds to the object name' do
+      injector.should respond_to(object_name)
+    end
+
+    it 'creates the object' do
+      injector.send(object_name).should be_an_instance_of(object_class)
+    end
+  end
+
+  context 'no dependencies' do
+    let(:object_name) { :sample_class_with_no_dependencies }
+    let(:object_class) { SampleClassWithNoDependencies }
+
+    it_behaves_like 'dependency injector'
+  end
+
+  context 'dependencies on other objects' do
+    let(:object_name) { :sample_class_with_dependency }
+    let(:object_class) { SampleClassWithDependency }
+
+    it_behaves_like 'dependency injector'
+  end
+
+  context 'dependencies on objects returned by methods on the injector' do
+    let(:object_name) { :sample_class_with_manual_dependency }
+    let(:object_class) { SampleClassWithManualDependency }
+
+    it_behaves_like 'dependency injector'
+  end
+
+  context 'dependencies from another module' do
+    let(:object_name) { :sample_class_within_some_module }
+    let(:object_class) { SomeModule::SampleClassWithinSomeModule }
+
+    it_behaves_like 'dependency injector'
+  end
+
+  it "raises an error if the object is not found" do
+    proc{ injector.unknown_object }.should raise_exception(Dependor::UnknownObject)
+  end
+
+  it 'responds to regular methods on injector' do
+    injector.should respond_to(:manual_dep)
+  end
+
+end

data/spec/dependor/class_name_resolver_spec.rb

@@ -0,0 +1,43 @@
+require_relative '../spec_helper'
+
+describe Dependor::ClassNameResolver do
+  class FooBarBaz
+  end
+
+  class FooBarBaz2
+  end
+
+  module Foo
+    class FooBarBaz
+    end
+  end
+
+  module Bar
+    class FooBarBaz
+    end
+  end
+
+  it "returns nil when the class could not be found" do
+    resolver = Dependor::ClassNameResolver.new([])
+
+    resolver.for_name(:something).should be_nil
+  end
+
+  it "uses global scope with no search_modules" do
+    resolver = Dependor::ClassNameResolver.new([])
+
+    resolver.for_name(:foo_bar_baz).should == FooBarBaz
+  end
+
+  it "searches modules in order specified" do
+    resolver = Dependor::ClassNameResolver.new([Foo, Bar])
+
+    resolver.for_name(:foo_bar_baz).should == Foo::FooBarBaz
+  end
+
+  it "searches in order specified, with the global scope last" do
+    resolver = Dependor::ClassNameResolver.new([Foo, Bar])
+
+    resolver.for_name(:foo_bar_baz_2).should == FooBarBaz2
+  end
+end

data/spec/dependor/constructor_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../spec_helper'
+
+describe 'Dependor::Constructor' do
+  class SampleClassUsingConstructor
+    include Dependor::Constructor(:foo, :bar, :baz)
+
+    def as_instance_variables
+      {foo: @foo, bar: @bar, baz: @baz}
+    end
+  end
+
+  it 'defines a constructor with given parameters' do
+    sample = SampleClassUsingConstructor.new('aaa', 'bbb', 'ccc')
+    sample.as_instance_variables.should == {foo: 'aaa', bar: 'bbb', baz: 'ccc'}
+  end
+end

data/spec/dependor/injectable_spec.rb

@@ -0,0 +1,63 @@
+require_relative '../spec_helper'
+
+describe Dependor::Injectable do
+  class SampleInjector
+    def foo
+      "foo"
+    end
+  end
+
+  class SampleInjectable
+    extend Dependor::Injectable
+    inject_from(SampleInjector)
+
+    inject :foo
+
+    def hello_foo
+      "hello #{foo}"
+    end
+  end
+
+  class SampleInjectableWithoutAnInjector
+    extend Dependor::Injectable
+
+    inject :foo
+
+    def hello_foo
+      "hello #{foo}"
+    end
+  end
+
+  it "requires the class to provide injector method" do
+    injectable = SampleInjectableWithoutAnInjector.new
+
+    expect do
+      injectable.hello_foo
+    end.to raise_exception
+  end
+
+  it "uses the provided injector" do
+    injectable = SampleInjectable.new
+
+    injectable.hello_foo.should == 'hello foo'
+  end
+
+  describe "typical Rails usage" do
+    class ApplicationController
+      extend Dependor::Injectable
+      inject_from SampleInjector
+    end
+
+    class PostsController < ApplicationController
+      inject :foo
+
+      def get
+        "render #{foo}"
+      end
+    end
+
+    it "should return foo value in child controller" do
+      PostsController.new.get.should == "render foo"
+    end
+  end
+end

data/spec/dependor/instantiator_spec.rb

@@ -0,0 +1,37 @@
+require_relative '../spec_helper'
+
+describe Dependor::Instantiator do
+  let(:injector) { stub(:injector) }
+  let(:instantiator) { Dependor::Instantiator.new(injector) }
+
+  it "instantiates objects with no-arg constructors" do
+    klass = Class.new do
+      def foo
+        "foo"
+      end
+    end
+
+    instance = instantiator.instantiate(klass)
+    instance.foo.should == "foo"
+  end
+
+  it "instantiates objects with constructors" do
+    klass = Class.new do
+      def initialize(foo, bar, baz)
+        @foo = [foo, bar, baz].join('-')
+      end
+
+      def foo
+        @foo
+      end
+    end
+
+    injector.should_receive(:get).with(:foo).and_return("foo")
+    injector.should_receive(:get).with(:bar).and_return("bar")
+    injector.should_receive(:get).with(:baz).and_return("baz")
+
+    instance = instantiator.instantiate(klass)
+
+    instance.foo.should == 'foo-bar-baz'
+  end
+end

data/spec/dependor/let_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../spec_helper'
+
+describe Dependor::Let do
+  class SampleClassUsingLet
+    extend Dependor::Let
+
+    let(:foo) { "foo foo" }
+  end
+
+  it 'shortens method declaration' do
+    SampleClassUsingLet.new.foo.should == "foo foo"
+  end
+end

data/spec/dependor/shorty_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../spec_helper'
+
+require 'dependor/shorty'
+
+describe Dependor::Shorty do
+  class SampleClassThatUsesTakes
+    takes :foo, :bar, :baz
+
+    def as_instance_variables
+      {foo: @foo, bar: @bar, baz: @baz}
+    end
+
+    def as_attributes
+      {foo: foo, bar: bar, baz: baz}
+    end
+  end
+
+  subject{ SampleClassThatUsesTakes.new('foo value', 'bar value', 'baz value') }
+
+  it 'defines a constructor with given names' do
+    subject.as_instance_variables.should == { foo: 'foo value',
+      bar: 'bar value',
+      baz: 'baz value'
+    }
+  end
+
+  it 'defines attr_reader for the given names' do
+    subject.as_attributes.should == { foo: 'foo value',
+      bar: 'bar value',
+      baz: 'baz value'
+    }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$:.push File.expand_path("../../lib", __FILE__)
+
+require 'rubygems'
+require 'rspec'
+
+require 'dependor'
+
+RSpec.configure do |c|
+  c.color_enabled = true
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: dependor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Adam Pohorecki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &71879150 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *71879150
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &71878830 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *71878830
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &71878470 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *71878470
+- !ruby/object:Gem::Dependency
+  name: growl
+  requirement: &71878150 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *71878150
+- !ruby/object:Gem::Dependency
+  name: libnotify
+  requirement: &71877780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *71877780
+description: Dependor is not a framework for Dependency Injection, but something thatt
+  reduces duplication a little bit when doing manual dependency injection in settings
+  like Rails apps.
+email:
+- adam@pohorecki.pl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- dependor.gemspec
+- lib/dependor.rb
+- lib/dependor/auto_inject.rb
+- lib/dependor/auto_injector.rb
+- lib/dependor/class_name_resolver.rb
+- lib/dependor/constructor.rb
+- lib/dependor/exceptions.rb
+- lib/dependor/injectable.rb
+- lib/dependor/instantiator.rb
+- lib/dependor/let.rb
+- lib/dependor/shorty.rb
+- lib/dependor/version.rb
+- spec/dependor/auto_inject_spec.rb
+- spec/dependor/class_name_resolver_spec.rb
+- spec/dependor/constructor_spec.rb
+- spec/dependor/injectable_spec.rb
+- spec/dependor/instantiator_spec.rb
+- spec/dependor/let_spec.rb
+- spec/dependor/shorty_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/psyho/dependor
+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: 637782349
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 637782349
+requirements: []
+rubyforge_project: dependor
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A couple of classes and modules that simplify dependency injection in Ruby.
+test_files: []