benhutton-remarkable_rails 4.0.0.alpha4

data/CHANGELOG

@@ -0,0 +1,105 @@
+* Allow should route(:get, :action => :show, :id => 1).to("/projects/1") and
+  should route(:get, "/projects/1").from(:action => :show, :id => 1) syntax.
+
+* Plugin files are automatically loaded [#86]
+
+* Allow should_route to use environment configuration [#88] (thanks to Lawrence Pit)
+
+* Allow mock model class to be set using :as option.
+
+* [DEPRECATION] By default all matchers perform expectations, use with_stubs => true
+  if you want otherwise.
+
+* [DEPRECATION] mock_models now creates model_proc instead of mock_model.
+  Altough this won't fire any deprecation warning, all the documentation was changed.
+
+* assert_valid_keys on expects
+
+* mock_models now creates a second class method to be used on the index action [#71]
+  In other words, mock_models :project will create:
+
+    def self.mock_project
+     proc { mock_project }
+    end
+
+    # This was added to be used on index actions
+    def self.mock_projects
+      proc { [ mock_project ] }
+    end
+
+    def mock_project(stubs={})
+      @project ||= mock_model(Project, stubs)
+    end
+
+* Allow multiple args to be given to :with in expects. If you need to verify that
+  an array is being sent, you need to send an array inside another array [#70]
+
+* Allow procs or blocks to be given to respond_with_body and respond_with :body [#67]
+
+* Allow ordered to be given to macro stubs as option [#66]
+
+# v3.1
+
+* Ensure set_cookies and set_session work with arrays [#55]
+
+* Added set_cookies matcher [#51]
+
+* Add a helper to declare that a XmlHttpRequest should be performed:
+
+    describe :get => :show do
+      xhr!
+
+* Macro stubs now supports blocks too [#50]
+
+    expects :human_attribute_name, :on => Project, :with => :title do |attr|
+      attr.to_s.humanize
+    end
+
+* :to option in set_session and set_the_flash now accepts Regexp [#46]
+
+* render_template now works with partials [#43]
+
+* Added to support for routing example group (inside spec/routing) [#26]
+
+# v3.0
+
+* redirect_to and render_template were ported from rspec-rails to
+remarkable to provide I18n. The second was also extended to deal with :with,
+:layout and :content_type as options.
+
+render_with_layout, render_without_layout delegate their logic to render_template
+so they share the same options.
+
+respond_with_content_type and respond_wity_body delegate their logic to
+respond_with matcher, so they also share the same options.
+
+:set_the_flash was also redesign to inherit from :set_session, providing a
+consistent API.
+
+* remarkable_rails now ships with a new feature, called macro stubs.
+This allows you to declare just once your mocks and/or expectations, and each
+matcher will know how to deal with properly. A TasksController could have your
+specs for a create action rewritten like this:
+
+  describe TasksController do
+    mock_models :task
+
+    describe :post => :create, :task => { :these => 'params' } do
+      expects :new,  :on => Task, with => {'these' => 'params'}, :returns => task_proc
+      expects :save, :on => mock_task, :returns => true
+
+      should_assign_to :task, :with => task_proc
+      should_redirect_to { task_url(mock_task) }
+    end
+  end
+
+It automatically performs the action before running each macro. In assign_to,
+it executes the expects as expectations (:should_receive), and in redirect_to
+it executes the expects as stubs (:stub!), just as above.
+
+For more options, information and configuration, check macro stubs documentation.
+
+# v2.x
+
+* Added assign_to, filter_params, render_with_layout, respond_with
+respond_with_content_type, route, set_session and set_the_flash matchers.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Carlos Brando
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,116 @@
+= Remarkable Rails
+
+Remarkable Rails is a collection of matchers to Rails. This package has some
+ActionController matchers and soon some ActionView matchers.
+
+Whenever using the Remarkable Rails gem, it will automatically add your ActiveRecord
+matchers. So just one line is needed to install both:
+
+  sudo gem install remarkable_rails
+
+If you are using Rails 2.3, you need to have this configuration on your
+config/environments/test.rb:
+
+  config.gem "rspec",            :lib => false
+  config.gem "rspec-rails",      :lib => false
+  config.gem "remarkable_rails", :lib => false
+
+And then require remarkable inside your spec_helper.rb, after "spec/rails":
+
+  require 'spec/rails'
+  require 'remarkable_rails'
+
+== Matchers & Macros
+
+The supported matchers and macros are:
+
+  assign_to, filter_params, render_with_layout, respond_with, 
+  respond_with_content_type, route, set_session and set_the_flash matchers.
+
+In Remarkable 3.0, we also ported and extended redirect to and render template
+from rspec rails matchers to provide I18n. You can also do:
+
+  render_template 'edit', :layout => 'default'
+  respond_with 404, :content_type => Mime::XML, :body => /Not found/
+
+== Macro stubs
+
+Another cool feature in Remarkable 3.0 is macro stubs, which makes your mocks
+and stubs DRY and easier to maintain. An rspec default scaffold would be:
+
+  describe TasksController do
+    def mock_task(stubs={})
+      @task ||= mock_model(Task, stubs)
+    end
+
+    describe “responding to #POST create” do
+      it "exposes a newly created task as @task" do
+        Task.should_receive(:new).with({'these' => 'params'}).
+                                  and_return(mock_task(:save => true))
+        post :create, :task => {:these => 'params'}
+        assigns[:task].should equal(mock_task)
+      end
+
+      it "redirects to the created task" do
+        Task.stub!(:new).and_return(mock_task(:save => true))
+        post :create, :task => {}
+        response.should redirect_to(task_url(mock_task))
+      end
+    end
+  end
+
+An equivalent in remarkable would be:
+
+  describe TasksController do
+    mock_models :task
+
+    describe :post => :create, :task => { :these => 'params' } do
+      expects :new,  :on => Task, :with => {'these' => 'params'}, :returns => task_proc
+      expects :save, :on => task_proc, :returns => true
+
+      should_assign_to :task, :with => task_proc
+      should_redirect_to { task_url(mock_task) }
+    end
+  end
+
+It automatically performs the action before running each macro. It executes the
+expects as expectations (:should_receive), but you can supply :with_stubs => true
+if you want it to be executed with stubs.
+
+There are also params and mime methods:
+
+  describe TasksController
+    params :project_id => 42
+    mime Mime::HTML
+
+    describe :get => :show, :id => 37 do
+      should_assign_to :project, :task
+
+      describe Mime::XML do
+        should_assign_to :project, :task
+      end
+    end
+  end
+
+And much more. Be sure to check macro stubs documentation.
+
+== Rails plugin developers
+
+Remarkable automatically loads files at the remarkable directory on your plugins
+and frozen gems if RAILS_ROOT is defined. The lookup happens like this:
+
+  RAILS_ROOT/spec/remarkable
+  RAILS_ROOT/vendor/gems/*/remarkable
+  RAILS_ROOT/vendor/plugins/*/remarkable
+
+Remarkable will load both ruby files (.rb) and Remarkable locale files (.yml).
+
+The only step remaining is to include the matchers, which Remarkable will not
+do automatically if the user is not using a Remarkable namespace. For example,
+if the developer includes his matchers to Remarkable::ActiveRecord::Matchers,
+the matchers will be automatically available in users spec. But if he creates
+a new namespace, like MyPlugin::Matchers, he has to tell Remarkable to include
+them in the proper example group:
+
+  Remarkable.include_matchers!(MyPlugin::Matchers, Spec::Rails::Example::ModelExampleGroup)
+

data/benhutton-remarkable_rails.gemspec

@@ -0,0 +1,73 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{benhutton-remarkable_rails}
+  s.version = "4.0.0.alpha4"
+
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ben Hutton", "Carlos Brando", "José Valim"]
+  s.date = %q{2010-11-15}
+  s.description = %q{Remarkable Rails: collection of matchers and macros with I18n for Rails}
+  s.email = ["benhutton@gmail.com", "eduardobrando@gmail.com", "jose.valim@gmail.com"]
+  s.extra_rdoc_files = [
+    "CHANGELOG",
+     "LICENSE",
+     "README"
+  ]
+  s.files = [
+    "CHANGELOG",
+     "LICENSE",
+     "README",
+     "benhutton-remarkable_rails.gemspec",
+     "lib/remarkable_rails.rb",
+     "lib/remarkable_rails/action_controller.rb",
+     "lib/remarkable_rails/action_controller/base.rb",
+     "lib/remarkable_rails/action_controller/macro_stubs.rb",
+     "lib/remarkable_rails/action_controller/matchers/assign_to_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/filter_params_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/redirect_to_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/render_template_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/respond_with_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/route_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/set_cookies_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/set_session_matcher.rb",
+     "lib/remarkable_rails/action_controller/matchers/set_the_flash_matcher.rb",
+     "lib/remarkable_rails/action_view.rb",
+     "lib/remarkable_rails/action_view/base.rb",
+     "lib/remarkable_rails/active_orm.rb",
+     "locale/en.yml",
+     "remarkable_rails.gemspec"
+  ]
+  s.homepage = %q{http://github.com/benhutton/remarkable}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{remarkable}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Remarkable Rails: collection of matchers and macros with I18n for Rails}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rspec>, [">= 2.0.0"])
+      s.add_runtime_dependency(%q<rspec-rails>, [">= 2.0.0"])
+      s.add_runtime_dependency(%q<remarkable>, ["~> 4.0.0.alpha4"])
+      s.add_runtime_dependency(%q<remarkable_activerecord>, ["~> 4.0.0.alpha4"])
+    else
+      s.add_dependency(%q<rspec>, [">= 2.0.0"])
+      s.add_dependency(%q<rspec-rails>, [">= 2.0.0"])
+      s.add_dependency(%q<remarkable>, ["~> 4.0.0.alpha4"])
+      s.add_dependency(%q<remarkable_activerecord>, ["~> 4.0.0.alpha4"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 2.0.0"])
+    s.add_dependency(%q<rspec-rails>, [">= 2.0.0"])
+    s.add_dependency(%q<remarkable>, ["~> 4.0.0.alpha4"])
+    s.add_dependency(%q<remarkable_activerecord>, ["~> 4.0.0.alpha4"])
+  end
+end
+

data/lib/remarkable_rails.rb

@@ -0,0 +1,48 @@
+# Load Remarkable
+require 'remarkable/core'
+
+# Load spec/rails
+# require 'rspec/rails'
+
+# Load Remarkable Rails base files
+dir = File.dirname(__FILE__)
+require File.join(dir, 'remarkable_rails', 'active_orm')
+require File.join(dir, 'remarkable_rails', 'action_controller')
+require File.join(dir, 'remarkable_rails', 'action_view')
+
+# Load locale file
+Remarkable.add_locale File.join(dir, '..', 'locale', 'en.yml')
+# Load plugin files if RAILS_ROOT is defined. It loads files at:
+#
+#   RAILS_ROOT/spec/remarkable
+#   RAILS_ROOT/vendor/gems/*/remarkable
+#   RAILS_ROOT/vendor/plugins/*/remarkable
+#
+# Remarkable will load both ruby files (.rb) and Remarkable locale files (.yml).
+#
+# The only step remaining is to include the matchers, which Remarkable will not
+# do automatically if the user is not using a Remarkable namespace. For example,
+# if the developer includes his matchers to Remarkable::ActiveRecord::Matchers,
+# the matchers will be automatically available in users spec. But if he creates
+# a new namespace, like MyPlugin::Matchers, he has to tell Remarkable to include
+# them in the proper example group:
+#
+#   Remarkable.include_matchers!(MyPlugin::Matchers, Spec::Rails::Example::ModelExampleGroup)
+#
+if defined?(Rails.root)
+  files = []
+  files += Dir.glob(File.join(Rails.root, "spec", "remarkable", "*"))
+  files += Dir.glob(File.join(Rails.root, "vendor", "{plugins,gems}", "*", "remarkable", "*"))
+  files.each do |file|
+    begin
+      case File.extname(file)
+        when ".rb"
+          require file
+        when ".yml"
+          Remarkable.add_locale file
+      end
+    rescue Exception => e
+      warn "[WARNING] Remarkable could not load file #{file.inspect}. Error: #{e.message}"
+    end
+  end
+end

data/lib/remarkable_rails/action_controller.rb

@@ -0,0 +1,22 @@
+module Remarkable
+  module ActionController
+  end
+end
+
+dir = File.dirname(__FILE__)
+require File.join(dir, 'action_controller', 'base')
+require File.join(dir, 'action_controller', 'macro_stubs')
+
+# Load matchers
+Dir[File.join(dir, 'action_controller', 'matchers', '*.rb')].each do |file|
+  require file
+end
+
+# Include macro_stubs and matchers in Spec::Rails
+if defined?(RSpec::Rails)
+  # RSpec::Rails::ControllerExampleGroup.send :include, Remarkable::ActionController::MacroStubs
+
+  Remarkable.include_matchers!(Remarkable::ActionController, RSpec::Rails::ControllerExampleGroup)
+  Remarkable.include_matchers!(Remarkable::ActionController, RSpec::Rails::RoutingExampleGroup)
+end
+

data/lib/remarkable_rails/action_controller/base.rb

@@ -0,0 +1,31 @@
+module Remarkable
+  module ActionController
+    class Base < Remarkable::Base
+
+      before_assert :perform_action_with_macro_stubs
+
+      optional :with_expectations, :default => true
+      optional :with_stubs,        :default => true
+
+      protected
+
+        # Before assertions, call run_action! to perform the action if it was
+        # not performed yet.
+        #
+        def perform_action_with_macro_stubs #:nodoc:
+          @spec.send(:run_action!, run_with_expectations?) if @spec.send(:controller)
+        end
+
+        def run_with_expectations? #:nodoc:
+          if @options.key?(:with_stubs)
+            !@options[:with_stubs]
+          elsif @options.key?(:with_expectations)
+            @options[:with_expectations]
+          else
+            true
+          end
+        end
+
+    end
+  end
+end

data/lib/remarkable_rails/action_controller/macro_stubs.rb

@@ -0,0 +1,594 @@
+module RSpec
+  module Core
+
+    # This is a hack that we need to run the alias method chain describe
+    class Metadata < Hash
+      def first_caller_from_outside_rspec_from_caller(list)
+        list.detect {|l| l !~ /(\/lib\/rspec\/core)|remarkable_rails/}
+      end
+    end
+
+    # Macro stubs makes stubs and expectations easier, more readable and DRY.
+    #
+    # == Example
+    #
+    # Let's jump off to an example:
+    #
+    #   describe ProjectsController do
+    #     describe :get => :show, :id => 37 do
+    #       expects :find, :on => Project, :with => '37', :returns => proc { mock_project }
+    #
+    #       should_assign_to :project, :with => proc { mock_project }
+    #       should_render_template 'show'
+    #
+    #       describe Mime::XML do
+    #         should_assign_to :project
+    #         should_respond_with_content_type Mime::XML
+    #       end
+    #     end
+    #   end
+    #
+    # See how the spec is readable: a ProjectsController responding to get show
+    # expects :find on Project which a mock project and then should assign to
+    # project and render template 'show'.
+    #
+    # Each macro before asserting will check if an action was already performed and
+    # if not, it runs the expectations and call the action.
+    #
+    # In other words, should assign to macro is basically doing:
+    #
+    #   it 'should assign to project' do
+    #     Project.should_receive(:find).with('37').and_return(mock_project)
+    #     get :show, :id => '37'
+    #     assigns(:project).should == mock_project
+    #   end
+    #
+    # By default, all macros perform expectations. You can change
+    # this behavior sending :with_stubs or :with_expectations as options:
+    #
+    #   should_assign_to       :project, :with_stubs => true
+    #   should_render_template 'show', :with_expectations => false
+    #
+    # This also works in the rspec way:
+    #
+    #   it { should assign_to(:project).with_stubs                   }
+    #   it { should render_template('show').with_expectations(false) }
+    #
+    # == Attention!
+    #
+    # If you need to check that an array is being sent to a method, you need to
+    # give an array inside another array, for example:
+    #
+    #   expects :comment_ids=, :on => Post, :with => [1,2,3]
+    #
+    # Is the same as:
+    #
+    #   Post.comment_ids = (1, 2, 3)
+    #
+    # And it won't work. The right way to handle this is:
+    #
+    #   expects :comment_ids=, :on => Post, :with => [[1,2,3]]
+    #
+    # == mock_models
+    #
+    # You don't have to play with proc all the time. You can call mock_models which
+    # creates two class methods that simply returns a proc and a instance method that
+    # do the actual mock.
+    #
+    #   describe ProjectsController do
+    #     mock_models :project
+    #
+    # And it creates:
+    #
+    #   def self.project_proc
+    #     proc { mock_project }
+    #   end
+    #
+    #   # To be used on index actions
+    #   def self.projects_proc
+    #     proc { [mock_project] }
+    #   end
+    #
+    #   def mock_project(stubs={})
+    #     @project ||= mock_model(Project, stubs)
+    #   end
+    #
+    # Then you can replace those lines:
+    #
+    #    expects :find, :on => Project, :with => '37', :returns => proc { mock_project }
+    #    should_assign_to :project, :with => proc { mock_project }
+    #
+    # For:
+    #
+    #    expects :find, :on => Project, :with => '37', :returns => project_proc
+    #    should_assign_to :project, :with => project_proc
+    #
+    # = Give me more!
+    #
+    # If you need to set the example group description, you can also call <tt>get</tt>,
+    # <tt>post</tt>, <tt>put</tt> and <tt>delete</tt> methods:
+    #
+    #   describe 'my description' do
+    #     get :show, :id => 37
+    #
+    # Things start to get even better when we start to talk about nested resources.
+    # After our ProjectsController is created, we want to create a TasksController:
+    #
+    #   describe TasksController do
+    #     params :project_id => '42' #=> define params for all requests
+    #
+    #     # Those two expectations get inherited in all describe groups below
+    #     expects :find_by_title, :on => Project, :with => '42', :returns => project_proc
+    #     expects :tasks, :and_return => Task
+    #
+    #     describe :get => :show, :id => '37' do
+    #       expects :find, :with => '37', :and_return => task_proc
+    #
+    #       should_assign_to :project, :task
+    #       should_render_template 'show'
+    #     end
+    #   end
+    #
+    # As you noticed, you can define parameters that will be available to all requests,
+    # using the method <tt>params</tt>.
+    #
+    # Finally if you need to write a spec by hand, you can invoke the action and
+    # expectations with run_action!, run_expectations! and run_stubs!. Examples:
+    #
+    #   describe :get => :new do
+    #     expects :new, :on => Project, :returns => project_proc
+    #
+    #     it "should do something different" do
+    #       run_action!
+    #       # do you assertions here
+    #     end
+    #   end
+    #
+    # = Performance!
+    #
+    # Remarkable comes with a new way to speed up your tests. It performs the
+    # action inside a before(:all), so you can do:
+    #
+    #   describe "responding to GET show" do
+    #     get! :show, :id => 37
+    #
+    #     should_assign_to :task
+    #     should_render_template :show
+    #   end
+    #
+    # Or in the compact way:
+    #
+    #   describe :get! => :show, :id => 37
+    #
+    # The action will be performed just once before running the macros. If any
+    # error happens while performing the action, rspec will output an error
+    # but ALL the examples inside the example group (describe) won't be run.
+    #
+    # By now, the bang methods works only when integrate_views is true and this
+    # is when you must see a bigger performance gain.
+    #
+    # This feature comes with some rspec and rspec rails tweakings. So if you want
+    # to do something before the action is performed (stubs something or log
+    # someone in session), you have to do it giving a block to the action method:
+    #
+    #   get! :show, :id => 37 do
+    #     login_as(mock_user)
+    #   end
+    #
+    # You can still use the compact way and give the block:
+    #
+    #   describe :get => :show, :id => 37 do
+    #     get! do
+    #       login_as(mock_user)
+    #     end
+    #   end
+    #
+    class ExampleGroup
+      HTTP_VERBS_METHODS = [:get, :get!, :post, :post!, :put, :put!, :delete, :delete!]
+
+      class_inheritable_reader :expects_chain, :default_action, :default_mime,
+        :default_verb, :default_params, :default_xhr,
+        :before_all_block
+
+      module NewClassMethods
+
+        # Creates a chain that will be evaluated as stub or expectation. The
+        # first parameter is the method expected. You can also specify multiple
+        # methods to stub and give a block to calculate the returned value. See
+        # examples below.
+        #
+        # == Options
+        #
+        # * <tt>:on</tt> - Tell which object will receive the expected method.
+        #   This option is always required.
+        #
+        # * <tt>:with</tt> - Tell each parameters will be sent with the expected
+        #   method. This option is used only in expectations and is optional.
+        #
+        # * <tt>:returns</tt> - Tell what the expectations should return. Not
+        #   required.
+        #
+        # * <tt>:times</tt> - The number of times the object will receive the
+        #   method. Used only in expectations and when not given, defaults to 1.
+        #
+        # * <tt>:ordered</tt> - When true specifies that expectations should
+        #   be received in order.
+        #
+        # == Example
+        #
+        #   expects :new, :on => Project, :returns => :project_proc, :times => 2
+        #
+        #   expects :new, :find, :on => Project, :returns => :project_proc
+        #
+        #   expects :human_attribute_name, :on => Project, :with => :title do |attr|
+        #     attr.to_s.humanize
+        #   end
+        #
+        def expects(*args, &block)
+          options = args.extract_options!
+          options.assert_valid_keys(:on, :with, :returns, :times, :ordered)
+
+          args.each do |arg|
+            write_inheritable_array(:expects_chain, [ [ arg, options, block] ])
+          end
+        end
+
+        # The mime type of the request. The value given will be called transformed
+        # into a string and set in the @request.env['HTTP_ACCEPT'] variable.
+        #
+        # == Examples
+        #
+        #   mime Mime::XML
+        #   mime 'application/xml+rss'
+        #
+        def mime(mime)
+          write_inheritable_attribute(:default_mime, mime.to_s)
+        end
+
+        # The params used for the request. Calls are always nested:
+        #
+        # == Examples
+        #
+        #   describe TasksController do
+        #     params :project_id => 42
+        #
+        #     describe :get => :show, :id => 37 do
+        #       # will request with params {:id => 37, :project_id => 42}
+        #     end
+        #   end
+        #
+        def params(params)
+          write_inheritable_hash(:default_params, params)
+        end
+
+        # Sets the request to perform a XmlHttpRequest.
+        #
+        # == Examples
+        #
+        #   describe TasksController do
+        #     xhr!
+        #   end
+        #
+        def xhr!(bool=true)
+          write_inheritable_attribute(:default_xhr, bool)
+        end
+
+        [:get, :post, :put, :delete].each do |verb|
+          module_eval <<-VERB, __FILE__, __LINE__
+            # Declares that we want to do a #{verb} request in the given action
+            # and with the given params.
+            #
+            # == Examples
+            #
+            #   #{verb} :action, :id => 42
+            #
+            def #{verb}(action, params={})
+              params(params)
+              write_inheritable_attribute(:default_verb, #{verb.inspect})
+              write_inheritable_attribute(:default_action, action)
+            end
+          VERB
+        end
+
+        [:get!, :post!, :put!, :delete!].each do |verb|
+          module_eval <<-VERB, __FILE__, __LINE__
+            # Declares that we want to do a #{verb} request in the given action
+            # and with the given params, but the action is performed just once
+            # in the describe group. In other words, it's performed in a
+            # before(:all) filter.
+            #
+            # == Examples
+            #
+            #   #{verb} :action, :id => 42
+            #
+            def #{verb}(action=nil, params={}, &block)
+              #{verb.to_s.chop}(action, params) if action
+              write_inheritable_array(:before_all_block, [block]) if block
+              run_callbacks_once!
+            end
+          VERB
+        end
+
+        # Undefine the method run_callbacks so rspec won't run them in the
+        # before and after :each cycle. Then we redefine it as run_callbacks_once,
+        # which will be used as an before(:all) and after(:all) filter.
+        #
+        def run_callbacks_once!(&block) #:nodoc:
+          unless instance_methods.any?{|m| m.to_s == 'run_callbacks_once' }
+            alias_method :run_callbacks_once, :run_callbacks
+            class_eval "def run_callbacks(*args); end"
+
+            before(:all) do
+              setup_mocks_for_rspec
+              run_callbacks_once :setup
+
+              before_all_block.each do |block|
+                instance_eval(&block)
+              end if before_all_block
+
+              run_action!
+              verify_mocks_for_rspec
+              teardown_mocks_for_rspec
+            end
+
+            after(:all) do
+              run_callbacks_once :teardown
+            end
+          end
+        end
+
+        # Overwrites describe to provide quick action description with I18n.
+        #
+        # You can now do:
+        #
+        #   describe :get => :show, :id => 37
+        #
+        # Which is the same as:
+        #
+        #   describe 'responding to #GET show' do
+        #     get :show, :id => 37
+        #
+        # And do this:
+        #
+        #   describe Mime::XML
+        #
+        # Which is the same as:
+        #
+        #   describe 'with xml' do
+        #     mime Mime::XML
+        #
+        # The string can be localized using I18n. An example yml file is:
+        #
+        #   locale:
+        #     remarkable:
+        #       action_controller:
+        #         responding: "responding to #{{verb}} {{action}}"
+        #         mime_type: "with {{format}} ({{content_type}})"
+        #
+        # And load the locale file with:
+        #
+        #   Remarkable.add_locale locale_path
+        #
+
+
+        def describe_with_verb_params(*args, &block)
+          options = args.first.is_a?(Hash) ? args.first : {}
+          verb    = (options.keys & HTTP_VERBS_METHODS).first
+
+          if verb
+            action = options.delete(verb)
+            verb   = verb.to_s
+
+            description = Remarkable.t 'remarkable.action_controller.responding',
+                                        :default => "responding to \#{{verb}} {{action}}",
+                                        :verb => verb.sub('!', '').upcase, :action => action
+
+            send_args = [ verb, action, options ]
+          elsif args.first.is_a?(Mime::Type)
+            mime = args.first
+
+            description = Remarkable.t 'remarkable.action_controller.mime_type',
+                                        :default => "with #{mime.to_sym}",
+                                        :format => mime.to_sym, :content_type => mime.to_s
+
+            send_args = [ :mime, mime ]
+          else # return if no special type was found
+            return describe_without_verb_params(*args, &block)
+          end
+
+          args.shift
+          args.unshift(description)
+
+          # Creates an example group, send the method and eval the given block.
+          #
+          example_group = describe_without_verb_params(*args) do
+            send(*send_args)
+            instance_eval(&block)
+          end
+        end
+
+        
+        # Creates mock methods automatically.
+        #
+        # == Options
+        #
+        # * <tt>:as</tt> -  Used to set the model . For example, if you have
+        #   Admin::Task model, you have to tell the name of the class to be
+        #   mocked:
+        #
+        #      mock_models :admin_task, :as => "Admin::Task"
+        #
+        # * <tt>:class_method</tt> - When set to false, does not create the
+        #   class method which returns a proc.
+        #
+        # == Examples
+        #
+        # Doing this:
+        #
+        #   describe ProjectsController do
+        #     mock_models :project
+        #   end
+        #
+        # Will create one instance and two class mock methods for you:
+        #
+        #   def self.project_proc
+        #     proc { mock_project }
+        #   end
+        #
+        #   # To be used on index actions
+        #   def self.projects_procs
+        #     proc { [ mock_project ] }
+        #   end
+        #
+        #   def mock_project(stubs={})
+        #     @project ||= mock_model(Project, stubs)
+        #   end
+        #
+        # If you want to create just the instance method, you can give
+        # :class_method => false as option.
+        #
+        def mock_models(*models)
+          options = models.extract_options!
+          options = { :class_method => true }.merge(options)
+
+          models.each do |model|
+            model = model.to_s
+            klass = options[:as] || model.classify
+
+            if options[:class_method]
+              (class << self; self; end).class_eval <<-METHOD
+                def #{model}_proc; proc { mock_#{model} }; end
+                def #{model.pluralize}_proc; proc { [ mock_#{model} ] }; end
+
+                alias :mock_#{model} :#{model}_proc
+                alias :mock_#{model.pluralize} :#{model.pluralize}_proc
+              METHOD
+            end
+
+            self.class_eval <<-METHOD
+              def mock_#{model}(stubs={})
+                @#{model} ||= mock_model(#{klass}, stubs)
+              end
+            METHOD
+          end
+        end
+        alias :mock_model :mock_models
+
+      end
+
+      protected
+
+        # Evaluates the expectation chain as stub or expectations.
+        #
+        def evaluate_expectation_chain(use_expectations=true) #:nodoc:
+          return if self.expects_chain.nil?
+
+          self.expects_chain.each do |method, options, block|
+            object = evaluate_value(options[:on])
+            raise ScriptError, "You have to give me :on as an option when calling :expects." if object.nil?
+
+            if use_expectations
+              chain = object.should_receive(method)
+
+              if options.key?(:with)
+                with = evaluate_value(options[:with])
+
+                chain = if with.is_a?(Array)
+                  chain.with(*with)
+                else
+                  chain.with(with)
+                end
+              end
+
+              times = options[:times] || 1
+              chain = chain.exactly(times).times
+
+              chain = chain.ordered if options[:ordered]
+            else
+              chain = object.stub!(method)
+            end
+
+            chain = if block
+              chain.and_return(&block)
+            else
+              return_value = evaluate_value(options[:returns])
+              chain.and_return(return_value)
+            end
+          end
+        end
+
+        # Instance method run_stubs! if someone wants to declare additional
+        # tests and call the stubs inside of it.
+        #
+        def run_stubs!
+          evaluate_expectation_chain(false)
+        end
+
+        # Instance method run_expectations! if someone wants to declare
+        # additional tests and call the stubs inside of it.
+        #
+        def run_expectations!
+          evaluate_expectation_chain(true)
+        end
+
+        # Run the action declared in the describe group, but before runs also
+        # the expectations. If an action was already performed, it doesn't run
+        # anything at all and returns false.
+        #
+        # The first parameter is if you want to run expectations or stubs. You
+        # can also supply the verb (get, post, put or delete), which action to
+        # call, parameters, the mime type and if a xhr should be performed. If
+        # any of those parameters are supplied, they override the current
+        # definition.
+        #
+        def run_action!(use_expectations=true, verb=nil, action=nil, params=nil, mime=nil, xhr=nil)
+          return false if controller.send(:performed?)
+
+          evaluate_expectation_chain(use_expectations)
+
+          mime   ||= default_mime
+          verb   ||= default_verb
+          action ||= default_action
+          params ||= default_params
+          xhr    ||= default_xhr
+
+          parent = self.class.parent
+          until mime || verb || action || params || xhr
+            mime   ||= parent.default_mime
+            verb   ||= parent.default_verb
+            action ||= parent.default_action
+            params ||= parent.default_params
+            xhr    ||= parent.default_xhr
+            parent = parent.parent
+          end
+
+          raise ScriptError, "No action was performed or declared." unless verb && action
+
+          request.env["HTTP_ACCEPT"] ||= mime.to_s                if mime
+          request.env['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest' if xhr
+          send(verb, action, params)
+        end
+
+        # Evaluate a given value.
+        #
+        # This allows procs to be given to the expectation chain and they will
+        # be evaluated in the instance binding.
+        #
+        def evaluate_value(duck) #:nodoc:
+          if duck.is_a?(Proc)
+            self.instance_eval(&duck)
+          elsif duck.is_a?(Array)
+            duck.map{|child_duck| evaluate_value(child_duck) }
+          else
+            duck
+          end
+        end
+
+      extend NewClassMethods
+      class << self
+        alias_method :describe_without_verb_params, :describe
+        alias_method :describe, :describe_with_verb_params
+      end
+    end
+  end
+end