Adding rspec_on_rails plugin

31 files changed, 1751 insertions, 0 deletions

diff --git a/vendor/plugins/rspec_on_rails/lib/autotest/rails_rspec.rb b/vendor/plugins/rspec_on_rails/lib/autotest/rails_rspec.rb
new file mode 100644
index 000000000..994b9f68e
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/autotest/rails_rspec.rb
@@ -0,0 +1,81 @@
+# (c) Copyright 2006 Nick Sieger <nicksieger@gmail.com>
+#
+# 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.
+
+$:.push(*Dir["vendor/rails/*/lib"])
+
+require 'active_support'
+require 'autotest/rspec'
+
+class Autotest::RailsRspec < Autotest::Rspec
+
+  def initialize # :nodoc:
+    super
+    @exceptions = %r%^\./(?:coverage|db|doc|log|public|script|vendor\/rails|previous_failures.txt)%
+    @test_mappings = {
+      %r%^(test|spec)/fixtures/(.*).yml$% => proc { |_, m|
+        ["spec/models/#{m[2].singularize}_spec.rb"] + files_matching(%r%^spec\/views\/#{m[2]}/.*_spec\.rb$%)
+      },
+      %r%^spec/(models|controllers|views|helpers|lib)/.*rb$% => proc { |filename, _|
+        filename
+      },
+      %r%^app/models/(.*)\.rb$% => proc { |_, m|
+        ["spec/models/#{m[1]}_spec.rb"]
+      },
+      %r%^app/views/(.*)$% => proc { |_, m|
+        files_matching %r%^spec/views/#{m[1]}_spec.rb$%
+      },
+      %r%^app/controllers/(.*)\.rb$% => proc { |_, m|
+        ["spec/controllers/#{m[1]}_spec.rb"]
+      },
+      %r%^app/helpers/(.*)_helper\.rb$% => proc { |_, m|
+        if m[1] == "application" then
+          files_matching(%r%^spec/(views|helpers)/.*_spec\.rb$%)
+        else
+          ["spec/helpers/#{m[1]}_helper_spec.rb"] + files_matching(%r%^spec\/views\/#{m[1]}/.*_spec\.rb$%)
+        end
+      },
+      %r%^app/helpers/application_helper\.rb$% => proc {
+        files_matching %r%^spec/(views|helpers)/.*_spec\.rb$%
+      },
+      %r%^app/controllers/application\.rb$% => proc { |_, m|
+        files_matching %r%^spec/controllers/.*_spec\.rb$%
+      },
+      %r%^config/routes\.rb$% => proc {
+        files_matching %r%^spec/(controllers|views|helpers)/.*_spec\.rb$%
+      },
+      %r%^config/database\.yml$% => proc { |_, m|
+        files_matching %r%^spec/models/.*_spec\.rb$%
+      },
+      %r%^(spec/(spec_helper|shared/.*)|config/(boot|environment(s/test)?))\.rb$% => proc {
+        files_matching %r%^spec/(models|controllers|views|helpers)/.*_spec\.rb$%
+      },
+      %r%^lib/(.*)\.rb$% => proc { |_, m|
+        ["spec/lib/#{m[1]}_spec.rb"]
+      },
+    }    
+  end
+  
+  def spec_command
+    "script/spec"
+  end
+    
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/dsl.rb b/vendor/plugins/rspec_on_rails/lib/spec/dsl.rb
new file mode 100755
index 000000000..272032210
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/dsl.rb
@@ -0,0 +1,2 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/dsl/configuration")
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/dsl/configuration.rb b/vendor/plugins/rspec_on_rails/lib/spec/dsl/configuration.rb
new file mode 100755
index 000000000..5605dc913
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/dsl/configuration.rb
@@ -0,0 +1,23 @@
+module Spec
+  module DSL
+    class Configuration
+      attr_writer :use_transactional_fixtures, :use_instantiated_fixtures, :fixture_path, :global_fixtures
+      
+      def use_transactional_fixtures
+        @use_transactional_fixtures.nil? ? @use_transactional_fixtures = true : @use_transactional_fixtures
+      end
+      
+      def use_instantiated_fixtures
+        @use_instantiated_fixtures ||= false
+      end
+      
+      def fixture_path
+        @fixture_path ||= RAILS_ROOT + '/spec/fixtures'
+      end
+      
+      def global_fixtures
+        @global_fixtures ||= []
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/matchers.rb b/vendor/plugins/rspec_on_rails/lib/spec/matchers.rb
new file mode 100755
index 000000000..7268a03ce
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/matchers.rb
@@ -0,0 +1,3 @@
+dir = File.dirname(__FILE__)
+
+require File.expand_path("#{dir}/matchers/have")
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/matchers/have.rb b/vendor/plugins/rspec_on_rails/lib/spec/matchers/have.rb
new file mode 100644
index 000000000..4abeb2faf
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/matchers/have.rb
@@ -0,0 +1,19 @@
+module Spec #:nodoc:
+  module Matchers #:nodoc:
+    class Have #:nodoc:
+      alias_method :__original_failure_message, :failure_message
+      def failure_message
+        return "expected #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}, got #{@actual}" if @collection_name == :errors_on
+        return "expected #{relativities[@relativity]}#{@expected} error on :#{@args[0]}, got #{@actual}" if @collection_name == :error_on
+        return __original_failure_message
+      end
+      
+      alias_method :__original_description, :description
+      def description
+        return "should have #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}" if @collection_name == :errors_on
+        return "should have #{relativities[@relativity]}#{@expected} error on :#{@args[0]}" if @collection_name == :error_on
+        return __original_description
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails.rb
new file mode 100644
index 000000000..b9b87043b
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails.rb
@@ -0,0 +1,57 @@
+dir = File.dirname(__FILE__)
+require 'application'
+
+silence_warnings { RAILS_ENV = "test" }
+require 'action_controller/test_process'
+require 'action_controller/integration'
+require 'active_record/base'
+require 'active_record/fixtures'
+require 'spec'
+
+require File.expand_path("#{dir}/rails/dsl")
+
+require File.expand_path("#{dir}/dsl")
+require File.expand_path("#{dir}/matchers")
+
+require File.expand_path("#{dir}/rails/version")
+require File.expand_path("#{dir}/rails/extensions")
+require File.expand_path("#{dir}/rails/matchers")
+
+Test::Unit.run = true
+
+module Spec
+  # = Spec::Rails
+  #
+  # Spec::Rails (a.k.a. RSpec on Rails) is a Ruby on Rails plugin that allows you to drive the development
+  # of your RoR application using RSpec, a framework that aims to enable Behaviour Driven Development
+  # in Ruby.
+  # 
+  # == Features
+  # 
+  # * Use RSpec to independently specify Rails Models, Views, Controllers and Helpers
+  # * Integrated fixture loading
+  # * Special generators for Resources, Models, Views and Controllers that generate Specs instead of Tests.
+  # 
+  # == Vision
+  # 
+  # For people for whom TDD is a brand new concept, the testing support built into Ruby on Rails
+  # is a huge leap forward. The fact that it is built right in is fantastic, and Ruby on Rails
+  # apps are generally much easier to maintain than they might have been without such support.
+  # 
+  # For those of us coming from a history with TDD, and now BDD, the existing support presents some problems related to dependencies across specs. To that end, RSpec on Rails supports 4 types of specs. We’ve also built in first class mocking and stubbing support in order to break dependencies across these different concerns.
+  # 
+  # == More Information
+  #
+  # See Spec::Rails::Runner for information about the different kinds of contexts
+  # you can use to spec the different Rails components
+  # 
+  # See Spec::Rails::Expectations for information about Rails-specific expectations
+  # you can set on responses and models, etc.
+  #
+  # == License
+  # 
+  # RSpec on Rails is licensed under the same license as RSpec itself,
+  # the MIT-LICENSE.
+  module Rails
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl.rb
new file mode 100644
index 000000000..23df14d68
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl.rb
@@ -0,0 +1,40 @@
+dir = File.dirname(__FILE__)
+
+require File.expand_path("#{dir}/dsl/ivar_proxy")
+require File.expand_path("#{dir}/dsl/assigns_hash_proxy")
+require File.expand_path("#{dir}/dsl/behaviour")
+
+module Spec
+  module Rails
+    # Spec::Rails::DSL extends Spec::DSL (RSpec's core DSL module) to provide
+    # Rails-specific contexts for describing Rails Models, Views, Controllers and Helpers.
+    #
+    # == Model Examples
+    #
+    # These are the equivalent of unit tests in Rails' built in testing. Ironically (for the traditional TDD'er) these are the only specs that we feel should actually interact with the database.
+    #
+    # See Spec::Rails::DSL::ModelBehaviour
+    #
+    # == Controller Examples
+    #
+    # These align somewhat with functional tests in rails, except that they do not actually render views (though you can force rendering of views if you prefer). Instead of setting expectations about what goes on a page, you set expectations about what templates get rendered.
+    #
+    # See Spec::Rails::DSL::ControllerBehaviour
+    #
+    # == View Examples
+    #
+    # This is the other half of Rails functional testing. View specs allow you to set up assigns and render
+    # a template. By assigning mock model data, you can specify view behaviour with no dependency on a database
+    # or your real models.
+    #
+    # See Spec::Rails::DSL::ViewBehaviour
+    #
+    # == Helper Examples
+    #
+    # These let you specify directly methods that live in your helpers.
+    #
+    # See Spec::Rails::DSL::HelperBehaviour
+    module DSL
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/assigns_hash_proxy.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/assigns_hash_proxy.rb
new file mode 100644
index 000000000..8e71c9b1e
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/assigns_hash_proxy.rb
@@ -0,0 +1,42 @@
+module Spec
+  module Rails
+    module DSL
+      class AssignsHashProxy #:nodoc:
+        def initialize(object)
+          @object = object
+        end
+
+        def [](ivar)
+          if assigns.include?(ivar.to_s)
+            assigns[ivar.to_s]
+          elsif assigns.include?(ivar)
+            assigns[ivar]
+          else
+            nil
+          end
+        end
+
+        def []=(ivar, val)
+          assigns[ivar.to_s] = val
+        end
+
+        def delete(name)
+          assigns.delete(name.to_s)
+        end
+
+        def each(&block)
+          assigns.each &block
+        end
+
+        def has_key?(key)
+          assigns.key?(key.to_s)
+        end
+
+        protected
+        def assigns
+          @object.assigns
+        end
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour.rb
new file mode 100644
index 000000000..0c45ad22c
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour.rb
@@ -0,0 +1,9 @@
+dir = File.dirname(__FILE__)
+
+require File.expand_path("#{dir}/behaviour/render_observer")
+require File.expand_path("#{dir}/behaviour/base")
+require File.expand_path("#{dir}/behaviour/functional")
+require File.expand_path("#{dir}/behaviour/model")
+require File.expand_path("#{dir}/behaviour/controller")
+require File.expand_path("#{dir}/behaviour/helper")
+require File.expand_path("#{dir}/behaviour/view")
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/base.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/base.rb
new file mode 100644
index 000000000..f40d191a0
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/base.rb
@@ -0,0 +1,88 @@
+module Spec
+  module Rails
+    class TestCase < Test::Unit::TestCase
+      cattr_accessor :fixture_path, :use_transactional_fixtures, :use_instantiated_fixtures, :global_fixtures
+      remove_method :default_test if respond_to?(:default_test)
+
+      def add_assertion #:nodoc:
+        # no-op
+      end
+    end
+  end
+end
+
+module Spec
+  module Rails
+    module DSL
+      module AllBehaviourHelpers
+        ActionView::Base.cache_template_extensions = false
+        class << self
+          def included(mod)
+            mod.send :include, ExampleMethods
+            mod.send :extend, BehaviourMethods
+          end
+        end
+        
+        module BehaviourMethods
+          def configure
+            self.use_transactional_fixtures = Spec::Runner.configuration.use_transactional_fixtures
+            self.use_instantiated_fixtures = Spec::Runner.configuration.use_instantiated_fixtures
+            self.fixture_path = Spec::Runner.configuration.fixture_path
+            self.global_fixtures = Spec::Runner.configuration.global_fixtures
+            fixtures global_fixtures if global_fixtures
+          end
+        end
+        
+        module ExampleMethods
+          @@model_id = 1000
+          # Creates a mock object instance for a +model_class+ with common
+          # methods stubbed out.
+          # Additional methods may be easily stubbed (via add_stubs) if +stubs+ is passed.
+          def mock_model(model_class, stubs = {})
+            id = @@model_id
+            @@model_id += 1
+            m = mock("#{model_class.name}_#{id}")
+            m.stub!(:id).and_return(id)
+            m.stub!(:to_param).and_return(id.to_s)
+            m.stub!(:new_record?).and_return(false)
+            m.stub!(:errors).and_return(stub("errors", :count => 0))
+            m.send(:__mock_proxy).instance_eval <<-CODE
+              def @target.is_a?(other)
+                #{model_class}.ancestors.include?(other)
+              end
+              def @target.kind_of?(other)
+                #{model_class}.ancestors.include?(other)
+              end
+              def @target.instance_of?(other)
+                other == #{model_class}
+              end
+              def @target.class
+                #{model_class}
+              end
+            CODE
+            add_stubs(m, stubs)
+            yield m if block_given?
+            m
+          end
+
+          #--
+          # TODO - Shouldn't this just be an extension of stub! ??
+          # - object.stub!(:method => return_value, :method2 => return_value2, :etc => etc)
+          #++
+          # Stubs methods on +object+ (if +object+ is a symbol or string a new mock 
+          # with that name will be created). +stubs+ is a Hash of <tt>method=>value</tt>
+          def add_stubs(object, stubs = {}) #:nodoc:
+            m = [String, Symbol].index(object.class) ? mock(object.to_s) : object
+            stubs.each {|k,v| m.stub!(k).and_return(v)}
+            m
+          end
+        end
+      end
+
+      class EvalContext < Spec::Rails::TestCase
+        include Spec::Rails::Matchers
+        include Spec::Rails::DSL::AllBehaviourHelpers
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/controller.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/controller.rb
new file mode 100644
index 000000000..54d08f8aa
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/controller.rb
@@ -0,0 +1,269 @@
+module Spec
+  module Rails
+    module DSL
+      module ControllerBehaviourHelpers
+        class << self
+          def included(mod)
+            mod.send :include, ExampleMethods
+            mod.send :extend,  BehaviourMethods
+          end
+        end
+        
+        module BehaviourMethods
+          attr_accessor :controller_class_name # :nodoc:
+          
+          # Use this to instruct RSpec to render views in your controller examples (Integration Mode).
+          # 
+          #   describe ThingController do
+          #     integrate_views
+          #     ...
+          #
+          # See Spec::Rails::DSL::ControllerBehaviour for more information about
+          # Integration and Isolation modes.
+          def integrate_views
+            @integrate_views = true
+          end
+          def integrate_views? # :nodoc:
+            @integrate_views
+          end
+        end
+        
+        module ExampleMethods
+          # Uses ActionController::Routing::Routes to generate
+          # the correct route for a given set of options.
+          # == Examples
+          #   route_for(:controller => 'registrations', :action => 'edit', :id => 1)
+          #     => '/registrations/1;edit'
+          def route_for(options)
+            ensure_that_routes_are_loaded
+            ActionController::Routing::Routes.generate(options)
+          end
+        end
+      end
+
+      module ControllerInstanceMethods #:nodoc:
+        include Spec::Rails::DSL::RenderObserver
+
+        # === render(options = nil, deprecated_status = nil, &block)
+        #
+        # This gets added to the controller's singleton meta class,
+        # allowing Controller Examples to run in two modes, freely switching
+        # from context to context.
+        def render(options=nil, deprecated_status=nil, &block)
+          unless block_given?
+            unless integrate_views?
+              @template.metaclass.class_eval do
+                define_method :file_exists? do true end
+                define_method :render_file do |*args|
+                  @first_render ||= args[0]
+                end
+              end
+            end
+          end
+          
+          if (Hash === options)
+            expect_render_mock_proxy.render(options)
+          end
+          if expect_render_mock_proxy.send(:__mock_proxy).send(:find_matching_expectation, :render, options)
+            @performed_render = true
+          else
+            super(options, deprecated_status, &block)
+          end
+        end
+        
+        if self.respond_to?(:should_receive) && self.respond_to?(:stub!)
+          self.send :alias_method, :orig_should_receive, :should_receive
+          self.send :alias_method, :orig_stub!, :stub!
+          def raise_with_disable_message(old_method, new_method)
+            raise %Q|
+  controller.#{old_method}(:render) has been disabled because it
+  can often produce unexpected results. Instead, you should
+  use the following (before the action):
+
+    controller.#{new_method}(*args)
+
+  See the rdoc for #{new_method} for more information.
+            |
+          end
+          def should_receive(*args)
+            if args[0] == :render
+              raise_with_disable_message("should_receive", "expect_render")
+            else
+              orig_should_receive(*args)
+            end
+          end
+          def stub!(*args)
+            if args[0] == :render
+              raise_with_disable_message("stub!", "stub_render")
+            else
+              orig_stub!(*args)
+            end
+          end
+        end
+
+        def response(&block)
+          # NOTE - we're setting @update for the assert_select_spec - kinda weird, huh?
+          @update = block
+          @_response || @response
+        end
+      
+        def integrate_views!
+          @integrate_views = true
+        end
+
+      private
+
+        def integrate_views?
+          @integrate_views
+        end
+      end
+    
+      # The methods provided by Spec::Rails::DSL::ControllerEvalContext
+      # are available to you in Controller Examples.
+      #
+      # The Public Class Methods are to be used within the +context+ block:
+      #
+      #   describe ThingController do
+      #     # public class methods go here
+      #
+      # The Public Instance Methods are to be used within the +specify+ block:
+      #
+      #   describe ThingController do
+      #     it "should do stuff" do
+      #       # public instance methods go here
+      #
+      # See Spec::Rails::DSL::ControllerBehaviour for more general information
+      # on Controller Examples
+      class ControllerEvalContext < Spec::Rails::DSL::FunctionalEvalContext
+        include Spec::Rails::DSL::ControllerBehaviourHelpers
+        attr_reader :response, :request, :controller
+      
+        def setup #:nodoc:
+          super
+          
+          # Some Rails apps explicitly disable ActionMailer in environment.rb
+          if defined?(ActionMailer)
+            @deliveries = []
+            ActionMailer::Base.deliveries = @deliveries
+          end
+
+          unless @controller.class.ancestors.include?(ActionController::Base)
+            Spec::Expectations.fail_with <<-EOE
+  You have to declare the controller name in controller specs. For example:
+    describe "The ExampleController" do
+      controller_name "example" #invokes the ExampleController
+    end
+  EOE
+          end
+          @controller.metaclass.class_eval do
+            def controller_path #:nodoc:
+              self.class.name.underscore.gsub('_controller','')
+            end
+            include ControllerInstanceMethods
+          end
+          @controller.integrate_views! if @integrate_views
+          @controller.session = session
+        end
+
+        protected
+          def _controller_ivar_proxy
+            @controller_ivar_proxy ||= AssignsHashProxy.new @controller
+          end
+      
+        private
+          def ensure_that_routes_are_loaded
+            ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+          end
+      end
+
+      # Controller Examples live in $RAILS_ROOT/spec/controllers/.
+      #
+      # Controller Examples use Spec::Rails::DSL::ControllerBehaviour, which supports running specs for
+      # Controllers in two modes, which represent the tension between the more granular
+      # testing common in TDD and the more high level testing built into
+      # rails. BDD sits somewhere in between: we want to a balance between
+      # specs that are close enough to the code to enable quick fault
+      # isolation and far enough away from the code to enable refactoring
+      # with minimal changes to the existing specs.
+      #
+      # == Isolation mode (default)
+      #
+      # No dependencies on views because none are ever rendered. The
+      # benefit of this mode is that can spec the controller completely
+      # independent of the view, allowing that responsibility to be
+      # handled later, or by somebody else. Combined w/ separate view
+      # specs, this also provides better fault isolation.
+      #
+      # == Integration mode
+      #
+      # To run in this mode, include the +integrate_views+ declaration
+      # in your controller context:
+      # 
+      #   describe ThingController do
+      #     integrate_views
+      #     ...
+      # 
+      # In this mode, controller specs are run in the same way that
+      # rails functional tests run - one set of tests for both the
+      # controllers and the views. The benefit of this approach is that
+      # you get wider coverage from each spec. Experienced rails
+      # developers may find this an easier approach to begin with, however
+      # we encourage you to explore using the isolation mode and revel
+      # in its benefits.
+      #
+      # == Expecting Errors
+      #
+      # Rspec on Rails will raise errors that occur in controller actions.
+      # In contrast, Rails will swallow errors that are raised in controller
+      # actions and return an error code in the header. If you wish to override
+      # Rspec and have Rail's default behaviour,tell the controller to use
+      # rails error handling ...
+      #
+      #   before(:each) do
+      #     controller.use_rails_error_handling!
+      #   end
+      #
+      # When using Rail's error handling, you can expect error codes in headers ...
+      #
+      #   it "should return an error in the header" do
+      #     response.should be_error
+      #   end
+      #
+      #   it "should return a 501" do
+      #     response.response_code.should == 501
+      #   end
+      #
+      #   it "should return a 501" do
+      #     response.code.should == "501"
+      #   end
+      #
+      # See Spec::Rails::DSL::ControllerEvalContext for information
+      # about methods you can use in your Controller Examples
+      class ControllerBehaviour < Spec::DSL::Behaviour
+        def execution_context(example=nil) # :nodoc:
+          instance = execution_context_class.new(example)
+          if controller_class_name.nil? && !described_type.nil?
+            controller_klass_name = described_type.to_s
+          else
+            controller_klass_name = controller_class_name.to_s
+          end
+          integrate_views = integrate_views?
+          instance.instance_eval {
+            @controller_class_name = controller_klass_name
+            @integrate_views = integrate_views
+          }
+          instance
+        end
+
+        def before_eval # :nodoc:
+          inherit Spec::Rails::DSL::ControllerEvalContext
+          prepend_before {setup}
+          append_after {teardown}
+          configure
+        end
+
+        Spec::DSL::BehaviourFactory.add_behaviour_class(:controller, self)
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/functional.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/functional.rb
new file mode 100644
index 000000000..e0caf9f48
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/functional.rb
@@ -0,0 +1,90 @@
+module Spec
+  module Rails
+    module DSL
+      module FunctionalBehaviourHelpers
+        class << self
+          def included(mod)
+            mod.send :include, ExampleMethods
+            mod.send :extend, BehaviourMethods
+          end
+        end
+        
+        module BehaviourMethods
+          # You MUST provide a controller_name within the context of
+          # your controller specs:
+          #
+          #   describe "ThingController" do
+          #     controller_name :thing
+          #     ...
+          def controller_name(name=nil)
+            @controller_class_name = "#{name}_controller".camelize
+          end
+        end
+        
+        module ExampleMethods
+          # :call-seq:
+          #   assigns()
+          #
+          # Hash of instance variables to values that are made available to views.
+          # == Examples
+          #
+          #   #in thing_controller.rb
+          #   def new
+          #     @thing = Thing.new
+          #   end
+          #
+          #   #in thing_controller_spec
+          #   get 'new'
+          #   assigns[:registration].should == Thing.new
+          #--
+          # NOTE - Even though docs say only use assigns[:key] format, but allowing assigns(:key)
+          # in order to avoid breaking old specs.
+          #++
+          def assigns(key = nil)
+            if key.nil?
+              @controller.assigns
+              _controller_ivar_proxy
+            else
+              @controller.assigns[key]
+              _controller_ivar_proxy[key]
+            end
+          end
+
+        protected
+          def _controller_ivar_proxy
+            @controller_ivar_proxy ||= IvarProxy.new @controller 
+          end
+        end
+      end
+
+      class FunctionalEvalContext < Spec::Rails::DSL::EvalContext
+        include Spec::Rails::DSL::FunctionalBehaviourHelpers
+        attr_reader :request, :response
+        
+        def setup #:nodoc:
+
+          @controller_class = Object.path2class @controller_class_name
+          raise "Can't determine controller class for #{@controller_class_name}" if @controller_class.nil?
+
+          @controller = @controller_class.new
+        
+          @request = ActionController::TestRequest.new
+          @response = ActionController::TestResponse.new
+        end
+        
+        def params
+          request.parameters
+        end
+        
+        def flash
+          response.flash
+        end
+        
+        def session
+          request.session
+        end
+        
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/helper.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/helper.rb
new file mode 100644
index 000000000..9d73c7a1c
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/helper.rb
@@ -0,0 +1,112 @@
+module Spec
+  module Rails
+    module DSL
+      module HelperBehaviourHelpers
+        class << self
+          def included(mod)
+            mod.send :include, ExampleMethods
+            mod.send :extend, BehaviourMethods
+          end
+        end
+        
+        module BehaviourMethods
+          # The helper name....
+          def helper_name(name=nil)
+            send :include, "#{name}_helper".camelize.constantize
+          end
+        end
+        
+        module ExampleMethods
+          include ActionView::Helpers::ActiveRecordHelper
+          include ActionView::Helpers::AssetTagHelper
+          include ActionView::Helpers::BenchmarkHelper
+          include ActionView::Helpers::CacheHelper
+          include ActionView::Helpers::CaptureHelper
+          include ActionView::Helpers::DateHelper
+          include ActionView::Helpers::DebugHelper
+          include ActionView::Helpers::FormHelper
+          include ActionView::Helpers::FormOptionsHelper
+          include ActionView::Helpers::FormTagHelper
+          include ActionView::Helpers::JavaScriptHelper
+          include ActionView::Helpers::JavaScriptMacrosHelper
+          include ActionView::Helpers::NumberHelper
+          include ActionView::Helpers::PaginationHelper rescue nil #removed after 1.2.3
+          include ActionView::Helpers::PrototypeHelper
+          include ActionView::Helpers::PrototypeHelper::JavaScriptGenerator::GeneratorMethods
+          include ActionView::Helpers::ScriptaculousHelper
+          include ActionView::Helpers::TagHelper
+          include ActionView::Helpers::TextHelper
+          include ActionView::Helpers::UrlHelper
+
+          def eval_erb(text)
+            ERB.new(text).result(binding)
+          end
+
+        end
+      end
+
+      class HelperEvalContextController < ApplicationController #:nodoc:
+        attr_accessor :request, :url
+
+        # Re-raise errors
+        def rescue_action(e); raise e; end
+      end
+
+      class HelperEvalContext < Spec::Rails::DSL::FunctionalEvalContext
+        include Spec::Rails::DSL::HelperBehaviourHelpers
+
+        def setup #:nodoc:
+          @controller_class_name = 'Spec::Rails::DSL::HelperEvalContextController'
+          super
+          @controller.request = @request
+          @controller.url = ActionController::UrlRewriter.new @request, {} # url_for
+          
+          @flash = ActionController::Flash::FlashHash.new
+          session['flash'] = @flash
+
+          ActionView::Helpers::AssetTagHelper::reset_javascript_include_default
+        end
+        
+        def flash
+          @flash
+        end
+      
+      end
+
+      # Helper Specs live in $RAILS_ROOT/spec/helpers/.
+      #
+      # Helper Specs use Spec::Rails::DSL::HelperBehaviour, which allows you to
+      # include your Helper directly in the context and write specs directly
+      # against its methods.
+      #
+      # HelperBehaviour also includes the standard lot of ActionView::Helpers in case your
+      # helpers rely on any of those.
+      #
+      # == Example
+      #
+      #   class ThingHelper
+      #     def number_of_things
+      #       Thing.count
+      #     end
+      #   end
+      #
+      #   describe "ThingHelper behaviour" do
+      #     include ThingHelper
+      #     it "should tell you the number of things" do
+      #       Thing.should_receive(:count).and_return(37)
+      #       number_of_things.should == 37
+      #     end
+      #   end
+      class HelperBehaviour < Spec::DSL::Behaviour
+        def before_eval #:nodoc:
+          inherit Spec::Rails::DSL::HelperEvalContext
+          prepend_before {setup}
+          append_after {teardown}
+          configure
+        end
+
+        Spec::DSL::BehaviourFactory.add_behaviour_class(:helper, self)
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/model.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/model.rb
new file mode 100644
index 000000000..a18455ab1
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/model.rb
@@ -0,0 +1,21 @@
+module Spec
+  module Rails
+    module DSL
+      # Model examples live in $RAILS_ROOT/spec/models/.
+      #
+      # Model examples use Spec::Rails::DSL::ModelBehaviour, which
+      # provides support for fixtures and some custom expectations via extensions
+      # to ActiveRecord::Base.
+      class ModelBehaviour < Spec::DSL::Behaviour
+        def before_eval # :nodoc:
+          inherit Spec::Rails::DSL::EvalContext
+          prepend_before {setup}
+          append_after {teardown}
+          configure
+        end
+
+        Spec::DSL::BehaviourFactory.add_behaviour_class(:model, self)
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/render_observer.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/render_observer.rb
new file mode 100644
index 000000000..1687e58b5
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/render_observer.rb
@@ -0,0 +1,94 @@
+require 'spec/mocks'
+
+module Spec
+  module Rails
+    module DSL
+      # Provides specialized mock-like behaviour for controller and view examples,
+      # allowing you to mock or stub calls to render with specific arguments while
+      # ignoring all other calls.
+      module RenderObserver
+
+        # Similar to mocking +render+ with the exception that calls to +render+ with
+        # any other options are passed on to the receiver (i.e. controller in
+        # controller examples, template in view examples).
+        #
+        # This is necessary because Rails uses the +render+ method on both
+        # controllers and templates as a dispatcher to render different kinds of
+        # things, sometimes resulting in many calls to the render method within one
+        # request. This approach makes it impossible to use a normal mock object, which
+        # is designed to observe all incoming messages with a given name.
+        #
+        # +expect_render+ is auto-verifying, so failures will be reported without
+        # requiring you to explicitly request verification.
+        #
+        # Also, +expect_render+ uses parts of RSpec's mock expectation framework. Because
+        # it wraps only a subset of the framework, using this will create no conflict with
+        # other mock frameworks if you choose to use them. Additionally, the object returned
+        # by expect_render is an RSpec mock object, which means that you can call any of the
+        # chained methods available in RSpec's mocks.
+        #
+        # == Controller Examples
+        #
+        #   controller.expect_render(:partial => 'thing', :object => thing)
+        #   controller.expect_render(:partial => 'thing', :collection => things).once
+        #
+        #   controller.stub_render(:partial => 'thing', :object => thing)
+        #   controller.stub_render(:partial => 'thing', :collection => things).twice
+        #
+        # == View Examples
+        #
+        #   template.expect_render(:partial => 'thing', :object => thing)
+        #   template.expect_render(:partial => 'thing', :collection => things)
+        #
+        #   template.stub_render(:partial => 'thing', :object => thing)
+        #   template.stub_render(:partial => 'thing', :collection => things)
+        #
+        def expect_render(opts={})
+          expectation = expect_render_mock_proxy.should_receive(:render, :expected_from => caller(1)[0]).with(opts)
+          register_verify_after_each
+          expectation
+        end
+
+        # This is exactly like expect_render, with the exception that the call to render will not
+        # be verified. Use this if you are trying to isolate your example from a complicated render
+        # operation but don't care whether it is called or not.
+        def stub_render(opts={})
+          expect_render_mock_proxy.should_receive(:render, :expected_from => caller(1)[0]).with(opts).any_number_of_times
+        end
+  
+        def verify_rendered # :nodoc:
+          expect_render_mock_proxy.rspec_verify
+        end
+  
+        def unregister_verify_after_each #:nodoc:
+          proc = verify_rendered_proc
+          Spec::DSL::Behaviour.remove_after(:each, &proc)
+        end
+
+        protected
+
+        def verify_rendered_proc #:nodoc:
+          template = self
+          @verify_rendered_proc ||= Proc.new do
+            template.verify_rendered
+            template.unregister_verify_after_each
+          end
+        end
+
+        def register_verify_after_each #:nodoc:
+          proc = verify_rendered_proc
+          Spec::DSL::Behaviour.after(:each, &proc)
+        end
+  
+        def expect_render_mock_proxy #:nodoc:
+          @expect_render_mock_proxy ||= lambda do
+            proxy = Spec::Mocks::Mock.new("expect_render_mock_proxy")
+            proxy.stub!(:render)
+            proxy
+          end.call
+        end
+  
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/view.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/view.rb
new file mode 100644
index 000000000..033d6f9c3
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/view.rb
@@ -0,0 +1,196 @@
+module Spec
+  module Rails
+    module DSL
+      module ViewBehaviourHelpers
+        class << self
+          def included(mod)
+            mod.send :include, ExampleMethods
+          end
+        end
+        
+        module ExampleMethods
+          # Renders a template for a View Spec, which then provides access to the result
+          # through the +response+.
+          # 
+          # == Examples
+          # 
+          #   render('/people/list')
+          #   render('/people/list', :helper => MyHelper)
+          #   render('/people/list', :helpers => [MyHelper, MyOtherHelper])
+          #   render(:partial => '/people/_address')
+          #
+          # See Spec::Rails::DSL::ViewBehaviour for more information.
+          def render(*args)
+            options = Hash === args.last ? args.pop : {}
+            options[:template] = args.first.to_s unless args.empty?
+
+            set_base_view_path(options)
+            add_helpers(options)
+
+            assigns[:action_name] = @action_name
+
+            @request.path_parameters = {
+              :controller => derived_controller_name(options),
+              :action => derived_action_name(options)
+            }
+
+            defaults = { :layout => false }
+            options = defaults.merge options
+
+            @controller.instance_variable_set :@params, @request.parameters
+            
+            @controller.send :initialize_current_url
+
+            @controller.class.instance_eval %{
+              def controller_path
+                "#{derived_controller_name(options)}"
+              end
+              
+              def controller_name
+                "#{derived_controller_name(options).split('/').last}"
+              end
+            }
+
+            @controller.send :forget_variables_added_to_assigns
+            @controller.send :render, options
+            @controller.send :process_cleanup
+          end
+          
+          # This provides the template. Use this to set mock
+          # expectations for dealing with partials
+          #
+          # == Example
+          #
+          #   describe "/person/new" do
+          #     it "should use the form partial" do
+          #       template.should_receive(:render).with(:partial => 'form')
+          #       render "/person/new"
+          #     end
+          #   end
+          def template
+            @controller.template
+          end
+          
+        end
+      end
+      
+      class ViewExampleController < ActionController::Base #:nodoc:
+        include Spec::Rails::DSL::RenderObserver
+        attr_reader :template
+
+        def add_helper_for(template_path)
+          add_helper(template_path.split('/')[0])
+        end
+
+        def add_helper(name)
+          begin
+            helper_module = "#{name}_helper".camelize.constantize
+          rescue
+            return
+          end
+          template.metaclass.class_eval do
+            include helper_module
+          end
+        end
+      
+      end
+      
+      class ViewEvalContext < Spec::Rails::DSL::FunctionalEvalContext
+        include Spec::Rails::DSL::ViewBehaviourHelpers
+        def setup #:nodoc:
+          super
+          ensure_that_flash_and_session_work_properly
+        end
+        
+        def ensure_that_flash_and_session_work_properly #:nodoc:
+          @controller.send :initialize_template_class, @response
+          @controller.send :assign_shortcuts, @request, @response
+          @session = @controller.session
+          @controller.class.send :public, :flash
+        end
+      
+        def teardown #:nodoc:
+          super
+          ensure_that_base_view_path_is_not_set_across_behaviours
+        end
+        
+        def ensure_that_base_view_path_is_not_set_across_behaviours #:nodoc:
+          ActionView::Base.base_view_path = nil
+        end
+
+        def set_base_view_path(options) #:nodoc:
+          ActionView::Base.base_view_path = base_view_path(options)
+        end
+
+        def base_view_path(options) #:nodoc:
+          "/#{derived_controller_name(options)}/"
+        end
+
+        def derived_controller_name(options) #:nodoc:
+          parts = subject_of_render(options).split('/').reject { |part| part.empty? }
+          "#{parts[0..-2].join('/')}"
+        end
+      
+        def derived_action_name(options) #:nodoc:
+          parts = subject_of_render(options).split('/').reject { |part| part.empty? }
+          "#{parts.last}"
+        end
+      
+        def subject_of_render(options) #:nodoc:
+          [:template, :partial, :file].each do |render_type|
+            if options.has_key?(render_type)
+              return options[render_type]
+            end
+          end
+          raise Exception.new("Unhandled render type in view spec.")
+        end
+      
+        def add_helpers(options) #:nodoc:
+          @controller.add_helper("application")
+          @controller.add_helper(derived_controller_name(options))
+          @controller.add_helper(options[:helper]) if options[:helper]
+          options[:helpers].each { |helper| @controller.add_helper(helper) } if options[:helpers]
+        end
+
+      end
+
+      # View Examples live in $RAILS_ROOT/spec/views/.
+      #
+      # View Specs use Spec::Rails::DSL::ViewBehaviour,
+      # which provides access to views without invoking any of your controllers.
+      # See Spec::Rails::Expectations::Matchers for information about specific
+      # expectations that you can set on views.
+      #
+      # == Example
+      #
+      #   describe "login/login" do
+      #     before do
+      #       render 'login/login'
+      #     end
+      # 
+      #     it "should display login form" do
+      #       response.should have_tag("form[action=/login]") do
+      #         with_tag("input[type=text][name=email]")
+      #         with_tag("input[type=password][name=password]")
+      #         with_tag("input[type=submit][value=Login]")
+      #       end
+      #     end
+      #   end
+      class ViewBehaviour < Spec::DSL::Behaviour
+        def execution_context(specification=nil) # :nodoc:
+          instance = execution_context_class.new(specification)
+          instance.instance_eval { @controller_class_name = "Spec::Rails::DSL::ViewExampleController" }
+          instance
+        end
+        def before_eval # :nodoc:
+          inherit Spec::Rails::DSL::ViewEvalContext
+          prepend_before {setup}
+          append_after {teardown}
+          configure
+        end
+
+        Spec::DSL::BehaviourFactory.add_behaviour_class(:view, self)
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/ivar_proxy.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/ivar_proxy.rb
new file mode 100644
index 000000000..4128c88f1
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/ivar_proxy.rb
@@ -0,0 +1,62 @@
+##
+# A wrapper that allows instance variables to be manipulated using +[]+ and
+# +[]=+
+
+module Spec
+  module Rails
+    module DSL
+      class IvarProxy #:nodoc:
+
+        ##
+        # Wraps +object+ allowing its instance variables to be manipulated.
+
+        def initialize(object)
+          @object = object
+        end
+
+        ##
+        # Retrieves +ivar+ from the wrapped object.
+
+        def [](ivar)
+          get_variable "@#{ivar}"
+        end
+
+        ##
+        # Sets +ivar+ to +val+ on the wrapped object.
+
+        def []=(ivar, val)
+          set_variable "@#{ivar}", val
+        end
+
+        def each
+          @object.instance_variables.each do |variable_full_name|
+            variable_name = variable_full_name[1...variable_full_name.length]
+            yield variable_name, get_variable(variable_full_name)
+          end
+        end
+
+        def delete(key)
+          var_name = "@#{key}"
+          if @object.instance_variables.include?(var_name)
+            @object.send(:remove_instance_variable, var_name)
+          else
+            return nil
+          end
+        end
+
+        def has_key?(key)
+          @object.instance_variables.include?("@#{key}")
+        end
+
+        protected
+        def get_variable(name)
+          @object.instance_variable_get name
+        end
+
+        def set_variable(name, value)
+          @object.instance_variable_set name, value
+        end
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions.rb
new file mode 100644
index 000000000..73dd1540f
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions.rb
@@ -0,0 +1,8 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/extensions/object")
+require File.expand_path("#{dir}/extensions/active_record/base")
+require File.expand_path("#{dir}/extensions/active_record/oracle_adapter_patch")
+require File.expand_path("#{dir}/extensions/action_controller/base")
+require File.expand_path("#{dir}/extensions/action_controller/rescue")
+require File.expand_path("#{dir}/extensions/action_controller/test_response")
+require File.expand_path("#{dir}/extensions/action_view/base")
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/base.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/base.rb
new file mode 100755
index 000000000..4b1b7c2df
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/base.rb
@@ -0,0 +1,11 @@
+module ActionController
+  class Base
+    class << self
+      def set_view_path(path)
+        method = respond_to?(:view_paths=) ? :view_paths= : :template_root=
+        send(method, path)
+      end
+    end
+  end
+end
+        
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/rescue.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/rescue.rb
new file mode 100644
index 000000000..03dc57276
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/rescue.rb
@@ -0,0 +1,21 @@
+module ActionController
+  module Rescue
+    def use_rails_error_handling!
+      @use_rails_error_handling = true
+    end
+
+    def use_rails_error_handling?
+      @use_rails_error_handling ||= false
+    end
+
+    protected
+    def rescue_action_with_fast_errors(exception)
+      if use_rails_error_handling?
+        rescue_action_without_fast_errors exception
+      else
+        raise exception
+      end
+    end
+    alias_method_chain :rescue_action, :fast_errors
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/test_response.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/test_response.rb
new file mode 100644
index 000000000..85badf9a0
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/test_response.rb
@@ -0,0 +1,11 @@
+module ActionController #:nodoc:
+  class TestResponse #:nodoc:
+    attr_writer :controller_path
+
+    def capture(name)
+      template.instance_variable_get "@content_for_#{name.to_s}"
+    end
+    alias [] capture
+
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_view/base.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_view/base.rb
new file mode 100644
index 000000000..8bb9ff1b6
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_view/base.rb
@@ -0,0 +1,26 @@
+module ActionView #:nodoc:
+  class Base #:nodoc:
+    include Spec::Rails::DSL::RenderObserver
+    cattr_accessor :base_view_path
+    def render_partial(partial_path, local_assigns = nil, deprecated_local_assigns = nil) #:nodoc:
+      if partial_path.is_a?(String)
+        unless partial_path.include?("/")
+          unless self.class.base_view_path.nil?
+            partial_path = "#{self.class.base_view_path}/#{partial_path}"
+          end
+        end
+      end
+      super(partial_path, local_assigns, deprecated_local_assigns)
+    end
+
+    alias_method :orig_render, :render
+    def render(options = {}, old_local_assigns = {}, &block)
+      if (Hash === options)
+        expect_render_mock_proxy.render(options)
+      end
+      unless expect_render_mock_proxy.send(:__mock_proxy).send(:find_matching_expectation, :render, options)
+        orig_render(options, old_local_assigns, &block)
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/active_record/base.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/active_record/base.rb
new file mode 100644
index 000000000..c58e8579f
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/active_record/base.rb
@@ -0,0 +1,29 @@
+module ActiveRecord #:nodoc:
+  class Base
+
+    (class << self; self; end).class_eval do
+      # Extension for <tt>should have</tt> on AR Model classes
+      #
+      #   ModelClass.should have(:no).records
+      #   ModelClass.should have(1).record
+      #   ModelClass.should have(n).records
+      def records
+        find(:all)
+      end
+      alias :record :records
+    end
+
+    # Extension for <tt>should have</tt> on AR Model instances
+    #
+    #   model.should have(:no).errors_on(:attribute)
+    #   model.should have(1).error_on(:attribute)
+    #   model.should have(n).errors_on(:attribute)
+    def errors_on(attribute)
+      self.valid?
+      [self.errors.on(attribute)].flatten.compact
+    end
+    alias :error_on :errors_on
+
+  end
+end
+
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/active_record/oracle_adapter_patch.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/active_record/oracle_adapter_patch.rb
new file mode 100644
index 000000000..18f40b808
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/active_record/oracle_adapter_patch.rb
@@ -0,0 +1,8 @@
+if defined?(OCI8AutoRecover)
+  module OracleAdapterPatch
+    def describe(name)
+      @connection.describe(name)
+    end
+  end
+  OCI8AutoRecover.send(:include, OracleAdapterPatch)
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/object.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/object.rb
new file mode 100644
index 000000000..68fce0ba8
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/object.rb
@@ -0,0 +1,5 @@
+class Object # :nodoc:
+  def self.path2class(klassname)
+    klassname.split('::').inject(Object) { |k,n| k.const_get n }
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers.rb
new file mode 100644
index 000000000..c5258966d
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers.rb
@@ -0,0 +1,29 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/matchers/assert_select")
+require File.expand_path("#{dir}/matchers/have_text")
+require File.expand_path("#{dir}/matchers/redirect_to")
+require File.expand_path("#{dir}/matchers/render_template")
+
+module Spec
+  module Rails
+    # Spec::Rails::Expectations::Matchers provides several expectation matchers
+    # intended to work with Rails components like models and responses. For example:
+    #
+    #   response.should redirect_to("some/url") #redirect_to(url) is the matcher.
+    #
+    # In addition to those you see below, the arbitrary predicate feature of RSpec
+    # makes the following available as well:
+    #
+    #   response.should be_success #passes if response.success?
+    #   response.should be_redirect #passes if response.redirect?
+    #
+    # Note that many of these matchers are part of a wrapper of <tt>assert_select</tt>, so
+    # the documentation comes straight from that with some slight modifications.
+    # <tt>assert_select</tt> is a Test::Unit extension originally contributed to the
+    # Rails community as a plugin by Assaf Arkin and eventually shipped as part of Rails.
+    #
+    # For more info on <tt>assert_select</tt>, see the relevant Rails documentation.
+    module Matchers
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/assert_select.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/assert_select.rb
new file mode 100644
index 000000000..c8cdf3521
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/assert_select.rb
@@ -0,0 +1,137 @@
+# This is a wrapper of assert_select for rspec.
+
+module Spec # :nodoc:
+  module Rails
+    module Matchers
+      
+      class AssertSelect #:nodoc:
+        
+        def initialize(*args, &block)
+          @assertion = args.shift
+          @spec_scope = args.shift
+          @args = args
+          @block = block
+        end
+        
+        def matches?(response_or_text, &block)
+          if ActionController::TestResponse === response_or_text and
+                   response_or_text.headers.key?('Content-Type') and
+                   response_or_text.headers['Content-Type'].to_sym == :xml
+            @args.unshift(HTML::Document.new(response_or_text.body, false, true).root)           
+          elsif String === response_or_text
+            @args.unshift(HTML::Document.new(response_or_text).root)
+          end
+          @block = block if block
+          begin
+            @spec_scope.send(@assertion, *@args, &@block)
+          rescue Exception => @error
+          end
+          @error.nil?
+        end
+        
+        def failure_message; @error.message; end
+        def negative_failure_message; "should not #{description}, but did"; end
+        
+        def description
+          {
+            :assert_select => "have tag#{format_args(*@args)}",
+            :assert_select_email => "send email#{format_args(*@args)}",
+          }[@assertion]
+        end
+        
+      private
+
+        def format_args(*args)
+          return "" if args.empty?
+          return "(#{arg_list(*args)})"
+        end
+
+        def arg_list(*args)
+          args.collect do |arg|
+            arg.respond_to?(:description) ? arg.description : arg.inspect
+          end.join(", ")
+        end
+        
+      end
+      
+      # :call-seq:
+      #   response.should have_tag(*args, &block)
+      #   string.should have_tag(*args, &block)
+      #
+      # wrapper for assert_select with additional support for using
+      # css selectors to set expectation on Strings. Use this in
+      # helper specs, for example, to set expectations on the results
+      # of helper methods.
+      #
+      # == Examples
+      #
+      #   # in a controller spec
+      #   response.should have_tag("div", "some text")
+      #
+      #   # in a helper spec (person_address_tag is a method in the helper)
+      #   person_address_tag.should have_tag("input#person_address")
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def have_tag(*args, &block)
+        args.unshift(self)
+        args.unshift(:assert_select)
+        AssertSelect.new(*args, &block)
+      end
+    
+      # wrapper for a nested assert_select
+      #
+      #   response.should have_tag("div#form") do
+      #     with_tag("input#person_name[name=?]", "person[name]")
+      #   end
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def with_tag(*args, &block)
+        should have_tag(*args, &block)
+      end
+    
+      # wrapper for a nested assert_select with false
+      #
+      #   response.should have_tag("div#1") do
+      #     without_tag("span", "some text that shouldn't be there")
+      #   end
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def without_tag(*args, &block)
+        should_not have_tag(*args, &block)
+      end
+    
+      # :call-seq:
+      #   response.should have_rjs(*args, &block)
+      #
+      # wrapper for assert_select_rjs
+      #
+      # see documentation for assert_select_rjs at http://api.rubyonrails.org/
+      def have_rjs(*args, &block)
+        args.unshift(self)
+        args.unshift(:assert_select_rjs)
+        AssertSelect.new(*args, &block)
+      end
+      
+      # :call-seq:
+      #   response.should send_email(*args, &block)
+      #
+      # wrapper for assert_select_email
+      #
+      # see documentation for assert_select_email at http://api.rubyonrails.org/
+      def send_email(*args, &block)
+        args.unshift(self)
+        args.unshift(:assert_select_email)
+        AssertSelect.new(*args, &block)
+      end
+      
+      # wrapper for assert_select_encoded
+      #
+      # see documentation for assert_select_encoded at http://api.rubyonrails.org/
+      def with_encoded(*args, &block)
+        args.unshift(self)
+        args.unshift(:assert_select_encoded)
+        should AssertSelect.new(*args, &block)
+      end
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/have_text.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/have_text.rb
new file mode 100644
index 000000000..5e4324107
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/have_text.rb
@@ -0,0 +1,55 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class HaveText  #:nodoc:
+
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(response)
+          @actual = response.body
+          return actual =~ expected if Regexp === expected
+          return actual == expected unless Regexp === expected
+        end
+      
+        def failure_message
+          "expected #{expected.inspect}, got #{actual.inspect}"
+        end
+        
+        def negative_failure_message
+          "expected not to have text #{expected.inspect}"
+        end
+        
+        def to_s
+          "have text #{expected.inspect}"
+        end
+      
+        private
+          attr_reader :expected
+          attr_reader :actual
+
+      end
+
+      # :call-seq:
+      #   response.should have_text(expected)
+      #   response.should_not have_text(expected)
+      #
+      # Accepts a String or a Regexp, matching a String using ==
+      # and a Regexp using =~.
+      #
+      # Use this instead of <tt>response.should have_tag()</tt>
+      # when you either don't know or don't care where on the page
+      # this text appears.
+      #
+      # == Examples
+      #
+      #   response.should have_text("This is the expected text")
+      def have_text(text)
+        HaveText.new(text)
+      end
+    
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/redirect_to.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/redirect_to.rb
new file mode 100644
index 000000000..35ebbe5d7
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/redirect_to.rb
@@ -0,0 +1,110 @@
+require 'action_controller/url_rewriter'
+
+module Spec
+  module Rails
+    module Matchers
+    
+      class RedirectTo  #:nodoc:
+    
+        def initialize(request, expected)
+          @expected = expected
+          @request = request
+        end
+
+        def matches?(response)
+          @redirected = response.redirect?
+          @actual = response.redirect_url
+          return false unless @redirected
+          if @expected.instance_of? Hash
+            return false unless @actual =~ %r{^\w+://#{@request.host}}
+            return false unless actual_redirect_to_valid_route
+            return actual_hash == expected_hash
+          else
+            return @actual == expected_url
+          end
+        end
+
+        def actual_hash
+          hash_from_url @actual
+        end
+
+        def expected_hash
+          hash_from_url expected_url
+        end
+
+        def actual_redirect_to_valid_route
+          actual_hash
+        end
+
+        def hash_from_url(url)
+          query_hash(url).merge(path_hash(url)).with_indifferent_access
+        end
+
+        def path_hash(url)
+          path = url.sub(%r{^\w+://#{@request.host}}, "").split("?", 2)[0]
+          path = path.split("/")[1..-1] if ::Rails::VERSION::MINOR < 2
+          ActionController::Routing::Routes.recognize_path path
+        end
+
+        def query_hash(url)
+          query = url.split("?", 2)[1] || ""
+          if defined?(CGIMethods)
+            CGIMethods.parse_query_parameters(query)
+          else
+            ActionController::AbstractRequest.parse_query_parameters(query)
+          end
+        end
+
+       def expected_url
+          case @expected
+            when Hash
+              return ActionController::UrlRewriter.new(@request, {}).rewrite(@expected)
+            when :back
+              return @request.env['HTTP_REFERER']
+            when %r{^\w+://.*}
+              return @expected
+            else
+              return "http://#{@request.host}" + (@expected.split('')[0] == '/' ? '' : '/') + @expected
+          end
+        end
+
+        def failure_message
+          if @redirected
+            return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
+          else
+            return %Q{expected redirect to #{@expected.inspect}, got no redirect}
+          end
+        end
+        
+        def negative_failure_message
+            return %Q{expected not to be redirected to #{@expected.inspect}, but was} if @redirected
+        end
+        
+        def description
+          "redirect to #{@actual.inspect}"
+        end
+      end
+
+      # :call-seq:
+      #   response.should redirect_to(url)
+      #   response.should redirect_to(:action => action_name)
+      #   response.should redirect_to(:controller => controller_name, :action => action_name)
+      #   response.should_not redirect_to(url)
+      #   response.should_not redirect_to(:action => action_name)
+      #   response.should_not redirect_to(:controller => controller_name, :action => action_name)
+      #
+      # Passes if the response is a redirect to the url, action or controller/action.
+      # Useful in controller specs (integration or isolation mode).
+      #
+      # == Examples
+      #
+      #   response.should redirect_to("path/to/action")
+      #   response.should redirect_to("http://test.host/path/to/action")
+      #   response.should redirect_to(:action => 'list')
+      def redirect_to(opts)
+        RedirectTo.new(request, opts)
+      end
+    end
+
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/render_template.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/render_template.rb
new file mode 100644
index 000000000..8c3df3ad2
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/render_template.rb
@@ -0,0 +1,66 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class RenderTemplate #:nodoc:
+    
+        def initialize(expected, controller)
+          @controller = controller
+          @expected = expected
+        end
+      
+        def matches?(response)
+          @actual = response.rendered_file
+          full_path(@actual) == full_path(@expected)
+        end
+
+        def failure_message
+          "expected #{@expected.inspect}, got #{@actual.inspect}"
+        end
+        
+        def description
+          "render template #{@expected.inspect}"
+        end
+      
+        private
+          def full_path(path)
+            return nil if path.nil?
+            path.include?('/') ? path : "#{@controller.class.to_s.underscore.gsub('_controller','')}/#{path}"
+          end
+        
+      end
+
+      # :call-seq:
+      #   response.should render_template(path)
+      #   response.should_not render_template(path)
+      #
+      # Passes if the specified template is rendered by the response.
+      # Useful in controller specs (integration or isolation mode).
+      #
+      # <code>path</code> can include the controller path or not. It
+      # can also include an optional extension (no extension assumes .rhtml).
+      #
+      # Note that partials must be spelled with the preceding underscore.
+      #
+      # == Examples
+      #
+      #   response.should render_template('list')
+      #   response.should render_template('same_controller/list')
+      #   response.should render_template('other_controller/list')
+      #
+      #   #rjs
+      #   response.should render_template('list.rjs')
+      #   response.should render_template('same_controller/list.rjs')
+      #   response.should render_template('other_controller/list.rjs')
+      #
+      #   #partials
+      #   response.should render_template('_a_partial')
+      #   response.should render_template('same_controller/_a_partial')
+      #   response.should render_template('other_controller/_a_partial')
+      def render_template(path)
+        RenderTemplate.new(path.to_s, @controller)
+      end
+
+    end
+  end
+end
diff --git a/vendor/plugins/rspec_on_rails/lib/spec/rails/version.rb b/vendor/plugins/rspec_on_rails/lib/spec/rails/version.rb
new file mode 100644
index 000000000..b97040856
--- /dev/null
+++ b/vendor/plugins/rspec_on_rails/lib/spec/rails/version.rb
@@ -0,0 +1,27 @@
+module Spec
+  module Rails
+    module VERSION #:nodoc:
+      unless defined?(REV)
+        # RANDOM_TOKEN: 0.510454315029681
+        REV = "$LastChangedRevision: 2338 $".match(/LastChangedRevision: (\d+)/)[1]
+      end
+    end
+  end
+end
+
+# Verifies that the plugin has the same revision as RSpec
+if Spec::VERSION::REV != Spec::Rails::VERSION::REV
+  raise <<-EOF
+
+############################################################################
+Your RSpec on Rails plugin is incompatible with your installed RSpec.
+
+RSpec          : #{Spec::VERSION::FULL_VERSION}
+RSpec on Rails : r#{Spec::Rails::VERSION::REV}
+
+Make sure your RSpec on Rails plugin is compatible with your RSpec gem.
+See http://rspec.rubyforge.org/documentation/rails/install.html for details.
+############################################################################
+EOF
+end
+