actionpack 1.13.6 → 2.0.0

data/lib/action_controller/templates/rescues/_request_and_response.erb

@@ -0,0 +1,24 @@
+<% unless @exception.blamed_files.blank? %>
+  <% if (hide = @exception.blamed_files.length > 8) %>
+    <a href="#" onclick="document.getElementById('blame_trace').style.display='block'; return false;">Show blamed files</a>
+  <% end %>
+  <pre id="blame_trace" <%='style="display:none"' if hide %>><code><%=h @exception.describe_blame %></code></pre>
+<% end %>
+
+<%
+  clean_params = request.parameters.clone
+  clean_params.delete("action")
+  clean_params.delete("controller")
+
+  request_dump = clean_params.empty? ? 'None' : clean_params.inspect.gsub(',', ",\n")
+%>
+
+<h2 style="margin-top: 30px">Request</h2>
+<p><b>Parameters</b>: <pre><%=h request_dump %></pre></p>
+
+<p><a href="#" onclick="document.getElementById('session_dump').style.display='block'; return false;">Show session dump</a></p>
+<div id="session_dump" style="display:none"><%= debug(request.session.instance_variable_get("@data")) %></div>
+
+
+<h2 style="margin-top: 30px">Response</h2>
+<p><b>Headers</b>: <pre><%=h response ? response.headers.inspect.gsub(',', ",\n") : 'None' %></pre></p>

data/lib/action_controller/templates/rescues/{diagnostics.rhtml → diagnostics.erb}

@@ -6,6 +6,6 @@
 </h1>
 <pre><%=h @exception.clean_message %></pre>
 
-<%= render_file(@rescues_path + "/_trace.rhtml", false) %>
+<%= render_file(@rescues_path + "/_trace.erb", false) %>
 
-<%= render_file(@rescues_path + "/_request_and_response.rhtml", false) %>
+<%= render_file(@rescues_path + "/_request_and_response.erb", false) %>

data/lib/action_controller/templates/rescues/{template_error.rhtml → template_error.erb}

@@ -15,7 +15,7 @@
 
 <% @real_exception = @exception
    @exception = @exception.original_exception || @exception %>
-<%= render_file(@rescues_path + "/_trace.rhtml", false) %>
+<%= render_file(@rescues_path + "/_trace.erb", false) %>
 <% @exception = @real_exception %>
 
-<%= render_file(@rescues_path + "/_request_and_response.rhtml", false) %>
+<%= render_file(@rescues_path + "/_request_and_response.erb", false) %>

data/lib/action_controller/test_case.rb

@@ -0,0 +1,53 @@
+require 'active_support/test_case'
+
+module ActionController
+  class NonInferrableControllerError < ActionControllerError
+    def initialize(name)
+      super "Unable to determine the controller to test from #{name}. " +
+        "You'll need to specify it using 'tests YourController' in your " +
+        "test case definition"
+    end
+  end
+
+  class TestCase < ActiveSupport::TestCase
+    @@controller_class = nil
+    class << self
+      def tests(controller_class)
+        self.controller_class = controller_class
+      end
+
+      def controller_class=(new_class)
+        prepare_controller_class(new_class)
+        write_inheritable_attribute(:controller_class, new_class)
+      end
+
+      def controller_class
+        if current_controller_class = read_inheritable_attribute(:controller_class)
+          current_controller_class
+        else
+          self.controller_class= determine_default_controller_class(name)
+        end
+      end
+
+      def determine_default_controller_class(name)
+        name.sub(/Test$/, '').constantize
+      rescue NameError
+        raise NonInferrableControllerError.new(name)
+      end
+
+      def prepare_controller_class(new_class)
+        new_class.class_eval do
+          def rescue_action(e)
+            raise e
+          end
+        end
+      end
+    end
+
+    def setup
+      @controller = self.class.controller_class.new
+      @request    = TestRequest.new
+      @response   = TestResponse.new
+    end
+  end
+end

data/lib/action_controller/test_process.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/assertions'
+require 'action_controller/assertions'
 
 module ActionController #:nodoc:
   class Base
@@ -23,8 +23,7 @@ module ActionController #:nodoc:
   class TestRequest < AbstractRequest #:nodoc:
     attr_accessor :cookies, :session_options
     attr_accessor :query_parameters, :request_parameters, :path, :session, :env
-    attr_accessor :host
-    attr_reader   :request_uri_overridden
+    attr_accessor :host, :user_agent
 
     def initialize(query_parameters = nil, request_parameters = nil, session = nil)
       @query_parameters   = query_parameters || {}
@@ -41,18 +40,15 @@ module ActionController #:nodoc:
       @session = TestSession.new
     end
 
+    # Wraps raw_post in a StringIO.
+    def body
+      StringIO.new(raw_post)
+    end
+
+    # Either the RAW_POST_DATA environment variable or the URL-encoded request
+    # parameters.
     def raw_post
-      if raw_post = env['RAW_POST_DATA']
-        raw_post
-      else
-        params = self.request_parameters.dup
-        %w(controller action only_path).each do |k|
-          params.delete(k)
-          params.delete(k.to_sym)
-        end
-    
-        params.map { |k,v| [ CGI.escape(k.to_s), CGI.escape(v.to_s) ].join('=') }.sort.join('&')
-      end
+      env['RAW_POST_DATA'] ||= url_encoded_request_parameters
     end
 
     def port=(number)
@@ -68,14 +64,12 @@ module ActionController #:nodoc:
     # Used to check AbstractRequest's request_uri functionality.
     # Disables the use of @path and @request_uri so superclass can handle those.
     def set_REQUEST_URI(value)
-      @request_uri_overridden = true
       @env["REQUEST_URI"] = value
       @request_uri = nil
       @path = nil
     end
 
     def request_uri=(uri)
-      @env["REQUEST_URI"] = uri
       @request_uri = uri
       @path = uri.split("?").first
     end
@@ -93,11 +87,11 @@ module ActionController #:nodoc:
     end
 
     def request_uri
-      @request_uri || super()
+      @request_uri || super
     end
 
     def path
-      @path || super()
+      @path || super
     end
 
     def assign_parameters(controller_path, action, parameters)
@@ -127,6 +121,10 @@ module ActionController #:nodoc:
       @request_method, @accepts, @content_type = nil, nil, nil
     end    
 
+    def referer
+      @env["HTTP_REFERER"]
+    end
+
     private
       def initialize_containers
         @env, @cookies = {}, {}
@@ -135,10 +133,22 @@ module ActionController #:nodoc:
       def initialize_default_values
         @host                    = "test.host"
         @request_uri             = "/"
+        @user_agent              = "Rails Testing"
         self.remote_addr         = "0.0.0.0"        
         @env["SERVER_PORT"]      = 80
         @env['REQUEST_METHOD']   = "GET"
       end
+
+      def url_encoded_request_parameters
+        params = self.request_parameters.dup
+
+        %w(controller action only_path).each do |k|
+          params.delete(k)
+          params.delete(k.to_sym)
+        end
+
+        params.to_query
+      end
   end
 
   # A refactoring of TestResponse to allow the same behavior to be applied
@@ -260,13 +270,7 @@ module ActionController #:nodoc:
       require 'stringio'
 
       sio = StringIO.new
-
-      begin 
-        $stdout = sio
-        body.call
-      ensure
-        $stdout = STDOUT
-      end
+      body.call(self, sio)
 
       sio.rewind
       sio.read
@@ -320,33 +324,37 @@ module ActionController #:nodoc:
   #
   # Usage example, within a functional test:
   #   post :change_avatar, :avatar => ActionController::TestUploadedFile.new(Test::Unit::TestCase.fixture_path + '/files/spongebob.png', 'image/png')
+  # 
+  # Pass a true third parameter to ensure the uploaded file is opened in binary mode (only required for Windows):
+  #   post :change_avatar, :avatar => ActionController::TestUploadedFile.new(Test::Unit::TestCase.fixture_path + '/files/spongebob.png', 'image/png', :binary)
   require 'tempfile'
   class TestUploadedFile
     # The filename, *not* including the path, of the "uploaded" file
     attr_reader :original_filename
-    
+
     # The content type of the "uploaded" file
     attr_reader :content_type
-    
-    def initialize(path, content_type = 'text/plain')
+
+    def initialize(path, content_type = Mime::TEXT, binary = false)
       raise "#{path} file does not exist" unless File.exist?(path)
       @content_type = content_type
       @original_filename = path.sub(/^.*#{File::SEPARATOR}([^#{File::SEPARATOR}]+)$/) { $1 }
       @tempfile = Tempfile.new(@original_filename)
+      @tempfile.binmode if binary
       FileUtils.copy_file(path, @tempfile.path)
     end
-    
+
     def path #:nodoc:
       @tempfile.path
     end
-    
+
     alias local_path path
-    
+
     def method_missing(method_name, *args, &block) #:nodoc:
-      @tempfile.send(method_name, *args, &block)
+      @tempfile.send!(method_name, *args, &block)
     end
   end
-  
+
   module TestProcess
     def self.included(base)
       # execute the request simulating a specific http method and set/volley the response
@@ -365,7 +373,7 @@ module ActionController #:nodoc:
       # Sanity check for required instance variables so we can give an
       # understandable error message.
       %w(@controller @request @response).each do |iv_name|
-        if !instance_variables.include?(iv_name) || instance_variable_get(iv_name).nil?
+        if !(instance_variables.include?(iv_name) || instance_variables.include?(iv_name.to_sym)) || instance_variable_get(iv_name).nil?
           raise "#{iv_name} is nil: make sure you set it in your test's setup method."
         end
       end
@@ -388,7 +396,7 @@ module ActionController #:nodoc:
     def xml_http_request(request_method, action, parameters = nil, session = nil, flash = nil)
       @request.env['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
       @request.env['HTTP_ACCEPT'] = 'text/javascript, text/html, application/xml, text/xml, */*'
-      returning self.send(request_method, action, parameters, session, flash) do
+      returning send!(request_method, action, parameters, session, flash) do
         @request.env.delete 'HTTP_X_REQUESTED_WITH'
         @request.env.delete 'HTTP_ACCEPT'
       end
@@ -429,17 +437,18 @@ module ActionController #:nodoc:
     end
 
     def build_request_uri(action, parameters)
-      unless @request.request_uri_overridden
-        options = @controller.send(:rewrite_options, parameters)
+      unless @request.env['REQUEST_URI']
+        options = @controller.send!(:rewrite_options, parameters)
         options.update(:only_path => true, :action => action)
 
         url = ActionController::UrlRewriter.new(@request, parameters)
-        @request.request_uri = url.rewrite(options)
+        @request.set_REQUEST_URI(url.rewrite(options))
       end
     end
 
     def html_document
-      @html_document ||= HTML::Document.new(@response.body)
+      xml = @response.content_type =~ /xml$/
+      @html_document ||= HTML::Document.new(@response.body, false, xml)
     end
 
     def find_tag(conditions)
@@ -451,16 +460,20 @@ module ActionController #:nodoc:
     end
 
     def method_missing(selector, *args)
-      return @controller.send(selector, *args) if ActionController::Routing::Routes.named_routes.helpers.include?(selector)
+      return @controller.send!(selector, *args) if ActionController::Routing::Routes.named_routes.helpers.include?(selector)
       return super
     end
     
     # Shortcut for ActionController::TestUploadedFile.new(Test::Unit::TestCase.fixture_path + path, type). Example:
     #   post :change_avatar, :avatar => fixture_file_upload('/files/spongebob.png', 'image/png')
-    def fixture_file_upload(path, mime_type = nil)
+    #
+    # To upload binary files on Windows, pass :binary as the last parameter. This will not affect other platforms.
+    #   post :change_avatar, :avatar => fixture_file_upload('/files/spongebob.png', 'image/png', :binary)
+    def fixture_file_upload(path, mime_type = nil, binary = false)
       ActionController::TestUploadedFile.new(
         Test::Unit::TestCase.respond_to?(:fixture_path) ? Test::Unit::TestCase.fixture_path + path : path, 
-        mime_type
+        mime_type,
+        binary
       )
     end
 
@@ -483,15 +496,15 @@ module ActionController #:nodoc:
     #
     def with_routing
       real_routes = ActionController::Routing::Routes
-      ActionController::Routing.send :remove_const, :Routes
+      ActionController::Routing.module_eval { remove_const :Routes }
 
       temporary_routes = ActionController::Routing::RouteSet.new
-      ActionController::Routing.send :const_set, :Routes, temporary_routes
-  
+      ActionController::Routing.module_eval { const_set :Routes, temporary_routes }
+
       yield temporary_routes
     ensure
       if ActionController::Routing.const_defined? :Routes
-        ActionController::Routing.send(:remove_const, :Routes) 
+        ActionController::Routing.module_eval { remove_const :Routes }
       end
       ActionController::Routing.const_set(:Routes, real_routes) if real_routes
     end

data/lib/action_controller/url_rewriter.rb

@@ -1,5 +1,4 @@
-module ActionController
-  
+module ActionController  
   # Write URLs from arbitrary places in your codebase, such as your mailers.
   # 
   # Example:
@@ -15,59 +14,71 @@ module ActionController
   # 
   # In addition to providing +url_for+, named routes are also accessible after
   # including UrlWriter.
-  # 
   module UrlWriter
-    
     # The default options for urls written by this writer. Typically a :host pair
     # is provided.
     mattr_accessor :default_url_options
     self.default_url_options = {}
     
     def self.included(base) #:nodoc:
-      ActionController::Routing::Routes.named_routes.install base
+      ActionController::Routing::Routes.install_helpers base 
       base.mattr_accessor :default_url_options
       base.default_url_options ||= default_url_options
     end
     
-    # Generate a url with the provided options. The following special options may
-    # effect the constructed url:
+    # Generate a url based on the options provided, default_url_options and the 
+    # routes defined in routes.rb.  The following options are supported:
+    # 
+    # * <tt>:only_path</tt> If true, the relative url is returned. Defaults to false.
+    # * <tt>:protocol</tt> The protocol to connect to. Defaults to 'http'.
+    # * <tt>:host</tt> Specifies the host the link should be targetted at. If <tt>:only_path</tt> is false, this option must be 
+    #   provided either explicitly, or via default_url_options. 
+    # * <tt>:port</tt> Optionally specify the port to connect to.
+    # * <tt>:anchor</tt> An anchor name to be appended to the path.
+    # 
+    # Any other key(:controller, :action, etc...) given to <tt>url_for</tt> is forwarded to the Routes module.
     # 
-    #   * :host Specifies the host the link should be targetted at. This option
-    #     must be provided either explicitly, or via default_url_options.
-    #   * :protocol The protocol to connect to. Defaults to 'http'
-    #   * :port Optionally specify the port to connect to.
+    # Examples:
+    # 
+    #    url_for :controller => 'tasks', :action => 'testing', :host=>'somehost.org', :port=>'8080'    # => 'http://somehost.org:8080/tasks/testing'
+    #    url_for :controller => 'tasks', :action => 'testing', :host=>'somehost.org', :anchor => 'ok', :only_path => true    # => '/tasks/testing#ok'
+    #    url_for :controller => 'tasks', :action => 'testing', :host=>'somehost.org', :number => '33'  # => 'http://somehost.org/tasks/testing?number=33'
     # 
     def url_for(options)
       options = self.class.default_url_options.merge(options)
       
       url = ''
+
       unless options.delete :only_path
         url << (options.delete(:protocol) || 'http')
-        url << '://'
+        url << '://' unless url.match("://") #dont add separator if its already been specified in :protocol 
         
         raise "Missing host to link to! Please provide :host parameter or set default_url_options[:host]" unless options[:host]
+
         url << options.delete(:host)
         url << ":#{options.delete(:port)}" if options.key?(:port)
       else
         # Delete the unused options to prevent their appearance in the query string
         [:protocol, :host, :port].each { |k| options.delete k }
       end
-      anchor = "##{options.delete(:anchor)}" if options.key?(:anchor)
+
+      anchor = "##{CGI.escape options.delete(:anchor).to_param.to_s}" if options.key?(:anchor)
       url << Routing::Routes.generate(options, {})
-      return "#{url}#{anchor}"
-    end
-    
+      url << anchor if anchor
+
+      return url
+    end    
   end
   
   # Rewrites URLs for Base.redirect_to and Base.url_for in the controller.
   class UrlRewriter #:nodoc:
-    RESERVED_OPTIONS = [:anchor, :params, :only_path, :host, :protocol, :trailing_slash, :skip_relative_url_root]
+    RESERVED_OPTIONS = [:anchor, :params, :only_path, :host, :protocol, :port, :trailing_slash, :skip_relative_url_root]
     def initialize(request, parameters)
       @request, @parameters = request, parameters
     end
     
     def rewrite(options = {})
-      rewrite_url(rewrite_path(options), options)
+      rewrite_url(options)
     end
 
     def to_str
@@ -78,16 +89,20 @@ module ActionController
 
     private
       # Given a path and options, returns a rewritten URL string
-      def rewrite_url(path, options)
+      def rewrite_url(options)
         rewritten_url = ""
+
         unless options[:only_path]
           rewritten_url << (options[:protocol] || @request.protocol)
+          rewritten_url << "://" unless rewritten_url.match("://")
+          rewritten_url << rewrite_authentication(options)
           rewritten_url << (options[:host] || @request.host_with_port)
+          rewritten_url << ":#{options.delete(:port)}" if options.key?(:port)
         end
 
+        path = rewrite_path(options)
         rewritten_url << @request.relative_url_root.to_s unless options[:skip_relative_url_root]
-        rewritten_url << path
-        rewritten_url << '/' if options[:trailing_slash]
+        rewritten_url << (options[:trailing_slash] ? path.sub(/\?|\z/) { "/" + $& } : path)
         rewritten_url << "##{options[:anchor]}" if options[:anchor]
 
         rewritten_url
@@ -97,15 +112,24 @@ module ActionController
       def rewrite_path(options)
         options = options.symbolize_keys
         options.update(options[:params].symbolize_keys) if options[:params]
+
         if (overwrite = options.delete(:overwrite_params))
           options.update(@parameters.symbolize_keys)
-          options.update(overwrite)
+          options.update(overwrite.symbolize_keys)
         end
-        RESERVED_OPTIONS.each {|k| options.delete k}
+
+        RESERVED_OPTIONS.each { |k| options.delete(k) }
 
         # Generates the query string, too
         Routing::Routes.generate(options, @request.symbolized_path_parameters)
       end
+      
+      def rewrite_authentication(options)
+        if options[:user] && options[:password]
+          "#{CGI.escape(options.delete(:user))}:#{CGI.escape(options.delete(:password))}@"
+        else
+          ""
+        end
+      end
   end
-  
 end