actionpack 1.4.0 → 1.5.0

data/lib/action_controller/base.rb

@@ -1,9 +1,10 @@
 require 'action_controller/request'
 require 'action_controller/response'
+require 'action_controller/routing'
 require 'action_controller/url_rewriter'
-require 'action_controller/support/class_attribute_accessors'
-require 'action_controller/support/class_inheritable_attributes'
-require 'action_controller/support/inflector'
+require 'active_support/class_attribute_accessors'
+require 'active_support/class_inheritable_attributes'
+require 'active_support/inflector'
 require 'drb'
 
 module ActionController #:nodoc:
@@ -13,6 +14,15 @@ module ActionController #:nodoc:
   end
   class MissingTemplate < ActionControllerError #:nodoc:
   end
+  class RoutingError < ActionControllerError#:nodoc:
+    attr_reader :failures
+    def initialize(message, failures=[])
+      super(message)
+      @failures = failures
+    end
+  end
+  class UnknownController < ActionControllerError #:nodoc:
+  end
   class UnknownAction < ActionControllerError #:nodoc:
   end
   class MissingFile < ActionControllerError #:nodoc:
@@ -76,9 +86,9 @@ module ActionController #:nodoc:
   #   <input type="text" name="post[name]" value="david">
   #   <input type="text" name="post[address]" value="hyacintvej">
   #
-  # A request stemming from a form holding these inputs will include { "post" # => { "name" => "david", "address" => "hyacintvej" } }.
+  # A request stemming from a form holding these inputs will include <tt>{ "post" => { "name" => "david", "address" => "hyacintvej" } }</tt>.
   # If the address input had been named "post[address][street]", the @params would have included 
-  # { "post" => { "address" => { "street" => "hyacintvej" } } }. There's no limit to the depth of the nesting.
+  # <tt>{ "post" => { "address" => { "street" => "hyacintvej" } } }</tt>. There's no limit to the depth of the nesting.
   #
   # == Sessions
   #
@@ -146,22 +156,20 @@ module ActionController #:nodoc:
   # 
   # Redirects work by rewriting the URL of the current action. So if the show action was called by "/library/books/ISBN/0743536703/show", 
   # we can redirect to an edit action simply by doing <tt>redirect_to(:action => "edit")</tt>, which could throw the user to 
-  # "/library/books/ISBN/0743536703/edit". Naturally, you'll need to setup the .htaccess (or other means of URL rewriting for the web server)
-  # to point to the proper controller and action in the first place, but once you have, it can be rewritten with ease.
+  # "/library/books/ISBN/0743536703/edit". Naturally, you'll need to setup the routes configuration file to point to the proper controller
+  # and action in the first place, but once you have, it can be rewritten with ease.
   # 
-  # Let's consider a bunch of examples on how to go from "/library/books/ISBN/0743536703/edit" to somewhere else:
-  #
-  #   redirect_to(:action => "show", :action_prefix => "XTC/123") =>
-  #     "http://www.singlefile.com/library/books/XTC/123/show"
+  # Let's consider a bunch of examples on how to go from "/clients/37signals/basecamp/project/dash" to somewhere else:
   #
-  #   redirect_to(:path_params => {"type" => "EXBC"}) =>
-  #     "http://www.singlefile.com/library/books/EXBC/0743536703/show"
+  #   redirect_to(:action => "edit") =>
+  #     /clients/37signals/basecamp/project/dash
+  #   
+  #   redirect_to(:client_name => "nextangle", :project_name => "rails") =>
+  #     /clients/nextangle/rails/project/dash
   #
-  #   redirect_to(:controller => "settings") => 
-  #     "http://www.singlefile.com/library/settings/"
+  # Those redirects happen under the configuration of:
   #
-  # For more examples of redirecting options, have a look at the unit test in test/controller/url_test.rb. It's very readable and will give
-  # you an excellent understanding of the different options and what they do.
+  #   map.connect 'clients/:client_name/:project_name/:controller/:action'
   #
   # == Calling multiple redirects or renders
   #
@@ -205,10 +213,16 @@ module ActionController #:nodoc:
     # should instead be implemented in the controller to determine when debugging screens should be shown.
     @@consider_all_requests_local = true
     cattr_accessor :consider_all_requests_local
+    
+    # Enable or disable the collection of failure information for RoutingErrors.
+    # This information can be extremely useful when tweaking custom routes, but is
+    # pointless once routes have been tested and verified.
+    @@debug_routes = true
+    cattr_accessor :debug_routes
 
     # Template root determines the base from which template references will be made. So a call to render("test/template")
     # will be converted to "#{template_root}/test/template.rhtml".
-    cattr_accessor :template_root
+    class_inheritable_accessor :template_root
 
     # The logger is used for generating information on the action run-time (including benchmarking) if available.
     # Can be set to nil for no logging. Compatible with both Ruby's own Logger and Log4r loggers.
@@ -261,6 +275,41 @@ module ActionController #:nodoc:
       def controller_name
         Inflector.underscore(controller_class_name.sub(/Controller/, ""))
       end
+      
+      # Convert the class name from something like "OneModule::TwoModule::NeatController" to "one_module/two_module/neat".
+      def controller_path
+        components = self.name.to_s.split('::').collect { |name| name.underscore }
+        components[-1] = $1 if /^(.*)_controller$/ =~ components[-1]
+        components.shift if components.first == 'controllers' # Transitional conditional to accomodate root Controllers module
+        components.join('/')
+      end
+
+      # Return an array containing the names of public methods that have been marked hidden from the action processor.
+      # By default, all methods defined in ActionController::Base and included modules are hidden.
+      # More methods can be hidden using +hide_actions+.
+      def hidden_actions
+        write_inheritable_attribute(:hidden_actions, ActionController::Base.public_instance_methods) unless read_inheritable_attribute(:hidden_actions)
+        read_inheritable_attribute(:hidden_actions)
+      end
+
+      # Hide each of the given methods from being callable as actions.
+      def hide_action(*names)
+        write_inheritable_attribute(:hidden_actions, hidden_actions | names.collect {|n| n.to_s})
+      end
+
+      # Set the template root to be one directory behind the root dir of the controller. Examples:
+      #   /code/weblog/components/admin/users_controller.rb with Admin::UsersController 
+      #     will use /code/weblog/components as template root 
+      #     and find templates in /code/weblog/components/admin/users/
+      #
+      #   /code/weblog/components/admin/parties/users_controller.rb with Admin::Parties::UsersController 
+      #     will also use /code/weblog/components as template root 
+      #     and find templates in /code/weblog/components/admin/parties/users/
+      def uses_component_template_root
+        path_of_calling_controller = File.dirname(caller[0].split(/:\d+:/).first)
+        path_of_controller_root    = path_of_calling_controller.sub(/#{controller_path.split("/")[0..-2]}$/, "")
+        self.template_root = path_of_controller_root
+      end
     end
 
     public
@@ -277,45 +326,65 @@ module ActionController #:nodoc:
         return @response
       end
 
-      # Returns an URL that has been rewritten according to the hash of +options+ (for doing a complete redirect, use redirect_to). The
-      # valid keys in options are specified below with an example going from "/library/books/ISBN/0743536703/show" (mapped to
-      # books_controller?action=show&type=ISBN&id=0743536703):
+      # Returns a URL that has been rewritten according to the options hash and the defined Routes. 
+      # (For doing a complete redirect, use redirect_to).
+      # �
+      # <tt>url_for</tt> is used to:
+      # �
+      # All keys given to url_for are forwarded to the Route module save for the following:
+      # * <tt>:anchor</tt> -- specifies the anchor name to be appended to the path. For example, 
+      #   <tt>url_for :controller => 'posts', :action => 'show', :id => 10, :anchor => 'comments'</tt> 
+      #   will produce "/posts/show/10#comments".
+      # * <tt>:only_path</tt> --  if true, returns the absolute URL (omitting the protocol, host name, and port)
+      # * <tt>:host</tt> -- overrides the default (current) host if provided
+      # * <tt>:protocol</tt> -- overrides the default (current) protocol if provided
+      #
+      # The URL is generated from the remaining keys in the hash. A URL contains two key parts: the <base> and a query string.
+      # Routes composes a query string as the key/value pairs not included in the <base>.
+      #
+      # The default Routes setup supports a typical Rails path of "controller/action/id" where action and id are optional, with
+      # action defaulting to 'index' when not given. Here are some typical url_for statements and their corresponding URLs:
+      # �
+      #   url_for :controller => 'posts', :action => 'recent' # => 'proto://host.com/posts/recent'
+      #   url_for :controller => 'posts', :action => 'index' # => 'proto://host.com/posts'
+      #   url_for :controller => 'posts', :action => 'show', :id => 10 # => 'proto://host.com/posts/show/10'
+      #
+      # When generating a new URL, missing values may be filled in from the current request's parameters. For example,
+      # <tt>url_for :action => 'some_action'</tt> will retain the current controller, as expected. This behavior extends to
+      # other parameters, including <tt>:controller</tt>, <tt>:id</tt>, and any other parameters that are placed into a Route's
+      # path.
+      # �
+      # The URL helpers such as <tt>url_for</tt> have a limited form of memory: when generating a new URL, they can look for
+      # missing values in the current request's parameters. Routes attempts to guess when a value should and should not be
+      # taken from the defaults. There are a few simple rules on how this is performed:
       #
-      #            .---> controller      .--> action
-      #   /library/books/ISBN/0743536703/show
-      #   '------>      '--------------> action_prefix
-      #    controller_prefix (or module)
+      # * If the controller name begins with a slash, no defaults are used: <tt>url_for :controller => '/home'</tt>
+      # * If the controller changes, the action will default to index unless provided
       #
-      # * <tt>:controller_prefix</tt> - specifies the string before the controller name, which would be "/library" for the example.
-      #   Called with "/shop" gives "/shop/books/ISBN/0743536703/show".
-      # * <tt>:module</tt> - serves as a alias to :controller_prefix (overwrites :controller_prefix unless its nil)
-      # * <tt>:controller</tt> - specifies a new controller and clears out everything after the controller name (including the action, 
-      #   the pre- and suffix, and all params), so called with "settings" gives "/library/settings/".
-      # * <tt>:action_prefix</tt> - specifies the string between the controller name and the action name, which would
-      #   be "/ISBN/0743536703" for the example. Called with "/XTC/123/" gives "/library/books/XTC/123/show".
-      # * <tt>:action</tt> - specifies a new action, so called with "edit" gives "/library/books/ISBN/0743536703/edit"
-      # * <tt>:action_suffix</tt> - specifies the string after the action name, which would be empty for the example.
-      #   Called with "/detailed" gives "/library/books/ISBN/0743536703/detailed".
-      # * <tt>:path_params</tt> - specifies a hash that contains keys mapping to the request parameter names. In the example, 
-      #   { "type" => "ISBN", "id" => "0743536703" } would be the path_params. It serves as another way of replacing part of
-      #   the action_prefix or action_suffix. So passing { "type" => "XTC" } would give "/library/books/XTC/0743536703/show".
-      # * <tt>:id</tt> - shortcut where ":id => 5" can be used instead of specifying :path_params => { "id" => 5 }.
-      #   Called with "123" gives "/library/books/ISBN/123/show".
-      # * <tt>:params</tt> - specifies a hash that represents the regular request parameters, such as { "cat" => 1, 
-      #   "origin" => "there"} that would give "?cat=1&origin=there". Called with { "temporary" => 1 } in the example would give
-      #   "/library/books/ISBN/0743536703/show?temporary=1"
-      # * <tt>:anchor</tt> - specifies the anchor name to be appended to the path. Called with "x14" would give
-      #   "/library/books/ISBN/0743536703/show#x14"
-      # * <tt>:only_path</tt> - if true, returns the absolute URL (omitting the protocol, host name, and port).
+      # The final rule is applied while the URL is being generated and is best illustrated by an example. Let us consider the
+      # route given by <tt>map.connect 'people/:last/:first/:action', :action => 'bio', :controller => 'people'</tt>.
       #
-      # Naturally, you can combine multiple options in a single redirect. Examples:
+      # Suppose that the current URL is "people/hh/david/contacts". Let's consider a few different cases URLs which are generated
+      # from this page.
       #
-      #   redirect_to(:controller_prefix => "/shop", :controller => "settings")
-      #   redirect_to(:controller_prefix => false, :controller => "settings") # breaks out of the current controller_prefix
-      #   redirect_to(:action => "edit", :id => 3425)
-      #   redirect_to(:action => "edit", :path_params => { "type" => "XTC" }, :params => { "temp" => 1})
-      #   redirect_to(:action => "publish", :action_prefix => "/published", :anchor => "x14")
+      # * <tt>url_for :action => 'bio'</tt> -- During the generation of this URL, default values will be used for the first and
+      # last components, and the action shall change. The generated URL will be, "people/david/hh/bio".
+      # * <tt>url_for :first => 'davids-little-brother'</tt> This generates the URL 'people/hh/davids-little-brother' -- note
+      #   that this URL leaves out the assumed action of 'bio'.
       #
+      # However, you might ask why the action from the current request, 'contacts', isn't carried over into the new URL. The
+      # answer has to do with the order in which the parameters appear in the generated path. In a nutshell, since the
+      # value that appears in the slot for <tt>:first</tt> is not equal to default value for <tt>:first</tt> we stop using
+      # defaults. On it's own, this rule can account for much of the typical Rails URL behavior.
+      # �
+      # Although a convienence, defaults can occasionaly get in your way. In some cases a default persists longer than desired.
+      # The default may be cleared by adding <tt>:name => nil</tt> to <tt>url_for</tt>'s options.
+      # This is often required when writing form helpers, since the defaults in play may vary greatly depending upon where the
+      # helper is used from. The following line will redirect to PostController's default action, regardless of the page it is
+      # displayed on:
+      #
+      #   url_for :controller => 'posts', :action => nil
+      #      
       # Instead of passing an options hash, you can also pass a method reference in the form of a symbol. Consider this example:
       #
       #   class WeblogController < ActionController::Base
@@ -337,10 +406,6 @@ module ActionController #:nodoc:
         end
       end
 
-      def module_name
-        @params["module"]
-      end
-
       # Converts the class name from something like "OneModule::TwoModule::NeatController" to "NeatController".
       def controller_class_name
         self.class.controller_class_name
@@ -405,10 +470,16 @@ module ActionController #:nodoc:
       
       # Renders an empty response that can be used when the request is only interested in triggering an effect. Do note that good
       # HTTP manners mandate that you don't use GET requests to trigger data changes.
-      def render_nothing(status = nil)
+      def render_nothing(status = nil) #:doc:
         render_text "", status
       end
 
+      # Returns the result of the render as a string.
+      def render_to_string(template_name = default_template_name) #:doc:
+        add_variables_to_assigns
+        @template.render_file(template_name)
+      end
+
       # Sends the file by streaming it 4096 bytes at a time. This way the
       # whole file doesn't need to be read into memory at once.  This makes
       # it feasible to send even large files.
@@ -458,6 +529,8 @@ module ActionController #:nodoc:
         options[:filename] ||= File.basename(path)
         send_file_headers! options
 
+        @performed_render = false
+
         if options[:stream]
           render_text do
             logger.info "Streaming file #{path}" unless logger.nil?
@@ -506,6 +579,7 @@ module ActionController #:nodoc:
       def send_data(data, options = {}) #:doc:
         logger.info "Sending data #{options[:filename]}" unless logger.nil?
         send_file_headers! options.merge(:length => data.size)
+        @performed_render = false
         render_text data
       end
 
@@ -521,7 +595,7 @@ module ActionController #:nodoc:
       # the form of a hash, just like the one you would use for url_for directly. Example:
       #
       #   def default_url_options(options)
-      #     { :controller_prefix => @project.active? ? "projects/" : "accounts/" }
+      #     { :project => @project.active? ? @project.url_name : "unknown" }
       #   end
       #
       # As you can infer from the example, this is mostly useful for situations where you want to centralize dynamic decisions about the
@@ -558,7 +632,7 @@ module ActionController #:nodoc:
         @performed_redirect = true
       end
 
-      # Resets the session by clearsing out all the objects stored within and initializing a new session object.
+      # Resets the session by clearing out all the objects stored within and initializing a new session object.
       def reset_session #:doc:
         @request.reset_session
         @session = @request.session
@@ -594,7 +668,7 @@ module ActionController #:nodoc:
       end
       
       def initialize_current_url
-        @url = UrlRewriter.new(@request, controller_name, action_name)
+        @url = UrlRewriter.new(@request, @params.clone())
       end
 
       def log_processing
@@ -618,10 +692,9 @@ module ActionController #:nodoc:
       end
 
       def action_methods
-        action_controller_classes = self.class.ancestors.reject{ |a| [Object, Kernel].include?(a) }
-        action_controller_classes.inject([]) { |action_methods, klass| action_methods + klass.public_instance_methods(false) }
+        @action_methods ||= (self.class.public_instance_methods - self.class.hidden_actions)
       end
-
+      
       def add_variables_to_assigns
         add_instance_variables_to_assigns
         add_class_variables_to_assigns if view_controller_internals
@@ -691,7 +764,7 @@ module ActionController #:nodoc:
       end
 
       def default_template_name(default_action_name = action_name)
-        module_name ? "#{module_name}/#{controller_name}/#{default_action_name}" : "#{controller_name}/#{default_action_name}"
+        "#{self.class.controller_path}/#{default_action_name}"
       end
   end
 end

data/lib/action_controller/caching.rb

@@ -23,7 +23,7 @@ module ActionController #:nodoc:
     # are treated the same. Content management systems -- including weblogs and wikis -- have many pages that are a great fit
     # for this approach, but account-based systems where people log in and manipulate their own data are often less likely candidates.
     #
-    # Specifying which actions to cach is done through the <tt>caches</tt> class method:
+    # Specifying which actions to cache is done through the <tt>caches</tt> class method:
     #
     #   class WeblogController < ActionController::Base
     #     caches_page :show, :new
@@ -67,7 +67,7 @@ module ActionController #:nodoc:
         def expire_page(path)
           return unless perform_caching
           File.delete(page_cache_path(path)) if File.exists?(page_cache_path(path))
-          logger.info "Expired page: #{path}" unless logger.nil?
+          logger.info "Expired page: #{page_cache_file(path)}" unless logger.nil?
         end
         
         # Manually cache the +content+ in the key determined by +path+. Example:
@@ -76,7 +76,7 @@ module ActionController #:nodoc:
           return unless perform_caching
           FileUtils.makedirs(File.dirname(page_cache_path(path)))
           File.open(page_cache_path(path), "w+") { |f| f.write(content) }
-          logger.info "Cached page: #{path}" unless logger.nil?
+          logger.info "Cached page: #{page_cache_file(path)}" unless logger.nil?
         end
 
         # Caches the +actions+ using the page-caching approach that'll store the cache in a path within the page_cache_directory that
@@ -89,12 +89,12 @@ module ActionController #:nodoc:
         end
         
         private
+          def page_cache_file(path)
+            (path.empty? ? "/index" : path) + ".html"
+          end
+        
           def page_cache_path(path)
-            if path[-1,1] == '/'
-              page_cache_directory + path + '/index'
-            else
-              page_cache_directory + path
-            end
+            page_cache_directory + page_cache_file(path)
           end
       end
 
@@ -121,7 +121,7 @@ module ActionController #:nodoc:
 
       private
         def caching_allowed
-          !@request.post? && (@request.parameters.reject { |k, v| %w( id action controller ).include?(k) }).empty?
+          !@request.post?
         end
     end
 
@@ -308,13 +308,13 @@ module ActionController #:nodoc:
 
       class DRbStore < MemoryStore #:nodoc:
         def initialize(address = 'druby://localhost:9192')
-          @data = DRbObject.new(nil, address)
+          @data, @mutex = DRbObject.new(nil, address), Mutex.new
         end    
       end
 
       class MemCacheStore < MemoryStore #:nodoc:
         def initialize(address = 'localhost')
-          @data = MemCache.new(address)
+          @data, @mutex = MemCache.new(address), Mutex.new
         end    
       end
 

data/lib/action_controller/cgi_ext/cgi_ext.rb

@@ -4,7 +4,7 @@ require 'cgi/session/pstore'
 require 'action_controller/cgi_ext/cgi_methods'
 
 # Wrapper around the CGIMethods that have been secluded to allow testing without 
-# an instatiated CGI object
+# an instantiated CGI object
 class CGI #:nodoc:
   class << self
     alias :escapeHTML_fail_on_nil :escapeHTML
@@ -40,4 +40,4 @@ class CGI #:nodoc:
     parameters['database_manager'] = CGI::Session::PStore
     CGI::Session.new(self, parameters)
   end
-end
+end

data/lib/action_controller/cgi_ext/raw_post_data_fix.rb

@@ -14,7 +14,7 @@ class CGI #:nodoc:
         @params = CGI::parse(read_query_params)
       end
       
-      @cookies = CGI::Cookie::parse((env_table['HTTP_COOKIE'] or env_table['COOKIE']))
+      @cookies = CGI::Cookie::parse((env_table['HTTP_COOKIE'] || env_table['COOKIE']))
     end
 
     private
@@ -30,13 +30,13 @@ class CGI #:nodoc:
         case env_table['REQUEST_METHOD']
           when 'GET', 'HEAD'
             if defined? MOD_RUBY              
-              Apache::request.args or ''
+              Apache::request.args || ''
             else
-              env_table['QUERY_STRING'] or ''
+              env_table['QUERY_STRING'] || ''
             end
           when 'POST'
             stdinput.binmode if stdinput.respond_to?(:binmode)
-            content = stdinput.read(Integer(env_table['CONTENT_LENGTH'])) or ''
+            content = stdinput.read(Integer(env_table['CONTENT_LENGTH'])) || ''
             env_table['RAW_POST_DATA'] = content.freeze
           else
             read_from_cmdline

data/lib/action_controller/cgi_process.rb

@@ -46,8 +46,16 @@ module ActionController #:nodoc:
       super()
     end
 
+    def query_string
+      return @cgi.query_string unless @cgi.query_string.nil? || @cgi.query_string.empty?
+      parts = env['REQUEST_URI'].split('?')
+      parts.shift
+      return parts.join('?')
+    end
+
     def query_parameters
-      @cgi.query_string ? CGIMethods.parse_query_parameters(@cgi.query_string) : {}
+      qs = self.query_string
+      qs.empty? ? {} : CGIMethods.parse_query_parameters(query_string)
     end
 
     def request_parameters

data/lib/action_controller/components.rb

@@ -0,0 +1,73 @@
+module ActionController #:nodoc:
+  # Components allows you to call other actions for their rendered response while execution another action. You can either delegate
+  # the entire response rendering or you can mix a partial response in with your other content.
+  #
+  #   class WeblogController < ActionController::Base
+  #     # Performs a method and then lets hello_world output its render
+  #     def delegate_action
+  #       do_other_stuff_before_hello_world
+  #       render_component :controller => "greeter",  :action => "hello_world"
+  #     end
+  #   end
+  #
+  #   class GreeterController < ActionController::Base
+  #     def hello_world
+  #       render_text "Hello World!"
+  #     end
+  #   end
+  #
+  # The same can be done in a view to do a partial rendering:
+  # 
+  #   Let's see a greeting: 
+  #   <%= render_component :controller => "greeter", :action => "hello_world" %>
+  module Components
+    def self.append_features(base) #:nodoc:
+      super
+      base.helper do
+        def render_component(options) 
+          @controller.send(:render_component_as_string, options)
+        end
+      end
+    end
+
+    protected
+      # Renders the component specified as the response for the current method
+      def render_component(options = {}) #:doc:
+        component_logging(options) { render_text(component_response(options).body, response.headers["Status"]) }
+      end
+
+      # Returns the component response as a string
+      def render_component_as_string(options) #:doc:
+        component_logging(options) { component_response(options, false).body }
+      end
+  
+    private
+      def component_response(options, reuse_response = true)
+        component_class(options).process(request_for_component(options), reuse_response ? @response : response_for_component)
+      end
+    
+      def component_class(options)
+        options[:controller] ? (options[:controller].camelize + "Controller").constantize : self.class
+      end
+      
+      def request_for_component(options)
+        request_for_component = @request.dup
+        request_for_component.send(
+          :instance_variable_set, :@parameters, 
+          (options[:params] || {}).merge({ "controller" => options[:controller], "action" => options[:action] })
+        )
+        return request_for_component
+      end
+      
+      def response_for_component
+        @response.dup
+      end
+      
+      def component_logging(options)
+        logger.info("Start rendering component (#{options.inspect}): ") unless logger.nil?
+        result = yield
+        logger.info("\n\nEnd of component rendering") unless logger.nil?
+        return result
+      end
+  end
+end