quill 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NWRmOGQ2ZDY1ZjU1ODFjY2UzMjU0MmZhZGMwZTFmOGFkZGFlODhjOQ==
+  data.tar.gz: !binary |-
+    ZDgzM2YyZmViNjI5NzQ5NTQ5MWY0YmRlMWM4M2JiNTZlNjA4YjQ3ZA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZWY1MWRkMmJkMTc4YzM0OGQ1M2M3ZTcwNjlkMjExZmI5ZGVlYmY5MzhlZGJh
+    ZDUxNTAyMDE4Njg3ODNmMGRiOTkxZjNkMzM3NDRhNGMxODE0MzE3NzM1ZmFh
+    MjkxODViNzUxOGRhODg1YTZiMTY1ZmRjMjEyNWU5ZjZlZmE4ZWY=
+  data.tar.gz: !binary |-
+    ZTZlYjgxYzU0MjgxZGFjOGYyZTk1NmM5NjZlOGNhMTRiMGZkYzBkYjU2ZGMz
+    OGRkNjQ5MWY0OWI1MDIxODdjYmRjY2Y2ODc3NjA4MDE1NTNkOTNlMWY0MDdh
+    OTBhZjQyZWYxNjg0NDNhZGI4YzNmMWQzYmFlMDUzNWRlNzU5MDQ=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-gemset

@@ -0,0 +1 @@
+quill

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Tim Cowlishaw
+
+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,124 @@
+# Quill
+
+Quill helps you write cleaner, clearer ruby code, by disentangling the business
+of specifying a classes dependencies from the business of constructing and
+supplying them.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'quill'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install quill
+
+## Usage
+
+Extend your classes with the Quill DSL in order to specify their dependencies.
+Each class must specify the name of the feature it implements, and can
+optionally specify a list of features on which it depends:
+
+```ruby
+require 'quill/dsl'
+class UIController
+  extend Quill::DSL
+
+  #The name of the feature implemented
+  provides :ui_controller
+
+  #The names of the features we depend on. These will be passed in order as
+arguments to the constructor.
+  depends [:logger, :display]
+
+  def initialize(logger, display)
+    @logger = logger
+    @display = display
+  end
+
+  def run!
+    #...do things with the logger and display
+  end
+end
+```
+
+You can then construct a Quill Container, and register all your Quill classes
+with them:
+
+```ruby
+  require 'quill/container'
+  container = Quill::Container.new
+  container.register_class(UIController)
+
+  #register implementation for every feature, so that the container can resolve
+the dependencies:
+  container.register_class(Logger)
+
+  #You can also register single instances as named features:
+  container.register_singleton(:display, STDOUT)
+
+```
+
+Finally, ask the container for the implementation of a feature, this will
+automatically resolve all the dependencies and construct the entire object
+graph!
+
+```ruby
+  controller = container[:ui_controller]
+  controller.run!
+```
+
+You can also lazily construct objects with a mixture of static dependencies and
+other arguments, using the 'curried' option:
+
+```ruby
+  require 'quill/dsl'
+  require 'quill/container'
+
+  class InventoryDisplay
+    extend Quill::DSL
+
+    provides :inventory_display
+    depends [:display]
+    curried
+
+    #the display dependency is injected, items is not.
+    def initialize(display, items)
+      @display = display
+      @items = items
+    end
+
+    container = Quill::Container.new
+    container.register_class(InventoryDisplay)
+
+    display_builder_proc = container[:inventory_display]
+
+    display_builder_proc.call(inventory) #=> Constructs and returns an instance
+```
+
+## Why?
+  [Dependency
+Injection](https://speakerdeck.com/bestie/improve-your-ruby-code-with-dependency-injection) is a fundamental pattern in object oriented programming, and is invaluable for making sure your code is testable and minimally coupled. However, it's often difficult to work out where the responsiblity for satisfying dependencies should happen. Quill takes care of this for you, with a simple, minimal framework for configuring your application's dependencies.
+
+## Compatibiliyu
+  Tested with Ruby 1.9.3
+
+## Still to come
+
+  - Support for argument hashes
+  - Support for Ruby 2.0 named arguments
+  - Configurable instance memoization
+
+
+## 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/features/declaring_dependencies.feature

@@ -0,0 +1,38 @@
+Feature: Declaring and Satisfying Dependencies
+
+  Scenario: Satisfying a dependency with a singleton
+    Given I have a factory with a named dependency
+    When I satisfy the named dependency with a singleton
+    And I call the factory
+    Then the factory should receive the singleton instance of its dependency
+
+  Scenario: Satisfying a dependency with a factory
+    Given I have a factory with a named dependency
+    When I satisfy the named dependency with another factory that has no dependencies
+    And I call the factory
+    Then the factory should receive an instance created by the dependency factory
+
+  Scenario: Transitively satisfying dependencies
+    Given I have a factory with a named dependency
+    When I satisfy the named dependency with another factory that has a dependency
+    And I satisfy that dependency with a singleton
+    And I call the factory
+    Then the dependency factory should receive the singleton instance of its dependency
+    And the factory should receive an instance created by the dependency factory
+
+  Scenario: Raising an error when dependencies are not satisfied
+    Given I have a factory with a named dependency
+    When I satisfy the named dependency with another factory that has a dependency
+    And I call the factory
+    Then an unmet dependency error should be raised for the transitive depenency
+
+  Scenario: Satisfying dependencies for curried factories
+    Given I have a curried factory with a named dependency
+    When I satisfy the named dependency with a singleton
+    And I call the factory
+    And I call the returned proc with additional arguments
+    Then the factory should receive the singleton dependency and the additional arguments
+
+  Scenario: Satisfying dependencies for factories that take an arguments hash
+
+  Scenario: Satisfying dependencies for curried factories that take an arguments hash

data/features/step_definitions/declaring_dependencies_steps.rb

@@ -0,0 +1,82 @@
+Given(/^I have a factory with a named dependency$/) do
+  @container = Quill::Container.new
+  @feature_class = Struct.new(:dependency) do
+    extend Quill::DSL
+    provides :feature
+    depends :dependency
+  end
+  @container.register_class(@feature_class)
+end
+
+Given(/^I have a curried factory with a named dependency$/) do
+  @container = Quill::Container.new
+  @feature_class = Struct.new(:dependency, :argument) do
+    extend Quill::DSL
+    provides :feature
+    depends :dependency
+    curried
+  end
+  @container.register_class(@feature_class)
+end
+
+When(/^I satisfy the named dependency with a singleton$/) do
+  @dependency = Object.new
+  @container.register_singleton(:dependency, @dependency)
+end
+
+When(/^I call the factory$/) do
+  begin
+    @feature = @container[:feature]
+  rescue Exception => e
+    @error = e
+  end
+end
+
+When(/^I satisfy the named dependency with another factory that has no dependencies$/) do
+  @dependency_class = Class.new do
+    extend Quill::DSL
+    provides :dependency
+  end
+  @container.register_class(@dependency_class)
+end
+
+When(/^I satisfy the named dependency with another factory that has a dependency$/) do
+  @dependency_class = Struct.new(:transitive_dependency) do
+    extend Quill::DSL
+    provides :dependency
+    depends :transitive_dependency
+  end
+  @container.register_class(@dependency_class)
+end
+
+When(/^I satisfy that dependency with a singleton$/) do
+  @transitive_dependency = Object.new
+  @container.register_singleton(:transitive_dependency, @transitive_dependency)
+end
+
+When(/^I call the returned proc with additional arguments$/) do
+  @argument = Object.new
+  @feature = @container[:feature][@argument]
+end
+
+Then(/^the factory should receive the singleton instance of its dependency$/) do
+  expect(@feature.dependency).to be == @dependency
+end
+
+Then(/^the factory should receive an instance created by the dependency factory$/) do
+  expect(@feature.dependency).to be_instance_of(@dependency_class)
+end
+
+Then(/^the dependency factory should receive the singleton instance of its dependency$/) do
+  expect(@feature.dependency.transitive_dependency).to be == @transitive_dependency
+end
+
+Then(/^the factory should receive the singleton dependency and the additional arguments$/) do
+  expect(@feature.dependency).to be == @dependency
+  expect(@feature.argument).to be == @argument
+end
+
+Then(/^an unmet dependency error should be raised for the transitive depenency$/) do
+  @error.should be_instance_of(Quill::UnsatisfiedDependencyError)
+  @error.dependency.should be == :transitive_dependency
+end

data/features/support/env.rb

@@ -0,0 +1 @@
+require 'quill'

data/lib/quill.rb

@@ -0,0 +1,5 @@
+module Quill
+end
+require "quill/version"
+require "quill/container"
+require "quill/dsl"

data/lib/quill/container.rb

@@ -0,0 +1,36 @@
+require 'quill/unsatisfied_dependency_error'
+require 'quill/no_factory_error'
+module Quill
+  class Container
+    def initialize
+      @singletons = {}
+      @factories = {}
+    end
+
+    def register_singleton(feature, instance)
+      @singletons[feature] = instance
+    end
+
+    def register_class(klass)
+      raise NoFactoryError.new(klass) unless klass.respond_to?(:factory)
+      factory = klass.factory
+      @factories[factory.feature] = factory
+    end
+
+    def [](name)
+      instance = named_singleton(name) || instance_from_named_factory(name)
+      instance or raise UnsatisfiedDependencyError.new(name)
+    end
+
+    private
+
+    def named_singleton(name)
+      @singletons[name]
+    end
+
+    def instance_from_named_factory(name)
+      factory = @factories[name]
+      factory && factory.call(self)
+    end
+  end
+end

data/lib/quill/dsl.rb

@@ -0,0 +1,33 @@
+require 'quill/factory'
+module Quill
+  module DSL
+
+    def factory
+      raise "You must specify a feature provided by the class" unless provided_feature
+      @factory ||= Quill::Factory.new(self, {
+        :feature => provided_feature,
+        :dependencies => @dependencies || [],
+        :curried => curried?
+      })
+    end
+
+    def provides(feature_name)
+      @provided_feature = feature_name
+    end
+
+    def depends(*dependency_names)
+      @dependencies = dependency_names
+    end
+
+    def curried(value = true)
+      @curried = value
+    end
+
+    private
+      attr_reader :provided_feature
+
+      def curried?
+        !!@curried
+      end
+  end
+end

data/lib/quill/factory.rb

@@ -0,0 +1,37 @@
+module Quill
+  class Factory
+    attr_reader :feature
+
+    def initialize(klass, arguments={})
+      @feature = arguments.fetch(:feature)
+      @dependencies = arguments[:dependencies] || []
+      @curried = arguments[:curried]
+      @klass = klass
+    end
+
+    def call(container)
+      curried? ? construct_curried_proc(container) : construct_instance(container)
+    end
+
+    private
+      attr_reader :klass, :dependencies
+
+      def curried?
+        !!@curried
+      end
+
+
+      def construct_instance(container, args=[])
+        arguments = fulfilled_dependencies(container) + args
+        @instance ||= klass.new(*arguments)
+      end
+
+      def construct_curried_proc(container)
+        ->(*args) { construct_instance(container, args) }
+      end
+
+      def fulfilled_dependencies(container)
+        dependencies.map { |dep| container[dep] }
+      end
+  end
+end

data/lib/quill/no_factory_error.rb

@@ -0,0 +1,14 @@
+module Quill
+  class NoFactoryError < RuntimeError
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def message
+      "The class #{klass.name} cannot be registered with the container, as it does not extend Quill::DSL."
+    end
+
+    private
+      attr_reader :klass
+  end
+end

data/lib/quill/unsatisfied_dependency_error.rb

@@ -0,0 +1,14 @@
+module Quill
+  class UnsatisfiedDependencyError < RuntimeError
+    def initialize(dependency)
+      @dependency = dependency
+      super
+    end
+
+    def message
+      "No implementation for the feature #{dependency} is registered with the container."
+    end
+
+    attr_reader :dependency
+  end
+end

data/lib/quill/version.rb

@@ -0,0 +1,3 @@
+module Quill
+  VERSION = "0.1.0"
+end

data/quill.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'quill/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "quill"
+  spec.version       = Quill::VERSION
+  spec.authors       = ["Tim Cowlishaw"]
+  spec.email         = ["tim@timcowlishaw.co.uk"]
+  spec.description   = %q{Quill helps you organize your code more easily by separating the business of specifying a class's dependencies from the business of actually providing them, using a simple, declerative syntax.}
+  spec.summary       = %q{Quill - Simple DI for your rupy applications}
+  spec.homepage      = "http://github.com/timcowlishaw/quill"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "cucumber"
+end

data/spec/quill/container_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'quill/container'
+require 'quill/unsatisfied_dependency_error'
+
+describe Quill::Container do
+  subject(:container) { Quill::Container.new }
+  let(:instance) { double(:instance) }
+  let(:name) { double(:factory) }
+
+  describe "requesting features which don't exist" do
+    it "raises an unment dependecy error for the feature" do
+      expect {
+        container[:non_existant_feature]
+      }.to raise_error { |error|
+        expect(error).to be_instance_of(Quill::UnsatisfiedDependencyError)
+        expect(error.dependency).to be == :non_existant_feature
+      }
+    end
+  end
+
+  describe "registering and returning singletons" do
+    it "returns the registed instance" do
+      container.register_singleton(name, instance)
+      expect(container[name]).to be(instance)
+    end
+  end
+
+  describe "registering and constructing classes" do
+    context "registering a class with a factory" do
+      it "calls the factory with itself when the named feature is requested" do
+        klass = double(:class)
+        instance = double(:instance)
+        factory = double(:factory, :feature => :feature_name)
+        expect(klass).to receive(:factory).and_return(factory)
+        container.register_class(klass)
+        expect(factory).to receive(:call).with(container).and_return(instance)
+        expect(container[:feature_name]).to be == instance
+      end
+    end
+
+    context "registering a class without a factory" do
+      it "raises an error" do
+        klass = double(:class)
+        expect {
+          container.register_class(klass)
+        }.to raise_error(Quill::NoFactoryError)
+      end
+    end
+  end
+end

data/spec/quill/dsl_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'quill/dsl'
+describe "Quill::DSL" do
+
+  let(:factory) { double(:factory) }
+
+  subject(:extending_class) {
+    Class.new do
+      extend Quill::DSL
+    end
+  }
+
+  before(:each) do
+    allow(Quill::Factory).to receive(:new).and_return(factory)
+  end
+
+  context "when a provided feature name is not supplied" do
+    it "raises an error when the factory is accessed" do
+      expect {
+        extending_class.factory
+      }.to raise_error
+    end
+  end
+
+  context "when a provided feature name is supplied" do
+    context "when no dependencies are supplied" do
+      it "exposes a Quill factory wrapping the extended class with the specified feature name and no dependencies" do
+        expect(Quill::Factory).to receive(:new).with(extending_class, {
+          :feature => :feature_name, :dependencies => [], :curried => false
+        }).and_return(factory)
+
+        extending_class.instance_eval do
+          extend Quill::DSL
+          provides :feature_name
+        end
+
+        expect(extending_class.factory).to be == factory
+      end
+    end
+
+    context "when dependencies are supplied" do
+      it "exposes a Quill factory wrapping the extended class with the specified feature name and the_specified dependencies" do
+        expect(Quill::Factory).to receive(:new).with(extending_class, {
+          :feature => :feature_name,
+          :dependencies => [:dependency_1, :dependency_2],
+          :curried => false
+        }).and_return(factory)
+
+        extending_class.instance_eval do
+          extend Quill::DSL
+          provides :feature_name
+          depends :dependency_1, :dependency_2
+        end
+
+        expect(extending_class.factory).to be == factory
+      end
+    end
+
+    context "when the factory is specified as curried" do
+      it "exposes a curried Quill factory wrapping the extended class with the specified feature name" do
+        expect(Quill::Factory).to receive(:new).with(extending_class, {
+          :feature => :feature_name, :dependencies => [], :curried => true
+        })
+        extending_class.instance_eval do
+          extend Quill::DSL
+          provides :feature_name
+          curried
+        end
+        expect(extending_class.factory).to be == factory
+      end
+    end
+  end
+end

data/spec/quill/factory_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'quill/factory'
+describe Quill::Factory do
+  let(:feature_name) { double(:feature_name) }
+  let(:klass) { double(:klass) }
+
+  subject(:factory) { Quill::Factory.new(klass, :feature => feature_name )}
+
+  describe "feature" do
+    it "returns the feature name" do
+      expect(factory.feature).to be == feature_name
+    end
+  end
+
+  describe "call" do
+    let(:container) { double(:container) }
+    let(:instance) { double(:instance) }
+
+    context "when the factory is not curried" do
+      context "when the factory has no dependencies" do
+        it "calls the class constructor with no arguments" do
+          expect(klass).to receive(:new).and_return(instance)
+          expect(factory.call(container)).to be == instance
+        end
+      end
+
+      context "when the factory has dependencies" do
+        let(:dependency_1) { double(:dependency_1) }
+        let(:dependency_2) { double(:dependency_2) }
+
+        subject(:factory) {
+          Quill::Factory.new(klass, {
+            :feature => feature_name,
+            :dependencies => [:dependency_1, :dependency_2],
+          })
+        }
+
+        it "calls the class constructor with the dependencies from the factory" do
+          expect(container).to receive(:[]).with(:dependency_1).and_return(dependency_1)
+          expect(container).to receive(:[]).with(:dependency_2).and_return(dependency_2)
+          expect(klass).to receive(:new).with(dependency_1, dependency_2).and_return(instance)
+          expect(factory.call(container)).to be == instance
+        end
+      end
+
+      it "memoizes the constructed instance of the class" do
+        allow(klass).to receive(:new) { Object.new }
+        first = factory.call(container)
+        second = factory.call(container)
+        expect(first).to eq(second)
+      end
+    end
+
+    context "when the factory is curried" do
+      context "when the factory has no dependencies" do
+        subject(:factory) {
+          Quill::Factory.new(klass, {
+            :feature => feature_name,
+            :curried => true,
+          })
+        }
+
+        it "returns a proc which calls the class constructor with no arguments" do
+          the_proc = factory.call(container)
+          expect(klass).to receive(:new).and_return(instance)
+          expect(the_proc.call).to be == instance
+        end
+      end
+
+      context "when the factory has dependencies" do
+        let(:dependency_1) { double(:dependency_1) }
+        let(:dependency_2) { double(:dependency_2) }
+        let(:additional_arg_1) { double(:additional_arg_1) }
+        let(:additional_arg_2) { double(:additional_arg_2) }
+
+        subject(:factory) {
+          Quill::Factory.new(klass, {
+            :feature => feature_name,
+            :dependencies => [:dependency_1, :dependency_2],
+            :curried => true
+          })
+        }
+
+        it "calls the class constructor with the dependencies from the factory" do
+          expect(container).to receive(:[]).with(:dependency_1).and_return(dependency_1)
+          expect(container).to receive(:[]).with(:dependency_2).and_return(dependency_2)
+          the_proc = factory.call(container)
+          expect(klass).to receive(:new).
+            with(dependency_1, dependency_2, additional_arg_1, additional_arg_2).
+            and_return(instance)
+          result = the_proc.call(additional_arg_1, additional_arg_2)
+          expect(result).to be == instance
+        end
+      end
+
+      it "memoizes the constructed instance of the class" do
+        allow(klass).to receive(:new) { Object.new }
+        first = factory.call(container)
+        second = factory.call(container)
+        expect(first).to eq(second)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+RSpec.configure do |c|
+  c.expect_with :rspec do |conf|
+    conf.syntax = :expect
+  end
+
+  c.mock_with :rspec do |conf|
+    conf.syntax = :expect
+  end
+
+  c.order = :random
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: quill
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tim Cowlishaw
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  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: Quill helps you organize your code more easily by separating the business
+  of specifying a class's dependencies from the business of actually providing them,
+  using a simple, declerative syntax.
+email:
+- tim@timcowlishaw.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- features/declaring_dependencies.feature
+- features/step_definitions/declaring_dependencies_steps.rb
+- features/support/env.rb
+- lib/quill.rb
+- lib/quill/container.rb
+- lib/quill/dsl.rb
+- lib/quill/factory.rb
+- lib/quill/no_factory_error.rb
+- lib/quill/unsatisfied_dependency_error.rb
+- lib/quill/version.rb
+- quill.gemspec
+- spec/quill/container_spec.rb
+- spec/quill/dsl_spec.rb
+- spec/quill/factory_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/timcowlishaw/quill
+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: []
+rubyforge_project: 
+rubygems_version: 2.0.4
+signing_key: 
+specification_version: 4
+summary: Quill - Simple DI for your rupy applications
+test_files:
+- features/declaring_dependencies.feature
+- features/step_definitions/declaring_dependencies_steps.rb
+- features/support/env.rb
+- spec/quill/container_spec.rb
+- spec/quill/dsl_spec.rb
+- spec/quill/factory_spec.rb
+- spec/spec_helper.rb