actionpack 0.9.5 → 1.0.0

data/lib/action_controller/benchmarking.rb

@@ -15,7 +15,7 @@ module ActionController #:nodoc:
       }
     end
 
-    def render_with_benchmark(template_name = "#{controller_name}/#{action_name}", status = "200 OK")
+    def render_with_benchmark(template_name = default_template_name, status = "200 OK")
       if logger.nil?
         render_without_benchmark(template_name, status)
       else

data/lib/action_controller/cgi_ext/cgi_methods.rb

@@ -63,29 +63,27 @@ class CGIMethods #:nodoc:
       end
     end
   
-    def CGIMethods.get_levels(key_string)
-      return [] if key_string.nil? or key_string.empty?
-
-      levels = []
-      main, existance = /(\w+)(\[)?.?/.match(key_string).captures
-      levels << main
-      
-      unless existance.nil?
-        hash_part = key_string.sub(/\w+\[/, "")
-        hash_part.slice!(-1, 1)
-        levels += hash_part.split(/\]\[/)
+    PARAMS_HASH_RE = /^([^\[]+)(\[.*\])?(.)?.*$/
+    def CGIMethods.get_levels(key)
+      all, main, bracketed, trailing = PARAMS_HASH_RE.match(key).to_a
+      if main.nil?
+        []
+      elsif trailing
+        [key]
+      elsif bracketed
+        [main] + bracketed.slice(1...-1).split('][')
+      else
+        [main]
       end
-      
-      levels
     end
-    
+
     def CGIMethods.build_deep_hash(value, hash, levels)
       if levels.length == 0
-        value;
+        value
       elsif hash.nil?
         { levels.first => CGIMethods.build_deep_hash(value, nil, levels[1..-1]) }
       else
         hash.update({ levels.first => CGIMethods.build_deep_hash(value, hash[levels.first], levels[1..-1]) })
       end
     end
-end
+end

data/lib/action_controller/cgi_process.rb

@@ -36,7 +36,7 @@ module ActionController #:nodoc:
     attr_accessor :cgi
 
     DEFAULT_SESSION_OPTIONS =
-      { "database_manager" => CGI::Session::PStore, "prefix" => "ruby_sess.", "session_path" => "/" }
+      { :database_manager => CGI::Session::PStore, :prefix => "ruby_sess.", :session_path => "/" }
 
     def initialize(cgi, session_options = {})
       @cgi = cgi
@@ -67,7 +67,7 @@ module ActionController #:nodoc:
     def session
       return @session unless @session.nil?
       begin
-        @session = (@session_options == false ? {} : CGI::Session.new(@cgi, DEFAULT_SESSION_OPTIONS.merge(@session_options)))
+        @session = (@session_options == false ? {} : CGI::Session.new(@cgi, session_options_with_string_keys))
         @session["__valid_session"]
         return @session
       rescue ArgumentError => e
@@ -94,6 +94,10 @@ module ActionController #:nodoc:
       def new_session
         CGI::Session.new(@cgi, DEFAULT_SESSION_OPTIONS.merge(@session_options).merge("new_session" => true))
       end
+      
+      def session_options_with_string_keys
+        DEFAULT_SESSION_OPTIONS.merge(@session_options).inject({}) { |options, pair| options[pair.first.to_s] = pair.last; options }
+      end
   end
 
   class CgiResponse < AbstractResponse #:nodoc:
@@ -105,8 +109,12 @@ module ActionController #:nodoc:
     def out
       convert_content_type!(@headers)
       $stdout.binmode if $stdout.respond_to?(:binmode)
+      $stdout.sync = false
       print @cgi.header(@headers)
-      if @body.respond_to?(:call)
+
+      if @cgi.send(:env_table)['REQUEST_METHOD'] == 'HEAD'
+        return
+      elsif @body.respond_to?(:call)
         @body.call(self)
       else
         print @body
@@ -115,9 +123,11 @@ module ActionController #:nodoc:
 
     private
       def convert_content_type!(headers)
-        if headers["Content-Type"]
-          headers["type"] = headers["Content-Type"]
-          headers.delete "Content-Type"
+        %w( Content-Type Content-type content-type ).each do |ct|
+          if headers[ct]
+            headers["type"] = headers[ct]
+            headers.delete(ct)
+          end
         end
       end
   end

data/lib/action_controller/cookies.rb

@@ -0,0 +1,70 @@
+module ActionController #:nodoc:
+  # Cookies are read and written through ActionController#cookies. The cookies being read is what was received along with the request,
+  # the cookies being written is what will be sent out will the response. Cookies are read by value (so you won't get the cookie object
+  # itself back -- just the value it holds). Examples for writting:
+  #
+  #   cookies["user_name"] = "david" # => Will set a simple session cookie
+  #   cookies["login"] = { :value => "XJ-122", :expires => Time.now + 360} # => Will set a cookie that expires in 1 hour
+  #   
+  # Examples for reading:
+  #
+  #   cookies["user_name"] # => "david"
+  #   cookies.size         # => 2
+  # 
+  # Example for deleting:
+  #
+  #   cookies.delete "user_name"
+  #
+  # All the option symbols for setting cookies are:
+  #
+  # * <tt>value</tt> - the cookie's value or list of values (as an array).
+  # * <tt>path</tt> - the path for which this cookie applies.  Defaults to the root of the application.
+  # * <tt>domain</tt> - the domain for which this cookie applies.
+  # * <tt>expires</tt> - the time at which this cookie expires, as a +Time+ object.
+  # * <tt>secure</tt> - whether this cookie is a secure cookie or not (default to false).
+  #   Secure cookies are only transmitted to HTTPS servers.
+  module Cookies
+    # Returns the cookie container, which operates as described above.
+    def cookies
+      CookieJar.new(self)
+    end
+  end
+  
+  class CookieJar < Hash #:nodoc:
+    def initialize(controller)
+      @controller, @cookies = controller, controller.instance_variable_get("@cookies")
+      super()
+      update(@cookies)
+    end
+
+    # Returns the value of the cookie by +name+ -- or nil if no such cookie exist. You set new cookies using either the cookie method
+    # or cookies[]= (for simple name/value cookies without options).
+    def [](name)
+      @cookies[name.to_s].value.first if @cookies[name.to_s] && @cookies[name.to_s].respond_to?(:value)
+    end
+    
+    def []=(name, options)
+      if options.is_a?(Hash)
+        options = options.inject({}) { |options, pair| options[pair.first.to_s] = pair.last; options }
+        options["name"] = name.to_s
+      else
+        options = { "name" => name, "value" => options }
+      end
+      
+      set_cookie(name, options)
+    end
+    
+    # Removes the cookie on the client machine by setting the value to an empty string.
+    def delete(name)
+      set_cookie(name, "name" => name, "value" => "")
+    end
+
+    private
+      def set_cookie(name, options) #:doc:
+        options["path"] = "/" unless options["path"]
+        cookie = CGI::Cookie.new(options)
+        @controller.logger.info "Cookie set: #{cookie}" unless @controller.logger.nil?
+        @controller.response.headers["cookie"] << cookie
+      end
+  end
+end

data/lib/action_controller/dependencies.rb

@@ -0,0 +1,106 @@
+unless Object.respond_to?(:require_dependency)
+  Object.send(:define_method, :require_dependency) { |file_name| ActionController::Base.require_dependency(file_name) }
+end
+
+module ActionController #:nodoc:
+  module Dependencies #:nodoc:
+    def self.append_features(base)
+      super
+
+      base.class_eval do
+        # When turned on (which is default), all dependencies are included using "load". This mean that any change is instant in cached
+        # environments like mod_ruby or FastCGI. When set to false, "require" is used, which is faster but requires server restart to
+        # be effective.
+        @@reload_dependencies = true
+        cattr_accessor :reload_dependencies
+      end
+
+      base.class_eval { class << self; alias_method :inherited_without_model, :inherited; end }
+
+      base.extend(ClassMethods)
+    end
+
+    # Dependencies control what classes are needed for the controller to run its course. This is an alternative to doing explicit
+    # +require+ statements that bring a number of benefits. It's more succinct, communicates what type of dependency we're talking about,
+    # can trigger special behavior (as in the case of +observer+), and enables Rails to be clever about reloading in cached environments
+    # like FCGI. Example:
+    #
+    #   class ApplicationController < ActionController::Base
+    #     model    :account, :company, :person, :project, :category
+    #     helper   :access_control
+    #     service  :notifications, :billings
+    #     observer :project_change_observer
+    #   end
+    #
+    # Please note that a controller like ApplicationController will automatically attempt to require_dependency on a model of its name and a helper
+    # of its name. If nothing is found, no error is raised. This is especially useful for concrete controllers like PostController:
+    #
+    #   class PostController < ApplicationController
+    #     # model  :post (already required)
+    #     # helper :post (already required)
+    #   end
+    module ClassMethods
+      # Loads the <tt>file_name</tt> if reload_dependencies is true or requires if it's false.
+      def require_dependency(file_name)
+        reload_dependencies ? silence_warnings { load("#{file_name}.rb") } : require(file_name)
+      end
+      
+      # Specifies a variable number of models that this controller depends on. Models are normally Active Record classes or a similar
+      # backend for modelling entity classes.
+      def model(*models)
+        require_dependencies(:model, models)
+        depend_on(:model, models)
+      end
+
+      # Specifies a variable number of services that this controller depends on. Services are normally singletons or factories, like
+      # Action Mailer service or a Payment Gateway service.
+      def service(*services)
+        require_dependencies(:service, services)
+        depend_on(:service, services)
+      end
+      
+      # Specifies a variable number of observers that are to govern when this controller is handling actions. The observers will
+      # automatically have .instance called on them to make them active on assignment.
+      def observer(*observers)
+        require_dependencies(:observer, observers)
+        depend_on(:observer, observers)
+        instantiate_observers(observers)
+      end
+
+      # Returns an array of symbols that specify the dependencies on a given layer. For the example at the top, calling
+      # <tt>ApplicationController.dependencies_on(:model)</tt> would return <tt>[:account, :company, :person, :project, :category]</tt>
+      def dependencies_on(layer)
+        read_inheritable_attribute("#{layer}_dependencies")
+      end
+    
+      def depend_on(layer, dependencies) #:nodoc:
+        write_inheritable_array("#{layer}_dependencies", dependencies)
+      end
+
+      private
+        def instantiate_observers(observers)
+          observers.flatten.each { |observer| Object.const_get(Inflector.classify(observer.to_s)).instance }
+        end
+        
+        def require_dependencies(layer, dependencies)
+          dependencies.flatten.each do |dependency|
+            begin
+              require_dependency(dependency.to_s)
+            rescue LoadError
+              raise LoadError, "Missing #{layer} #{dependency}.rb"
+            end
+          end
+        end
+
+        def inherited(child)
+          inherited_without_model(child)
+          begin
+            child.model(child.controller_name)
+            child.model(Inflector.singularize(child.controller_name))
+          rescue LoadError
+            # No neither singular or plural model available for this controller
+          end
+        end        
+    end
+  end
+end

data/lib/action_controller/helpers.rb

@@ -2,6 +2,7 @@ module ActionController #:nodoc:
   module Helpers #:nodoc:
     def self.append_features(base)
       super
+      base.class_eval { class << self; alias_method :inherited_without_helper, :inherited; end }
       base.extend(ClassMethods)
     end
 
@@ -30,7 +31,7 @@ module ActionController #:nodoc:
       # Makes all the (instance) methods in the helper module available to templates rendered through this controller.
       # See ActionView::Helpers (link:classes/ActionView/Helpers.html) for more about making your own helper modules 
       # available to the templates.
-      def add_template_helper(helper_module)
+      def add_template_helper(helper_module) #:nodoc:
         template_class.class_eval "include #{helper_module}"
       end
 
@@ -53,9 +54,9 @@ module ActionController #:nodoc:
             file_name  = Inflector.underscore(arg.to_s.downcase) + '_helper'
             class_name = Inflector.camelize(file_name)
             begin
-              require file_name
+              require_dependency(file_name)
             rescue LoadError
-              raise ArgumentError, "Missing helper file helpers/#{file_name}.rb"
+              raise LoadError, "Missing helper file helpers/#{file_name}.rb"
             end
             raise ArgumentError, "Missing #{class_name} module in helpers/#{file_name}.rb" unless Object.const_defined?(class_name)
             add_template_helper(Object.const_get(class_name))
@@ -84,6 +85,16 @@ module ActionController #:nodoc:
       def helper_attr(*attrs)
         attrs.flatten.each { |attr| helper_method(attr, "#{attr}=") }
       end
+
+      private 
+        def inherited(child)
+          inherited_without_helper(child)
+          begin
+            child.helper(child.controller_name)
+          rescue LoadError
+            # No default helper available for this controller
+          end
+        end        
     end
   end
 end

data/lib/action_controller/layout.rb

@@ -2,11 +2,14 @@ module ActionController #:nodoc:
   module Layout #:nodoc:
     def self.append_features(base)
       super
-      base.extend(ClassMethods)
       base.class_eval do
         alias_method :render_without_layout, :render
         alias_method :render, :render_with_layout
+        class << self
+          alias_method :inherited_without_layout, :inherited
+        end
       end
+      base.extend(ClassMethods)
     end
 
     # Layouts reverse the common pattern of including shared headers and footers in many templates to isolate changes in
@@ -119,6 +122,16 @@ module ActionController #:nodoc:
       def layout(template_name)
         write_inheritable_attribute "layout", template_name
       end
+
+      private
+        def inherited(child)
+          inherited_without_layout(child)
+          child.layout(child.controller_name) unless layout_list.grep(/^#{child.controller_name}\.r(?:xml|html)$/).empty?
+        end
+
+        def layout_list
+          Dir.glob("#{template_root}/layouts/*.r{xml,html}").map { |layout| File.basename(layout) }
+        end
     end
 
     # Returns the name of the active layout. If the layout was specified as a method reference (through a symbol), this method
@@ -135,7 +148,7 @@ module ActionController #:nodoc:
       active_layout.include?("/") ? active_layout : "layouts/#{active_layout}" if active_layout
     end
 
-    def render_with_layout(template_name = "#{controller_name}/#{action_name}", status = nil, layout = nil) #:nodoc:
+    def render_with_layout(template_name = default_template_name, status = nil, layout = nil) #:nodoc:
       if layout ||= active_layout
         add_variables_to_assigns
         logger.info("Rendering #{template_name} within #{layout}") unless logger.nil?
@@ -145,5 +158,6 @@ module ActionController #:nodoc:
         render_without_layout(template_name, status)
       end
     end
+
   end
 end

data/lib/action_controller/request.rb

@@ -26,6 +26,10 @@ module ActionController
       method == :delete
     end
 
+    def head?
+      method == :head
+    end
+
     # Determine originating IP address.  REMOTE_ADDR is the standard
     # but will fail if the user is behind a proxy.  HTTP_CLIENT_IP and/or
     # HTTP_X_FORWARDED_FOR are set by proxies so check for these before
@@ -33,15 +37,17 @@ module ActionController
     # delimited list in the case of multiple chained proxies; the first is
     # the originating IP.
     def remote_ip
-      if env['HTTP_CLIENT_IP']
-        env['HTTP_CLIENT_IP']
-      elsif env['HTTP_X_FORWARDED_FOR']
-        env['HTTP_X_FORWARDED_FOR'].split(',').reject { |ip|
+      return env['HTTP_CLIENT_IP'] if env.include? 'HTTP_CLIENT_IP'
+
+      if env.include? 'HTTP_X_FORWARDED_FOR' then
+        remote_ips = env['HTTP_X_FORWARDED_FOR'].split(',').reject do |ip|
             ip =~ /^unknown$|^(10|172\.16|192\.168)\./i
-        }.first.strip
-      else
-        env['REMOTE_ADDR']
+        end
+
+        return remote_ips.first.strip unless remote_ips.empty?
       end
+
+      return env['REMOTE_ADDR']
     end
 
     def request_uri
@@ -52,6 +58,10 @@ module ActionController
       port == 443 ? "https://" : "http://"
     end
 
+    def ssl?
+      protocol == "https://"
+    end
+
     def path
       request_uri ? request_uri.split("?").first : ""
     end

data/lib/action_controller/rescue.rb

@@ -8,12 +8,19 @@ module ActionController #:nodoc:
   module Rescue
     def self.append_features(base) #:nodoc:
       super
+      base.extend(ClassMethods)
       base.class_eval do
         alias_method :perform_action_without_rescue, :perform_action
         alias_method :perform_action, :perform_action_with_rescue
       end
     end
 
+    module ClassMethods #:nodoc:
+      def process_with_exception(request, response, exception)
+        new.process(request, response, :rescue_action, exception)
+      end
+    end
+
     protected
       # Exception handler called when the performance of an action raises an exception.
       def rescue_action(exception)
@@ -66,7 +73,31 @@ module ActionController #:nodoc:
       def perform_action_with_rescue #:nodoc:
         begin
           perform_action_without_rescue
-        rescue Exception => exception
+        rescue => exception
+          if defined?(Breakpoint) and @params["BP-RETRY"] then
+            msg = exception.backtrace.first
+            if md = /^(.+?):(\d+)(?::in `(.+)')?$/.match(msg) then
+              origin_file, origin_line = md[1], md[2].to_i
+
+              set_trace_func(lambda do |type, file, line, method, context, klass|
+                if file == origin_file and line == origin_line then
+                  set_trace_func(nil)
+                  @params["BP-RETRY"] = false
+
+                  callstack = caller
+                  callstack.slice!(0) if callstack.first["rescue.rb"]
+                  file, line, method = *callstack.first.match(/^(.+?):(\d+)(?::in `(.*?)')?/).captures
+
+                  message = "Exception at #{file}:#{line}#{" in `#{method}'" if method}."
+
+                  Breakpoint.handle_breakpoint(context, message, file, line)
+                end
+              end)
+
+              retry
+            end
+          end
+
           rescue_action(exception)
         end
       end
@@ -87,8 +118,7 @@ module ActionController #:nodoc:
       end
       
       def clean_backtrace(exception)
-        base_dir = File.expand_path(File.dirname(__FILE__) + "/../../../../")
-        exception.backtrace.collect { |line| line.gsub(base_dir, "").gsub("/public/../config/environments/../../", "").gsub("/public/../", "") }
+        exception.backtrace.collect { |line| Object.const_defined?(:RAILS_ROOT) ? line.gsub(RAILS_ROOT, "") : line }
       end
   end
 end