rails-ioc 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+**/.DS_Store

data/Gemfile

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

data/README.markdown

@@ -0,0 +1,155 @@
+## Quickstart
+
+Gemfile:
+
+    ```ruby
+    gem 'rails-ioc'
+    ```
+
+config/dependencies/development.rb:
+
+    ```ruby
+    RailsIOC::Dependencies.define do     
+      prototype :ccv, CreditCardValidator, "Visa", "Mastercard"
+      prototype :payment_gateway, DummyPaymentGateway, ref(:ccv)
+
+      controller PaymentsController, {
+        payment_gateway: ref(:payment_gateway),
+      }
+    end   
+    ```
+    
+app/controllers/payments_controller.rb:
+
+  ```ruby
+  class PaymentsController < ApplicationController
+    def accept_payment
+      @payment_gateway.process(params[:credit_card])
+    end
+  end
+  ```
+
+## Background
+
+Inversion of control by dependency injection is widely used in large software systems and is generally accepted as being a "good idea". If the terms are unfamiliar, do some research before going any further. These are good places to start: 
+
+- http://en.wikipedia.org/wiki/Inversion_of_control
+- http://martinfowler.com/articles/injection.html
+
+The practice as described in the articles above is not particularly common in Ruby applications. Jamis Buck, author of the erstwhile DI framework [Copland](http://copland.rubyforge.org) makes a [compelling argument](http://weblog.jamisbuck.org/2008/11/9/legos-play-doh-and-programming) against it. If you have to ask the question "will I need IOC for my next Rails app", the answer is almost certainly "No". The core components of a standard Rails app usually interact politely  and can generally be tested reasonably easily in most apps.
+
+Still, having run into several Rails projects which dealt with dependencies beyond a simple ActiveRecord database connection (payment gateways, email services, version control systems, image processing services and more) I realised that I was reminiscing fondly about Java and .NET's various containers for two reasons:
+
+1. I really hate mocking calls to MyService#new to force a controller to use a stub implementation in a unit test.
+2. There is no clean way to switch dependencies out on a per-environment basis (to use the testable version of a payment gateway in the staging environment, for example).
+
+RailsIOC attempts to make these problems less painful for applications with complex interactions with external services by providing a very lightweight way to define dependencies and inject them into ActionController. The patterns will be familiar to anyone who has used [Spring](http://www.springsource.org/documentation) or [Unity](http://msdn.microsoft.com/en-us/library/dd203319.aspx). Where possible, RailsIOC enforces constructor injection. The exception to this rule is the creation of controllers, where it avoids interfering with Rails' own instantiation and injects dependencies as local @variables.
+
+## Cleaner Testing
+### Before
+    
+    ```ruby
+    #Controller
+    @gateway = Gateway.new(ServiceA.new, ServiceB.new)
+    @gateway.do_something!
+
+    #RSpec
+    @svc_a = mock(ServiceA)
+    @svc_b = mock(ServiceB)
+    ServiceA.stub(:new).and_return(@svc_a)
+    ServiceB.stub(:new).and_return(@svc_b)
+    @gateway = mock(Gateway)
+    @gateway.should_receive(:do_something!).and_return(12345)
+    Gateway.stub(:new).with(@svc_a, @svc_b).and_return(@gateway)
+    ```
+
+### After
+
+    ```ruby
+    #Controller
+    @gateway.do_something!
+
+    #RSpec
+    @gateway = mock(Gateway)
+    @gateway.should_receive(:do_something!).and_return(12345)
+    controller_dependencies(gateway: @gateway)
+    ```
+
+## Customise Dependencies Per-Environment
+### Before
+
+PaymentController:
+    
+    ```ruby
+    class PaymentsController < ApplicationController
+      def accept_payment
+        if Rails.env.development? || Rails.env.test?
+          @credit_card_validator = BogusCardValidator.new
+        else
+          @credit_card_validator = RealCardValidator.new
+        end
+        if Rails.env.production? 
+          @gateway = RealPaymentGateway.new
+        elsif Rails.env.staging? 
+          @gateway = RealPaymentGateway.new(:use_testing_url)
+        else
+          @gateway = BogusPaymentGateway.new
+        end
+        card = @credit_card_validator.validate(params[:card])
+        @gateway.process(card)
+      end
+    end
+    ```
+
+### After
+
+
+app/controllers/payments_controller:
+
+    ```ruby
+    class PaymentsController < ApplicationController
+      def accept_payment    
+        card = @credit_card_validator.validate(params[:card])
+        @gateway.process(card)
+      end
+    end
+    ```
+    
+config/dependencies/production.rb:
+
+    ```ruby
+    RailsIOC::Dependencies.define do
+      prototype :payment_gateway, RealPaymentGateway
+      prototype :credit_card_validator, RealCardValidator
+      
+      controller MyController, {
+        gateway: ref(:payment_gateway)
+        credit_card_validator: ref(:credit_card_validator)
+      }
+    end
+    ```
+        
+config/dependencies/staging.rb:
+
+    ```ruby
+    RailsIOC::Dependencies.define do
+      inherit_environment(:production)
+      
+      controller MyController, {
+        gateway: prototype(:payment_gateway, RealPaymentGateway, :use_test_url)
+      }
+    end
+    ```
+    
+config/dependencies/development.rb:
+
+    ```ruby
+    RailsIOC::Dependencies.define do
+      inherit_environment(:production)
+
+      controller MyController, {
+        gateway: singleton(BogusPaymentGateway),
+        credit_card_validator: singleton(BogusCardValidator)
+      }
+    end
+    ```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/lib/rails-ioc.rb

@@ -0,0 +1,15 @@
+require "rails-ioc/version"
+require "rails-ioc/errors"
+require "rails-ioc/dependencies"
+require "rails-ioc/dependency_constructor"
+require "rails-ioc/dependency_injector"
+      
+raise RailsIOC::NoRailsError.new(:Rails) unless defined?(Rails)
+raise RailsIOC::NoRailsError.new(:ActionController) unless defined?(ActionController)
+require "rails-ioc/controller_extension"
+ActionController::Base.send(:include, RailsIOC::ControllerExtension)
+
+if defined?(RSpec)
+  require "rails-ioc/rspec_extension"
+  Object.send(:include, RailsIOC::RSpecExtension)
+end

data/lib/rails-ioc/controller_extension.rb

@@ -0,0 +1,13 @@
+module RailsIOC
+  module ControllerExtension
+    def self.included(controller)
+      controller.before_filter :inject_dependencies
+    end
+    
+    def inject_dependencies
+      RailsIOC::Dependencies.load!
+      dependencies = RailsIOC::Dependencies.controllers[self.class] || {}      
+      RailsIOC::DependencyInjector.new(self).inject(dependencies)
+    end
+  end
+end

data/lib/rails-ioc/dependencies.rb

@@ -0,0 +1,66 @@
+module RailsIOC
+  class Dependencies    
+    def self.reset!
+      @dependencies = {}
+      @controllers = {}
+      @loaded = false      
+    end
+    self.reset!
+    
+    def self.load!
+      self.reset! unless Rails.application.config.cache_classes
+      if !@loaded
+        inherit_environment(Rails.env)
+        @loaded = true
+      end
+    end
+    
+    def self.define(&definition)
+      class_exec(&definition)
+    end
+  
+    def self.inherit_environment(env)
+      load File.join(Rails.root, "config", "dependencies", "#{env}.rb")
+    end
+  
+    def self.controller(klass, dependencies)
+      @controllers[klass] ||= {}
+      @controllers[klass].merge!(dependencies)
+    end
+  
+    def self.singleton(*args)
+      store_dependency(args) do |klass, constructor_args|
+        if klass.instance_of?(Class)
+          DependencyConstructor.new(klass, caller).construct(constructor_args)
+        else
+          klass
+        end
+      end
+    end
+  
+    def self.prototype(*args)
+      store_dependency(args) do |klass, constructor_args|
+        definition_backtrace = caller
+        -> { DependencyConstructor.new(klass, definition_backtrace).construct(constructor_args) }
+      end
+    end
+  
+    def self.ref(name)
+      @dependencies[name] || raise(MissingReferenceError.new(name))
+    end
+    
+    def self.controllers
+      @controllers
+    end
+  
+    private
+    
+    def self.store_dependency(args)
+      if args.first.is_a?(Symbol)
+        @dependencies[args.shift] = yield(args.shift, args)
+      else
+        yield(args.shift, args)
+      end
+    end
+  end
+end

data/lib/rails-ioc/dependency_constructor.rb

@@ -0,0 +1,17 @@
+module RailsIOC
+  class DependencyConstructor
+    def initialize(klass, definition_backtrace)
+      @klass = klass
+      @definition_backtrace = definition_backtrace
+    end
+    
+    def construct(dependencies)
+      begin
+        @klass.new(*dependencies.map { |x| x.is_a?(Proc) ? x.call : x })
+      rescue ArgumentError => e
+        e.set_backtrace(@definition_backtrace)
+        raise e
+      end
+    end
+  end
+end

data/lib/rails-ioc/dependency_injector.rb

@@ -0,0 +1,15 @@
+module RailsIOC
+  class DependencyInjector
+    def initialize(target)
+      @target = target
+    end
+    
+    def inject(dependencies)
+      dependencies.each do |field, value|
+        value = value.call if value.is_a?(Proc)
+        @target.instance_variable_set("@#{field}", value)
+      end
+      @target
+    end
+  end
+end

data/lib/rails-ioc/errors.rb

@@ -0,0 +1,14 @@
+module RailsIOC
+  class BaseError < StandardError; end
+  class NoRailsError < BaseError
+    def initialize(missing_class)
+      super("#{missing_class} is not defined. RailsIOC can only be used within a Rails application.")
+    end
+  end
+  
+  class MissingReferenceError < BaseError
+    def initialize(name)
+      super("No dependency defined with name :#{name}.")
+    end
+  end
+end

data/lib/rails-ioc/rspec_extension.rb

@@ -0,0 +1,16 @@
+module RailsIOC
+  module RSpecExtension
+    def self.included(klass)
+      RSpec.configure do |config|
+        config.before(:each) { RailsIOC::Dependencies.reset! }
+      end
+    end
+    
+    def controller_dependencies(dependencies)
+      klass = controller.class
+      Dependencies.define do
+        controller klass, dependencies
+      end
+    end
+  end
+end

data/lib/rails-ioc/version.rb

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

data/rails-ioc.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rails-ioc/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rails-ioc"
+  s.version     = RailsIOC::VERSION
+  s.authors     = ["Rick Grundy"]
+  s.email       = ["rick@rickgrundy.com"]
+  s.homepage    = "http://www.github.com/rickgrundy/rails-ioc"
+  s.summary     = "Simple dependency injection for Rails."
+  s.description = "Simple dependency injection for Rails."
+
+  s.rubyforge_project = "rails-ioc"
+
+  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 "rspec"
+  # specify any dependencies here; for example:
+  # s.add_runtime_dependency "rest-client"
+end

data/spec/fixtures/config/dependencies/incrementing_test.rb

@@ -0,0 +1,5 @@
+GlobalCounter.increment!
+
+RailsIOC::Dependencies.define do
+  singleton :counter, GlobalCounter.count
+end

data/spec/fixtures/config/dependencies/production.rb

@@ -0,0 +1,5 @@
+RailsIOC::Dependencies.define do
+  singleton :env_string, "Production"
+  singleton :foo_string, "Foo"
+  singleton :production_only_string, "This comes from production.rb"
+end

data/spec/fixtures/config/dependencies/test.rb

@@ -0,0 +1,5 @@
+RailsIOC::Dependencies.define do
+  singleton :env_string, "Test"
+  singleton :foo_string, "Foo"
+  singleton :test_only_string, "This comes from test.rb"
+end

data/spec/rails-ioc/controller_extension_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path("../../spec_helper.rb", __FILE__)
+
+describe RailsIOC::ControllerExtension do
+  class ExtendedController    
+    def self.before_filter(method_name)
+      @@before_filter_method = method_name
+    end
+    
+    def trigger_before_filter!
+      self.send(@@before_filter_method)
+    end
+    
+    include RailsIOC::ControllerExtension
+  end
+  
+  it "injects pre-defined dependencies" do        
+    Rails.application.config.cache_classes = true
+    RailsIOC::Dependencies.instance_variable_set :@loaded, true
+    
+    RailsIOC::Dependencies.define do
+      controller ExtendedController, {
+        a_number: 123,
+        a_string: "Hello" 
+      }
+    end
+    
+    controller = ExtendedController.new    
+    controller.trigger_before_filter!
+    controller.instance_variable_get(:@a_number).should == 123
+    controller.instance_variable_get(:@a_string).should == "Hello"
+  end
+end

data/spec/rails-ioc/dependencies_spec.rb

@@ -0,0 +1,163 @@
+require File.expand_path("../../spec_helper.rb", __FILE__)
+
+describe RailsIOC::Dependencies do
+  class TestListNode
+    attr_reader :next_node
+    def initialize(next_node=nil)
+      @next_node = next_node
+    end
+  end
+  
+  class TestController
+    attr_reader :foo, :bar
+  end
+  
+  describe "singletons" do
+    it "creates and references singletons from a class and constructor args" do
+      RailsIOC::Dependencies.define do
+        singleton :second_node, TestListNode
+        singleton :first_node, TestListNode, ref(:second_node)
+      end
+    
+      first_node = RailsIOC::Dependencies.ref(:first_node)
+      first_node.should be_a TestListNode
+      first_node.should === RailsIOC::Dependencies.ref(:first_node)
+      first_node.next_node.should === RailsIOC::Dependencies.ref(:second_node)
+    end
+    
+    it "creates unreferenced singletons from a class and constructor args" do
+      RailsIOC::Dependencies.define do
+        singleton :first_node, TestListNode, singleton(TestListNode)
+      end
+
+      first_node = RailsIOC::Dependencies.ref(:first_node)
+      first_node.should be_a(TestListNode)
+      first_node.next_node.should be_a TestListNode
+    end
+    
+    it "does not require a class for simple types" do
+      RailsIOC::Dependencies.define do
+        singleton :a_number, 12345
+      end
+      
+      RailsIOC::Dependencies.ref(:a_number).should == 12345
+    end
+    
+    it "raises an error containing information about original definition if the wrong number of constructor args are defined" do
+      defining_line = __LINE__ + 3
+      -> {
+        RailsIOC::Dependencies.define do
+          singleton :a_string, String, "Too", "many", "args"
+        end
+      }.should raise_error(ArgumentError) { |e|
+        e.backtrace.find { |l| l =~ /dependencies_spec.rb:#{defining_line}/ }.should_not be_nil
+      }
+    end
+  end
+  
+  describe "prototypes" do
+    it "creates and references prototypes from a class and constructor args" do
+      RailsIOC::Dependencies.define do
+        prototype :second_node, TestListNode
+        prototype :first_node, TestListNode, ref(:second_node)
+      end
+    
+      ref = RailsIOC::Dependencies.ref(:first_node)
+      ref.should be_a Proc
+      first_node = ref.call
+      first_node.should be_a TestListNode
+      first_node.should_not === ref.call 
+      
+      first_node.next_node.should be_a TestListNode
+      first_node.next_node.should_not === RailsIOC::Dependencies.ref(:second_node).call
+    end
+    
+    it "creates unreferenced prototypes from a class and constructor args" do
+      RailsIOC::Dependencies.define do
+        prototype :first_node, TestListNode, prototype(TestListNode)
+      end
+
+      ref = RailsIOC::Dependencies.ref(:first_node)
+      ref.should be_a Proc
+      first_node = ref.call
+      first_node.should be_a(TestListNode)
+      first_node.next_node.should be_a TestListNode
+    end
+    
+    it "raises an error containing information about original definition if the wrong number of constructor args are defined" do
+      defining_line = __LINE__ + 2
+      RailsIOC::Dependencies.define do
+        prototype :a_string, String, "Too", "many", "args"
+      end
+            
+      -> { RailsIOC::Dependencies.ref(:a_string).call }.should raise_error(ArgumentError) { |e|
+        e.backtrace.find { |l| l =~ /dependencies_spec.rb:#{defining_line}/ }.should_not be_nil
+      }
+    end
+  end
+  
+  describe "controllers" do
+    it "stores controller dependencies for later injection by Rails' before_filter" do      
+      RailsIOC::Dependencies.define do
+        prototype :second_node, TestListNode
+        singleton :first_node, TestListNode, ref(:second_node)
+        
+        controller TestController, {
+           foo: ref(:first_node),
+           bar: singleton("The Sheep Says Bar")
+        }
+      end
+      
+      controller = TestController.new
+      dependencies = RailsIOC::Dependencies.controllers[TestController]
+      RailsIOC::DependencyInjector.new(controller).inject(dependencies)
+      
+      controller.foo.should === RailsIOC::Dependencies.ref(:first_node)
+      controller.bar.should == "The Sheep Says Bar"
+    end
+  end
+  
+  describe "loading dependencies file" do
+    before(:each) do
+      GlobalCounter.zero!
+    end
+    
+    it "reloads the file if cache_classes is false" do
+      Rails.env = "incrementing_test"
+      Rails.application.config.cache_classes = false
+      
+      RailsIOC::Dependencies.load!
+      RailsIOC::Dependencies.ref(:counter).should == 1
+      
+      RailsIOC::Dependencies.load!
+      RailsIOC::Dependencies.ref(:counter).should == 2
+    end
+    
+    it "does not reload the file if cache_classes is true" do
+      Rails.env = "incrementing_test"
+      Rails.application.config.cache_classes = true
+
+      RailsIOC::Dependencies.load!
+      RailsIOC::Dependencies.ref(:counter).should == 1
+      
+      RailsIOC::Dependencies.load!
+      RailsIOC::Dependencies.ref(:counter).should == 1
+    end
+  end
+  
+  describe "inheriting environments" do
+    it "loads the corresponding dependencies file" do
+      RailsIOC::Dependencies.inherit_environment("production")
+      RailsIOC::Dependencies.ref(:env_string).should == "Production"
+      RailsIOC::Dependencies.ref(:foo_string).should == "Foo"
+      RailsIOC::Dependencies.ref(:production_only_string).should == "This comes from production.rb"
+      -> { RailsIOC::Dependencies.ref(:test_only_string) }.should raise_error RailsIOC::MissingReferenceError
+      
+      RailsIOC::Dependencies.inherit_environment("test")
+      RailsIOC::Dependencies.ref(:env_string).should == "Test"
+      RailsIOC::Dependencies.ref(:foo_string).should == "Foo"
+      RailsIOC::Dependencies.ref(:production_only_string).should == "This comes from production.rb"
+      RailsIOC::Dependencies.ref(:test_only_string).should == "This comes from test.rb"
+    end
+  end
+end

data/spec/rails-ioc/dependency_constructor_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path("../../spec_helper.rb", __FILE__)
+
+describe RailsIOC::DependencyConstructor do
+  class ConstructorTestClass
+    attr_reader :foo, :bar
+    def initialize(foo, bar)
+      @foo, @bar = foo, bar
+    end
+  end
+  
+  it "constructs the given class" do
+    instance = RailsIOC::DependencyConstructor.new(ConstructorTestClass, []).construct([123, :abc])
+    instance.foo.should == 123
+    instance.bar.should == :abc
+  end
+  
+  it "calls any procs which are provided in constructor args" do
+    returns_7 = -> { 3 + 4 }
+    instance = RailsIOC::DependencyConstructor.new(ConstructorTestClass, []).construct([returns_7, :abc])
+    instance.foo.should == 7
+    instance.bar.should == :abc
+  end
+  
+  it "sets the provided backtrace in the event of an ArgumentError" do
+    constructor = RailsIOC::DependencyConstructor.new(ConstructorTestClass, ["my_backtrace"])
+
+    -> { constructor.construct([]) }.should raise_error(ArgumentError) do |e|
+      e.backtrace.should == ["my_backtrace"]
+    end
+    
+    -> { constructor.construct(nil) }.should raise_error do |e|
+      e.backtrace.should_not == ["my_backtrace"]
+    end
+  end
+end

data/spec/rails-ioc/dependency_injector_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path("../../spec_helper.rb", __FILE__)
+
+describe RailsIOC::DependencyInjector do
+  class InjectorTestClass
+    attr_reader :foo, :bar
+  end
+  
+  it "injects named variables for the given class" do
+    instance = RailsIOC::DependencyInjector.new(InjectorTestClass.new).inject(foo: 123, bar: :abc)
+    instance.foo.should == 123
+    instance.bar.should == :abc
+  end
+  
+  it "calls any procs which are provided in constructor args" do
+    returns_7 = -> { 3 + 4 }
+    instance = RailsIOC::DependencyInjector.new(InjectorTestClass.new).inject(foo: returns_7, bar: :abc)
+    instance.foo.should == 7
+    instance.bar.should == :abc
+  end
+end

data/spec/rails-ioc/rspec_extension_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path("../../spec_helper.rb", __FILE__)
+
+describe RailsIOC::RSpecExtension do
+  class MyController; end
+  def controller; MyController.new; end
+  
+  describe "resetting dependencies between tests" do
+    after(:each) do
+      RailsIOC::Dependencies.define { singleton :defined?, true }
+    end
+    
+    it "resets before this test" do
+      -> { RailsIOC::Dependencies.ref(:defined?) }.should raise_error RailsIOC::MissingReferenceError
+    end
+    
+    it "also resets before this test" do
+      -> { RailsIOC::Dependencies.ref(:defined?) }.should raise_error RailsIOC::MissingReferenceError
+    end
+  end
+  
+  it "provides a shorthand way to define controller dependencies" do
+    controller_dependencies(who_am_i: "The Walrus")
+    RailsIOC::Dependencies.controllers[MyController][:who_am_i].should == "The Walrus"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,62 @@
+def ignoring_warnings
+  verbosity = $VERBOSE
+  $VERBOSE = nil
+  yield
+ensure
+  $VERBOSE = verbosity
+end
+
+class GlobalCounter
+  def self.zero!
+    @count = 0
+  end
+  
+  def self.increment!
+    @count += 1
+  end
+  
+  def self.count
+    @count
+  end
+end
+
+class AdHocObject  
+  def initialize
+    @store = {}
+  end
+  
+  def method_missing(name, *args)
+    if name =~ /=$/
+      @store[name.to_s.sub(/=|\s/, "").to_sym] = args.first
+    else
+      @store[name]
+    end
+  end
+end
+
+module FakeActionController
+  class Base
+    def self.before_filter(method_name); end 
+  end
+end
+
+def reset_fake_dependencies!
+  ignoring_warnings do
+    Object.send(:const_set, :Rails, AdHocObject.new)
+    Rails.application = AdHocObject.new
+    Rails.application.config = AdHocObject.new
+    Rails.root = File.expand_path("../fixtures", __FILE__)
+
+    Object.send(:const_set, :ActionController, FakeActionController)
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:each) do
+    GlobalCounter.zero!
+    reset_fake_dependencies!
+  end
+end
+
+reset_fake_dependencies!
+require File.expand_path("../../lib/rails-ioc.rb", __FILE__)

data/spec/spec_helper_spec_spec_spec_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path("../spec_helper.rb", __FILE__)
+
+describe "Spec Helper" do
+  it "provides a global counter" do
+    3.times { GlobalCounter.increment! }
+    GlobalCounter.count.should == 3
+    GlobalCounter.zero!
+    GlobalCounter.count.should == 0
+  end
+  
+  describe "zeroing the global counter between tests" do
+    after(:each) { GlobalCounter.increment! }
+    
+    it "zeroes before this test" do
+      GlobalCounter.count.should == 0
+    end
+    
+    it "also zeroes before this test" do
+      GlobalCounter.count.should == 0
+    end
+  end
+  
+  it "simulates Rails.application.config to allow testing outside a Rails app" do
+    Rails.application.config.kittens = "Small Cats"
+    Rails.application.config.kittens.should == "Small Cats"
+  end
+  
+  describe "resetting fake Rails environment between tests" do
+    after(:each) do
+      ignoring_warnings do
+        Rails = nil
+        ActionController = nil
+      end
+    end
+    
+    it "resets Rails before this test" do
+      ActionController.should_not be_nil
+      Rails.application.should_not be_nil
+    end    
+    
+    it "resets Rails before this test too" do
+      ActionController.should_not be_nil
+      Rails.application.should_not be_nil
+    end
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: rails-ioc
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Rick Grundy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-29 00:00:00 +10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Simple dependency injection for Rails.
+email: 
+- rick@rickgrundy.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- lib/rails-ioc.rb
+- lib/rails-ioc/controller_extension.rb
+- lib/rails-ioc/dependencies.rb
+- lib/rails-ioc/dependency_constructor.rb
+- lib/rails-ioc/dependency_injector.rb
+- lib/rails-ioc/errors.rb
+- lib/rails-ioc/rspec_extension.rb
+- lib/rails-ioc/version.rb
+- rails-ioc.gemspec
+- spec/fixtures/config/dependencies/incrementing_test.rb
+- spec/fixtures/config/dependencies/production.rb
+- spec/fixtures/config/dependencies/test.rb
+- spec/rails-ioc/controller_extension_spec.rb
+- spec/rails-ioc/dependencies_spec.rb
+- spec/rails-ioc/dependency_constructor_spec.rb
+- spec/rails-ioc/dependency_injector_spec.rb
+- spec/rails-ioc/rspec_extension_spec.rb
+- spec/spec_helper.rb
+- spec/spec_helper_spec_spec_spec_spec.rb
+has_rdoc: true
+homepage: http://www.github.com/rickgrundy/rails-ioc
+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"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: rails-ioc
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Simple dependency injection for Rails.
+test_files: 
+- spec/fixtures/config/dependencies/incrementing_test.rb
+- spec/fixtures/config/dependencies/production.rb
+- spec/fixtures/config/dependencies/test.rb
+- spec/rails-ioc/controller_extension_spec.rb
+- spec/rails-ioc/dependencies_spec.rb
+- spec/rails-ioc/dependency_constructor_spec.rb
+- spec/rails-ioc/dependency_injector_spec.rb
+- spec/rails-ioc/rspec_extension_spec.rb
+- spec/spec_helper.rb
+- spec/spec_helper_spec_spec_spec_spec.rb