tame_the_beast 0.1.0

data/Guardfile

@@ -0,0 +1,8 @@
+notification :growl
+
+cli_options = `cat $HOME/.rspec .rspec 2>/dev/null`.gsub("\n", ' ')
+guard 'rspec', :version => 2, :cli => cli_options do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Thomas Stratmann
+
+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 @@
+# TameTheBeast
+
+## What?
+
+TameTheBeast lets you define the creation of components of your application in a central container.
+It is inspired by [this blog post](http://onestepback.org/index.cgi/Tech/Ruby/DependencyInjectionInRuby.rdoc) by
+Jim Weirich.
+
+## Why?
+
+A central singleton is eventually inevitable for any application, but if you are like me, it tends to
+suck up and swallow functionality that really should be separate from each other. You end up with one big blob
+of unmanageable spaghetti since everything is tightly coupled.
+
+Dependency injection is a way out that has proven to be effective in OOP. TameTheBeast aims at giving some nice lightweight sugar above it. (What it actually does is it patronizes you. Have been warned.)
+
+## Show me code!
+
+    container = TameTheBease.new
+
+    container.register(:app_state) do
+      { :running => false, :initializing => true }
+    end
+
+    container.register(:splash_window, :using => :app_state) do |h|
+      SplashWindow.new(h.app_state)
+    end
+    
+    # ...many more components registered here...
+    
+    resolution = container.resolve(:for => [:splash_window, ...])
+    # => { :splash_window => <SplashWindow...> }
+
+So this is the pattern:
+
+* register your components with a slot (which must be a Symbol) and a constructing block
+* the block argument gives you access to your dependencies. I call it the **inject hash**.
+* declare your dependencies with the :using option, they will appear in the inject hash
+* resolve for the components you need to kick your application up
+
+Explicitly declaring your dependencies in this way _really_ helps in refactoring later!
+
+## Features
+
+### Sugar
+
+#### Hash access
+
+Access the resolution and the inject hashes by `[]` or by name.
+That means you can say `resolution[:app_state]` as well as `resolution.app_state`. Same for the inject hashes.
+
+#### Control what's getting resolved for
+
+There are three ways to accomplish that:
+
+    container.resolve_for :configuration, :app_state
+    # or, at register time
+    container.register(:printer_dialog, :resolve => true)
+    # or, at resolution time
+    container.resolve(:for => [:configuration, :app_state])
+
+All components mentioned in any of the three ways will get resolved for. Call `resolve_for` as often as you like.
+
+#### Slim dependency notation
+
+Slots have to be symbols, but when declaring dependencies or resolving, 
+you can reference them as strings like this:
+
+    container.register(:foo, :using => %w{bar baz}) { ... }
+
+    container.resolve_for %w{foo bar baz}
+
+#### Stubbing
+
+Is this really sugar? Not sure. Anyway, you can leave off the block on `register`,
+and the component will be initialized as a stub. This way you can play around with the effects of
+refactorings on dependencies to some extent without having to go too deep.
+
+The stub will yell at you when you try to use it.
+
+### Is my container complete? Do I have a dependency loop?
+
+Just ask.
+
+    container.complete?
+    container.free_of_loops?
+
+If there are dependency loops, `resolve` will raise an exception.
+
+### Give me a dependency graph, please.
+
+Nothing fancy yet, but you can do
+
+    container.render_dependencies(:format => :hash)
+    # => { :splash_window => [:app_state], ... }
+
+Let me know if you know of a way to visualize this easily!
+
+### Post-injection as a last resort
+
+I have not yet completely made up my mind about this yet, but it seems like it is not always possible to avoid circular dependencies. You can break them up and post-inject like this:
+
+    container.register(:component) do |h|
+      ...
+    end.post_inject_into { |h| h.parent = h.root_something } # or similar foo
+
+The post injection block will be called right before the resolution is returned. It is passed
+the resolution.
+
+If you think you need this feature, _really_ think hard if you cannot find a way around (I believe there usually is). Using this feature should actually give you some pain, but I could not find a reliable way to implement this.
+
+### Multi-phase initialization / Injection of pre-existing objects
+
+There is no such thing as incremental resolution, you cannot use a component directly while still registering construction of others.
+
+However, you can break up the registration into multiple phases and simply inject the result of prior `resolve` runs:
+
+    container.inject(resolution_from_the_past)
+
+If you have existing objects, you can actually keep them in a hash and inject them in this way. There is nothing special about using a `resolve` result here!
+
+## License
+
+Released under the MIT License.  See the [LICENSE](https://github.com/schnittchen/tame_the_beast/blob/master/LICENSE.md) file for further details.

data/lib/tame_the_beast.rb

@@ -0,0 +1,12 @@
+require 'tame_the_beast/armory'
+
+module TameTheBeast
+  class Incomplete < RuntimeError; end
+  class CircularDependency < RuntimeError; end
+  class BadComponent < RuntimeError; end
+  class StubUsedError < RuntimeError; end
+
+  def self.new(*args)
+    Armory.new *args
+  end
+end

data/lib/tame_the_beast/armory.rb

@@ -0,0 +1,142 @@
+require 'tame_the_beast/reg_entry'
+require 'tame_the_beast/stub'
+
+module TameTheBeast
+  class Armory
+    def initialize
+      @registry = {}
+      @resolve_for = []
+    end
+
+    class ChainedDSLObject
+      def initialize(reg_entry)
+        @reg_entry = reg_entry
+      end
+
+      def post_inject_into(&block)
+        @reg_entry.post_inject_block = block
+      end
+    end
+
+    def register(slot, options = {}, &block)
+      using = options.delete(:using) || []
+      @resolve_for << slot if options[:resolve]
+      reg_entry = _register(slot, using, block)
+      return ChainedDSLObject.new reg_entry
+    end
+
+    def inject(hash_like)
+      hash_like.each do |slot, object|
+        block = lambda { object }
+        _register(slot, [], block)
+      end
+      return self
+    end
+
+    def complete?
+      @registry.each do |slot, entry|
+        entry.dependent_slots.each do |dependent_slot|
+          unless @registry.key? dependent_slot
+            yield dependent_slot, slot if block_given?
+            return false
+          end
+        end
+      end
+      return true
+    end
+
+    def free_of_loops?
+      raise Incomplete, "Armory is incomplete!" unless complete?
+
+      dependency_chains = @registry.keys.map &method(:Array)
+
+      until dependency_chains.empty?
+        dependency_chains = dependency_chains.map do |chain|
+          chain_begin, chain_end = chain.first, chain.last
+
+          @registry[chain.last].dependent_slots.map do |dependent_slot|
+            if dependent_slot == chain_begin
+              yield chain if block_given?
+              return false
+            end
+
+            chain + [dependent_slot]
+          end
+
+        end.reduce([], :+)
+      end
+      return true
+    end
+
+    def render_dependencies(options = {})
+      format = options[:format] || :hash
+      raise "Unknown format #{format}" unless %w{hash}.include? format.to_s
+
+      hash = Hash[@registry.map do |slot, entry|
+        [slot, entry.dependent_slots]
+      end]
+
+      return hash
+    end
+
+    def resolve_for(*args)
+      args = args.first if args.first.kind_of? Array
+      @resolve_for += args.map &:to_sym
+      return self
+    end
+
+    def resolve(options = {})
+      inject_dependent_reg_entries
+
+      assert_complete_and_free_of_loops
+
+      #do the actual resolution
+      @resolve_for += Array(options[:for]).map &:to_sym
+      #return magic hash here
+      resolution = Hash[@resolve_for.map { |key| [key, @registry[key].value] }]
+
+      #remove unused entries
+      @registry.values.reject(&:constructed?).each { |reg_entry| @registry.delete reg_entry.key }
+
+      #call post_inject_blocks
+      component_hash = Container.from_reg_entries @registry.values
+      @registry.values.map(&:post_inject_block).compact.each do |post_inject_block|
+        post_inject_block.call(component_hash)
+      end
+
+      @registry.clear
+
+      return Container[resolution]
+    end
+
+    private
+
+    def _register(slot, using, block)
+      slot = slot.to_sym
+      using = Array(using).map &:to_sym
+      block = block_or_default_for_slot slot, block
+
+      reg_entry = RegEntry.new :slot => slot, :constructor => block, :dependent_slots => using
+      @registry[slot] = reg_entry
+      return reg_entry
+    end
+
+    def block_or_default_for_slot(key, block)
+      return block || lambda do
+        Stub.new key.inspect
+      end
+    end
+
+    def inject_dependent_reg_entries
+      @registry.values.each do |reg_entry|
+        reg_entry.dependent_reg_entries = reg_entry.dependent_slots.map { |slot| @registry[slot] }
+      end
+    end
+
+    def assert_complete_and_free_of_loops
+      complete? { |dependent_slot, slot| raise Incomplete, "No component #{dependent_slot} defined (needed by #{slot}" }
+      free_of_loops? { |bad_chain| raise CircularDependency, "Circular dependency: #{bad_chain.join ' '}" }
+    end
+
+  end
+end

data/lib/tame_the_beast/container.rb

@@ -0,0 +1,23 @@
+module TameTheBeast
+  class Container < Hash
+    def self.[](*args)
+      new.replace Hash[*args]
+    end
+
+    def self.from_reg_entries(entries)
+      self[entries.map { |re| [re.key, re.value] }]
+    end
+
+    def method_missing(sym)
+      self[sym]
+    end
+
+    def [](key)
+      fetch key, &method(:_bad_access)
+    end
+
+    def _bad_access(sym)
+      raise BadComponent, "component #{sym} unknown or unavailable"
+    end
+  end
+end

data/lib/tame_the_beast/reg_entry.rb

@@ -0,0 +1,26 @@
+require 'tame_the_beast/container'
+
+module TameTheBeast
+  class RegEntry
+    attr_reader :key, :dependent_slots, :constructed
+    attr_writer :dependent_reg_entries
+    attr_accessor :post_inject_block
+    alias_method :constructed?, :constructed
+
+    def initialize(data)
+      @key, @constructor, @dependent_slots = data.values_at :slot, :constructor, :dependent_slots
+      @post_inject_block, @constructed = nil, false
+    end
+
+    def value
+      return @value if @constructed
+      @value = @constructor.call(constructor_argument).tap { @constructed = true }
+    end
+
+    private
+
+    def constructor_argument
+      Container.from_reg_entries @dependent_reg_entries
+    end
+  end
+end

data/lib/tame_the_beast/stub.rb

@@ -0,0 +1,11 @@
+module TameTheBeast
+  class Stub
+    def initialize(name)
+      @name = name
+    end
+
+    def method_missing(sym, *args)
+      raise StubUsedError, "#{sym.inspect} invoked on component #{@name}, which is only a stub!"
+    end
+  end
+end

data/lib/tame_the_beast/version.rb

@@ -0,0 +1,3 @@
+module TameTheBeast
+  VERSION = '0.1.0'
+end

data/spec/acceptance/tame_the_beast_spec.rb

@@ -0,0 +1,268 @@
+require 'tame_the_beast'
+
+module TameTheBeast
+  describe TameTheBeast do
+    subject { TameTheBeast.new }
+
+    describe ".resolve" do
+      context "with registered dependencies a -> b -> c" do
+        before(:each) do
+          @component_hashes = {}
+          subject.register(:a, :using => :b) do |c|
+            @component_hashes[:a] = c
+            { :item => :a }
+          end
+          subject.register(:b, :using => :c) do |c|
+            @component_hashes[:b] = c
+            { :item => :b }
+          end
+        end
+
+        it "should detect that c has not been registered" do
+          lambda { subject.resolve(:for => %w{a b}) }.should raise_error(described_class::Incomplete)
+        end
+
+        context "with registered dependency c -> a" do
+          before(:each) { subject.register(:c, :using => :a) { 2 } }
+
+          it "should detect circular dependency" do
+            lambda { subject.resolve(:for => %w{a b c}) }.should raise_error(described_class::CircularDependency)
+          end
+        end
+
+        context "with simple leaf node c" do
+          before(:each) do
+            subject.register(:c) do |c|
+              @component_hashes[:c] = c
+              { :item => :c }
+            end
+          end
+
+          it "should call constructor blocks with an argument" do
+            subject.resolve(:for => %w{a b c})
+
+            @component_hashes.should have_key(:a)
+            @component_hashes.should have_key(:b)
+            @component_hashes.should have_key(:c)
+          end
+
+          it "should pass sparse component hash to constructor blocks" do
+            subject.resolve(:for => %w{a b c})
+
+            @component_hashes[:a].should have(1).item
+            @component_hashes[:b].should have(1).item
+            @component_hashes[:c].should be_empty
+          end
+
+          it "should raise BadComponent when trying to access an empty slot in a component hash" do
+            subject.resolve(:for => %w{a b c})
+
+            chash = @component_hashes[:a]
+            lambda { chash.a }.should raise_error(described_class::BadComponent)
+            lambda { chash.c }.should raise_error(described_class::BadComponent)
+            lambda { chash.x }.should raise_error(described_class::BadComponent)
+
+            chash = @component_hashes[:b]
+            lambda { chash.a }.should raise_error(described_class::BadComponent)
+            lambda { chash.b }.should raise_error(described_class::BadComponent)
+
+            chash = @component_hashes[:c]
+            lambda { chash.a }.should raise_error(described_class::BadComponent)
+            lambda { chash.b }.should raise_error(described_class::BadComponent)
+            lambda { chash.c }.should raise_error(described_class::BadComponent)
+          end
+
+          it "should pass component hash to constructor blocks containing the right components" do
+            subject.resolve(:for => %w{a b c})
+
+            @component_hashes[:a].b[:item].should == :b
+            @component_hashes[:b].c[:item].should == :c
+          end
+
+          describe "result" do
+            let(:resolution) { subject.resolve(:for => %w{a b}) }
+
+            it "contains requested components" do
+#              resolution = subject.resolve(:for => %w{a b})
+              resolution.should have(2).items
+              resolution[:a][:item].should == :a
+              resolution[:b][:item].should == :b
+            end
+
+            it "exposes components as methods as well" do
+              resolution.a.should be_equal(resolution[:a])
+              resolution.b.should be_equal(resolution[:b])
+            end
+          end
+
+          describe ".inject" do
+            it "is chainable" do
+              subject.inject({}).should be_equal(subject)
+            end
+          end
+
+          describe "effect of .inject" do
+            before(:each) do
+              subject.inject :injected => 'injected'
+            end
+
+            it "allows me to resolve for injected objects" do
+              resolution = subject.resolve(:for => %w{injected})
+
+              resolution.should have_key(:injected)
+              resolution[:injected].should == 'injected'
+            end
+
+            it "allows me to use injected object for injecting into another slot object" do
+              subject.register(:x, :using => :injected) do |c|
+                @component_hashes[:x] = c
+                "x"
+              end
+              subject.resolve :for => :x
+
+              chash = @component_hashes[:x]
+              chash.should have_key(:injected)
+              chash[:injected].should == "injected"
+            end
+          end
+        end
+
+        context "with leaf node c subject to post injection" do
+          before(:each) do
+            subject.register(:c) do |c|
+              @component_hashes[:c] = c
+              { :item => :c }
+            end.post_inject_into { |c| @component_hashes[:c_post] = c }
+          end
+
+          it "should invoke post_inject_into block with an argument" do
+            subject.resolve(:for => %w{a})
+
+            @component_hashes.should have_key(:c_post)
+          end
+
+          it "should invoke post_inject_into block with sparse component hash" do
+            subject.resolve(:for => %w{a})
+
+            @component_hashes[:c_post].should have(3).items
+          end
+
+          it "should invoke post_inject_into block with component hash containing needed components" do
+            subject.resolve(:for => %w{a})
+
+            chash = @component_hashes[:c_post]
+            chash[:a][:item].should == :a
+            chash[:b][:item].should == :b
+            chash[:c][:item].should == :c
+          end
+
+          context "with detached node d" do
+            before(:each) do
+              subject.register(:d, :using => :a) do |c|
+                @component_hashes[:d_post] = c
+                { :item => :d }
+              end
+            end
+
+            it "should not invoke constructor block for d" do
+              subject.resolve(:for => :a)
+
+              @component_hashes.should_not have_key(:d_post)
+              @component_hashes[:b].c[:item].should == :c
+            end
+
+            it "should not keep d in component hash passed to c's post inject block" do
+              subject.resolve(:for => :a)
+
+              chash = @component_hashes[:c_post]
+              chash.should have(3).items
+              lambda { chash.d }.should raise_error(described_class::BadComponent)
+            end
+          end
+        end
+      end
+    end
+
+    describe "stubbing" do
+      before(:each) do
+        subject.register(:a)
+      end
+
+      it "should pass component hash to constructor blocks containing the right components" do
+        resolution = subject.resolve(:for => :a)
+        resolution[:a].class.should == Stub
+        lambda { resolution[:a].some_method }.should raise_error(described_class::StubUsedError)
+      end
+    end
+
+    describe "render_dependencies" do
+      context "with dependencies a -> b -> c, a -> d" do
+        before(:each) do
+          subject.register(:a, :using => %w{b d})
+          subject.register(:b, :using => :c)
+          subject.register(:c)
+          subject.register(:d)
+        end
+
+        let(:dependencies) { subject.render_dependencies(:format => :hash) }
+
+        it "gives me a nice hash with dependencies" do
+          keys = dependencies.keys
+          keys.sort_by(&:to_s).should == [:a, :b, :c, :d]
+
+          dependencies.each_value.sort_by(&:to_s)
+
+          dependencies[:a].should == [:b, :d]
+          dependencies[:b].should == [:c]
+          dependencies[:c].should be_empty
+          dependencies[:d].should be_empty
+        end
+      end
+    end
+
+    describe "marking for resolution" do
+      describe ".resolve_for" do
+        before(:each) do
+          subject.register(:a)
+          subject.register(:b)
+          subject.register(:c)
+        end
+
+        it "is chainable" do
+          subject.resolve_for.should be_equal(subject)
+        end
+
+        it "has the effekt that .resolve will deliver the argument(s). pt. 1" do
+          subject.resolve_for :a
+          subject.resolve.keys.should == [:a]
+        end
+
+        it "has the effekt that .resolve will deliver the argument(s). pt. 2" do
+          subject.resolve_for :a
+          subject.resolve(:for => :b).keys.sort_by(&:to_s).should == [:a, :b]
+        end
+
+        it "has the effekt that .resolve will deliver the argument(s). pt. 3" do
+          subject.resolve_for *%w{a b}
+          subject.resolve.keys.sort_by(&:to_s).should == [:a, :b]
+        end
+
+        it "has the effekt that .resolve will deliver the argument(s). pt. 4" do
+          subject.resolve_for %w{a b}
+          subject.resolve.keys.sort_by(&:to_s).should == [:a, :b]
+        end
+      end
+
+      describe ".register(:resolve => true)" do
+        before(:each) do
+          subject.register(:a)
+          subject.register(:b, :resolve => true)
+        end
+
+        it "has the effekt that .resolve will deliver the component" do
+          subject.resolve.keys.should == [:b]
+        end
+      end
+    end
+  end
+end

data/tame_the_beast.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tame_the_beast/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tame_the_beast"
+  s.version     = TameTheBeast::VERSION
+  s.authors     = ["Thomas Stratmann"]
+  s.email       = ["thomas.stratmann@9elements.com"]
+  s.homepage    = ""
+  s.summary     = %q{Systematic dependency injection: keep your singletons manageable}
+  s.description = s.summary
+
+  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"]
+
+  s.add_development_dependency "ruby-debug"
+  s.add_development_dependency "rspec", "2.8.0"
+  s.add_development_dependency "growl"
+  s.add_development_dependency "guard-rspec"
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: tame_the_beast
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Thomas Stratmann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-23 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 2
+        - 8
+        - 0
+        version: 2.8.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: growl
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: "Systematic dependency injection: keep your singletons manageable"
+email: 
+- thomas.stratmann@9elements.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Guardfile
+- LICENSE.md
+- Readme.md
+- lib/tame_the_beast.rb
+- lib/tame_the_beast/armory.rb
+- lib/tame_the_beast/container.rb
+- lib/tame_the_beast/reg_entry.rb
+- lib/tame_the_beast/stub.rb
+- lib/tame_the_beast/version.rb
+- spec/acceptance/tame_the_beast_spec.rb
+- tame_the_beast.gemspec
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: "Systematic dependency injection: keep your singletons manageable"
+test_files: 
+- spec/acceptance/tame_the_beast_spec.rb