actionpack 1.2.0 → 1.3.0

data/lib/action_controller/cgi_process.rb

@@ -2,6 +2,7 @@ require 'action_controller/cgi_ext/cgi_ext'
 require 'action_controller/cgi_ext/cookie_performance_fix'
 require 'action_controller/session/drb_store'
 require 'action_controller/session/active_record_store'
+require 'action_controller/session/mem_cache_store'
 
 module ActionController #:nodoc:
   class Base
@@ -61,7 +62,7 @@ module ActionController #:nodoc:
     end
 
     def host
-      env["HTTP_X_FORWARDED_HOST"] || @cgi.host.split(":").first
+      env["HTTP_X_FORWARDED_HOST"] || @cgi.host.to_s.split(":").first
     end
     
     def session

data/lib/action_controller/cookies.rb

@@ -51,16 +51,16 @@ module ActionController #:nodoc:
         options = { "name" => name, "value" => options }
       end
       
-      set_cookie(name, options)
+      set_cookie(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" => "")
+      set_cookie("name" => name.to_s, "value" => "")
     end
 
     private
-      def set_cookie(name, options) #:doc:
+      def set_cookie(options) #:doc:
         options["path"] = "/" unless options["path"]
         cookie = CGI::Cookie.new(options)
         @controller.logger.info "Cookie set: #{cookie}" unless @controller.logger.nil?

data/lib/action_controller/filters.rb

@@ -3,7 +3,7 @@ module ActionController #:nodoc:
     def self.append_features(base)
       super
       base.extend(ClassMethods)
-      base.class_eval { include ActionController::Filters::InstanceMethods }
+      base.send(:include, ActionController::Filters::InstanceMethods)
     end
 
     # Filters enable controllers to run shared pre and post processing code for its actions. These filters can be used to do 
@@ -126,19 +126,47 @@ module ActionController #:nodoc:
     #       report_result
     #     end
     #   end
+    #
+    # == Filter conditions
+    #
+    # Filters can be limited to run for only specific actions. This can be expressed either by listing the actions to
+    # exclude or the actions to include when executing the filter. Available conditions are +:only+ or +:except+, both 
+    # of which accept an arbitrary number of method references. For example:
+    #
+    #   class Journal < ActionController::Base
+    #     # only require authentication if the current action is edit or delete
+    #     before_filter :authorize, :only => [ :edit, :delete ]
+    #    
+    #     private
+    #       def authorize
+    #         # redirect to login unless authenticated
+    #       end
+    #   end
+    # 
+    # When setting conditions on inline method (proc) filters the condition must come first and be placed in parenthesis.
+    #
+    #   class UserPreferences < ActionController::Base
+    #     before_filter(:except => :new) { # some proc ... }
+    #     # ...
+    #   end
+    #
     module ClassMethods
       # The passed <tt>filters</tt> will be appended to the array of filters that's run _before_ actions
       # on this controller are performed.
       def append_before_filter(*filters, &block)
-          filters << block if block_given?
-          append_filter_to_chain("before", filters)
+        conditions = extract_conditions!(filters)
+        filters << block if block_given?
+        add_action_conditions(filters, conditions)
+        append_filter_to_chain("before", filters)
       end
 
       # The passed <tt>filters</tt> will be prepended to the array of filters that's run _before_ actions
       # on this controller are performed.
       def prepend_before_filter(*filters, &block)
-          filters << block if block_given?
-          prepend_filter_to_chain("before", filters)
+        conditions = extract_conditions!(filters) 
+        filters << block if block_given?
+        add_action_conditions(filters, conditions)
+        prepend_filter_to_chain("before", filters)
       end
 
       # Short-hand for append_before_filter since that's the most common of the two.
@@ -147,15 +175,19 @@ module ActionController #:nodoc:
       # The passed <tt>filters</tt> will be appended to the array of filters that's run _after_ actions
       # on this controller are performed.
       def append_after_filter(*filters, &block)
-          filters << block if block_given?
-          append_filter_to_chain("after", filters)
+        conditions = extract_conditions!(filters) 
+        filters << block if block_given?
+        add_action_conditions(filters, conditions)
+        append_filter_to_chain("after", filters)
       end
 
       # The passed <tt>filters</tt> will be prepended to the array of filters that's run _after_ actions
       # on this controller are performed.
       def prepend_after_filter(*filters, &block)
-          filters << block if block_given?
-          prepend_filter_to_chain("after", filters)
+        conditions = extract_conditions!(filters) 
+        filters << block if block_given?
+        add_action_conditions(filters, conditions)
+        prepend_filter_to_chain("after", filters)
       end
 
       # Short-hand for append_after_filter since that's the most common of the two.
@@ -169,8 +201,8 @@ module ActionController #:nodoc:
       #     A#before
       #     A#after
       #   B#after
-      def append_around_filter(filters)
-        for filter in [filters].flatten
+      def append_around_filter(*filters)
+        for filter in filters.flatten
           ensure_filter_responds_to_before_and_after(filter)
           append_before_filter { |c| filter.before(c) }
           prepend_after_filter { |c| filter.after(c) }
@@ -185,8 +217,8 @@ module ActionController #:nodoc:
       #     B#before
       #     B#after
       #   A#after
-      def prepend_around_filter(filters)
-        for filter in [filters].flatten
+      def prepend_around_filter(*filters)
+        for filter in filters.flatten
           ensure_filter_responds_to_before_and_after(filter)
           prepend_before_filter { |c| filter.before(c) }
           append_after_filter   { |c| filter.after(c) }
@@ -206,6 +238,16 @@ module ActionController #:nodoc:
         read_inheritable_attribute("after_filters")
       end
       
+      # Returns a mapping between filters and the actions that may run them.
+      def included_actions #:nodoc:
+        read_inheritable_attribute("included_actions") || {}
+      end
+      
+      # Returns a mapping between filters and actions that may not run them.
+      def excluded_actions #:nodoc:
+        read_inheritable_attribute("excluded_actions") || {}
+      end
+      
       private
         def append_filter_to_chain(condition, filters)
           write_inheritable_array("#{condition}_filters", filters)
@@ -220,6 +262,22 @@ module ActionController #:nodoc:
             raise ActionControllerError, "Filter object must respond to both before and after"
           end
         end
+
+        def extract_conditions!(filters)
+          return nil unless filters.last.is_a? Hash
+          filters.pop
+        end
+
+        def add_action_conditions(filters, conditions)
+          return unless conditions
+          included, excluded = conditions[:only], conditions[:except]
+          write_inheritable_hash("included_actions", condition_hash(filters, included)) && return if included
+          write_inheritable_hash("excluded_actions", condition_hash(filters, excluded)) if excluded
+        end
+
+        def condition_hash(filters, *actions)
+          filters.inject({}) {|hash, filter| hash.merge(filter => actions.flatten.map {|action| action.to_s})}
+        end
     end
 
     module InstanceMethods # :nodoc:
@@ -252,18 +310,21 @@ module ActionController #:nodoc:
       private
         def call_filters(filters)
           filters.each do |filter| 
-            if Symbol === filter
-              if self.send(filter) == false then return false end
-            elsif filter_block?(filter)
-              if filter.call(self) == false then return false end
-            elsif filter_class?(filter)
-              if filter.filter(self) == false then return false end
-            else
-              raise(
-                ActionControllerError, 
-                "Filters need to be either a symbol, proc/method, or class implementing a static filter method"
-              )
+            next if action_exempted?(filter)
+            filter_result = case
+              when filter.is_a?(Symbol)
+                self.send(filter)
+              when filter_block?(filter)
+                filter.call(self)
+              when filter_class?(filter)
+                filter.filter(self)
+              else
+                raise(
+                  ActionControllerError, 
+                  "Filters need to be either a symbol, proc/method, or class implementing a static filter method"
+                )
             end
+            return false if filter_result == false
           end
         end
         
@@ -274,6 +335,15 @@ module ActionController #:nodoc:
         def filter_class?(filter)
           filter.respond_to?("filter")
         end
+
+        def action_exempted?(filter)
+          case
+            when self.class.included_actions[filter]
+              !self.class.included_actions[filter].include?(action_name)
+            when self.class.excluded_actions[filter] 
+              self.class.excluded_actions[filter].include?(action_name)
+          end
+        end
     end
   end
 end

data/lib/action_controller/layout.rb

@@ -58,12 +58,21 @@ module ActionController #:nodoc:
     #   <h1>Welcome</h1>
     #   Off-world colonies offers you a chance to start a new life
     #
+    # == Automatic layout assignment
+    #
+    # If there is a template in <tt>app/views/layouts/</tt> with the same name as the current controller then it will be automatically
+    # set as that controller's layout unless explicitly told otherwise. Say you have a WeblogController, for example. If a template named 
+    # <tt>app/views/layouts/weblog.rhtml</tt> or <tt>app/views/layouts/weblog.rxml</tt> exists then it will be automatically set as
+    # the layout for your WeblogController. You can create a layout with the name <tt>application.rhtml</tt> or <tt>application.rxml</tt>
+    # and this will be set as the default controller if there is no layout with the same name as the current controller and there is 
+    # no layout explicitly assigned with the +layout+ method. Setting a layout explicity will always override the automatic behaviour. 
+    #
     # == Inheritance for layouts
     #
     # Layouts are shared downwards in the inheritance hierarchy, but not upwards. Examples:
     #
     #   class BankController < ActionController::Base
-    #     layout "layouts/bank_standard"
+    #     layout "bank_standard"
     #
     #   class InformationController < BankController
     #
@@ -73,7 +82,7 @@ module ActionController #:nodoc:
     #   class EmployeeController < BankController
     #     layout nil
     #
-    # The InformationController uses "layouts/bank_standard" inherited from the BankController, the VaultController overwrites
+    # The InformationController uses "bank_standard" inherited from the BankController, the VaultController overwrites
     # and picks the layout dynamically, and the EmployeeController doesn't want to use a layout at all.
     #
     # == Types of layouts
@@ -104,16 +113,31 @@ module ActionController #:nodoc:
     #   class WeblogController < ActionController::Base
     #     layout proc{ |controller| controller.logged_in? ? "writer_layout" : "reader_layout" }
     #
-    # Of course, the most common way of specifying a layout is still just as a plain template path:
+    # Of course, the most common way of specifying a layout is still just as a plain template name:
     #
     #   class WeblogController < ActionController::Base
-    #     layout "layouts/weblog_standard"
+    #     layout "weblog_standard"
     #
-    # == Avoiding the use of a layout
+    # If no directory is specified for the template name, the template will by default by looked for in +app/views/layouts/+.
     #
-    # If you have a layout that by default is applied to all the actions of a controller, you still have the option to rendering
-    # a given action without a layout. Just use the method <tt>render_without_layout</tt>, which works just like Base.render --
-    # it just doesn't apply any layouts.
+    # == Conditional layouts
+    #
+    # If you have a layout that by default is applied to all the actions of a controller, you still have the option of rendering
+    # a given action or set of actions without a layout, or restricting a layout to only a single action or a set of actions. The 
+    # +:only+ and +:except+ options can be passed to the layout call. For example:
+    #
+    #   class WeblogController < ActionController::Base
+    #     layout "weblog_standard", :except => :rss
+    # 
+    #     # ...
+    #
+    #   end
+    #
+    # This will assign "weblog_standard" as the WeblogController's layout  except for the +rss+ action, which will not wrap a layout 
+    # around the rendered view.
+    #
+    # Both the +:only+ and +:except+ condition can accept an aribtrary number of method references, so +:except => [ :rss, :text_only ]+ 
+    # is valid, as is # +:except => :rss+.
     #
     # == Using a different layout in the action render call
     # 
@@ -130,32 +154,36 @@ module ActionController #:nodoc:
     #
     # As you can see, you pass the template as the first parameter, the status code as the second ("200" is OK), and the layout
     # as the third.
-    #
-    # == Automatic layout assignment
-    #
-    # If there is a template in <tt>app/views/layouts/</tt> with the same name as the current controller then it will be automatically
-    # set as that controller's layout unless explicitly told otherwise. Say you have a WeblogController, for example. If a template named 
-    # <tt>app/views/layouts/weblog.rhtml</tt> or <tt>app/views/layouts/weblog.rxml</tt> exists then it will be automatically set as
-    # the layout for your WeblogController. You can create a layout with the name <tt>application.rhtml</tt> or <tt>application.rxml</tt>
-    # and this will be set as the default controller if there is no layout with the same name as the current controller and there is 
-    # no layout explicitly assigned with the +layout+ method. Setting a layout explicity will always override the automatic behaviour. 
     module ClassMethods
       # If a layout is specified, all actions rendered through render and render_action will have their result assigned 
       # to <tt>@content_for_layout</tt>, which can then be used by the layout to insert their contents with
       # <tt><%= @content_for_layout %></tt>. This layout can itself depend on instance variables assigned during action
       # performance and have access to them as any normal template would.
-      def layout(template_name)
+      def layout(template_name, conditions = {})
+        add_layout_conditions(conditions)
         write_inheritable_attribute "layout", template_name
       end
 
+      def layout_conditions #:nodoc:
+        read_inheritable_attribute("layout_conditions")
+      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?
+          child.layout(child.controller_name) unless layout_list.grep(/^#{child.controller_name}\.r(?:x|ht)ml$/).empty?
         end
 
         def layout_list
-          Dir.glob("#{template_root}/layouts/*.r{xml,html}").map { |layout| File.basename(layout) }
+          Dir.glob("#{template_root}/layouts/*.r{x,ht}ml").map { |layout| File.basename(layout) }
+        end
+
+        def add_layout_conditions(conditions)
+          write_inheritable_hash "layout_conditions", normalize_conditions(conditions)
+        end
+
+        def normalize_conditions(conditions)
+          conditions.inject({}) {|hash, (key, value)| hash.merge(key => [value].flatten.map {|action| action.to_s})}
         end
     end
 
@@ -174,7 +202,7 @@ module ActionController #:nodoc:
     end
 
     def render_with_layout(template_name = default_template_name, status = nil, layout = nil) #:nodoc:
-      if layout ||= active_layout
+      if layout ||= active_layout and action_has_layout?
         add_variables_to_assigns
         logger.info("Rendering #{template_name} within #{layout}") unless logger.nil?
         @content_for_layout = @template.render_file(template_name, true)
@@ -184,5 +212,19 @@ module ActionController #:nodoc:
       end
     end
 
+    private
+      
+      def action_has_layout?
+        conditions = self.class.layout_conditions
+        case
+          when conditions[:only]
+            conditions[:only].include?(action_name)
+          when conditions[:except]
+            !conditions[:except].include?(action_name) 
+          else
+            true
+        end
+      end
+
   end
 end

data/lib/action_controller/session/mem_cache_store.rb

@@ -46,7 +46,7 @@ begin
           unless check_id(id)
             raise ArgumentError, "session_id '%s' is invalid" % id
   	      end
-          @cache = options['cache']
+          @cache = options['cache'] || MemCache.new('localhost')
   	      @session_key = "session:#{id}"
   	      @hash = {}
         end

data/lib/action_controller/support/binding_of_caller.rb

@@ -1,81 +1,85 @@
 begin
   require 'simplecc'
 rescue LoadError
-  def Continuation.create(*args, &block)
-    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
-    result ||= args
-    return *[cc, *result]
+  class Continuation #:nodoc:
+    def create(*args, &block)
+      cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
+      result ||= args
+      return *[cc, *result]
+    end
   end
 end
 
-# This method returns the binding of the method that called your
-# method. It will raise an Exception when you're not inside a method.
-#
-# It's used like this:
-#   def inc_counter(amount = 1)
-#     Binding.of_caller do |binding|
-#       # Create a lambda that will increase the variable 'counter'
-#       # in the caller of this method when called.
-#       inc = eval("lambda { |arg| counter += arg }", binding)
-#       # We can refer to amount from inside this block safely.
-#       inc.call(amount)
-#     end
-#     # No other statements can go here. Put them inside the block.
-#   end
-#   counter = 0
-#   2.times { inc_counter }
-#   counter # => 2
-#
-# Binding.of_caller must be the last statement in the method.
-# This means that you will have to put everything you want to
-# do after the call to Binding.of_caller into the block of it.
-# This should be no problem however, because Ruby has closures.
-# If you don't do this an Exception will be raised. Because of
-# the way that Binding.of_caller is implemented it has to be
-# done this way.
-def Binding.of_caller(&block)
-  old_critical = Thread.critical
-  Thread.critical = true
-  count = 0
-  cc, result, error, extra_data = Continuation.create(nil, nil)
-  error.call if error
+class Binding #:nodoc:
+  # This method returns the binding of the method that called your
+  # method. It will raise an Exception when you're not inside a method.
+  #
+  # It's used like this:
+  #   def inc_counter(amount = 1)
+  #     Binding.of_caller do |binding|
+  #       # Create a lambda that will increase the variable 'counter'
+  #       # in the caller of this method when called.
+  #       inc = eval("lambda { |arg| counter += arg }", binding)
+  #       # We can refer to amount from inside this block safely.
+  #       inc.call(amount)
+  #     end
+  #     # No other statements can go here. Put them inside the block.
+  #   end
+  #   counter = 0
+  #   2.times { inc_counter }
+  #   counter # => 2
+  #
+  # Binding.of_caller must be the last statement in the method.
+  # This means that you will have to put everything you want to
+  # do after the call to Binding.of_caller into the block of it.
+  # This should be no problem however, because Ruby has closures.
+  # If you don't do this an Exception will be raised. Because of
+  # the way that Binding.of_caller is implemented it has to be
+  # done this way.
+  def of_caller(&block)
+    old_critical = Thread.critical
+    Thread.critical = true
+    count = 0
+    cc, result, error, extra_data = Continuation.create(nil, nil)
+    error.call if error
 
-  tracer = lambda do |*args|
-    type, context, extra_data = args[0], args[4], args
-    if type == "return"
-      count += 1
-      # First this method and then calling one will return --
-      # the trace event of the second event gets the context
-      # of the method which called the method that called this
-      # method.
-      if count == 2
-        # It would be nice if we could restore the trace_func
-        # that was set before we swapped in our own one, but
-        # this is impossible without overloading set_trace_func
-        # in current Ruby.
+    tracer = lambda do |*args|
+      type, context, extra_data = args[0], args[4], args
+      if type == "return"
+        count += 1
+        # First this method and then calling one will return --
+        # the trace event of the second event gets the context
+        # of the method which called the method that called this
+        # method.
+        if count == 2
+          # It would be nice if we could restore the trace_func
+          # that was set before we swapped in our own one, but
+          # this is impossible without overloading set_trace_func
+          # in current Ruby.
+          set_trace_func(nil)
+          cc.call(eval("binding", context), nil, extra_data)
+        end
+      elsif type == "line" then
+        nil
+      elsif type == "c-return" and extra_data[3] == :set_trace_func then
+        nil
+      else
         set_trace_func(nil)
-        cc.call(eval("binding", context), nil, extra_data)
+        error_msg = "Binding.of_caller used in non-method context or " +
+          "trailing statements of method using it aren't in the block."
+        cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
       end
-    elsif type == "line" then
-      nil
-    elsif type == "c-return" and extra_data[3] == :set_trace_func then
-      nil
-    else
-      set_trace_func(nil)
-      error_msg = "Binding.of_caller used in non-method context or " +
-        "trailing statements of method using it aren't in the block."
-      cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
     end
-  end
 
-  unless result
-    set_trace_func(tracer)
-    return nil
-  else
-    Thread.critical = old_critical
-    case block.arity
-      when 1 then yield(result)
-      else yield(result, extra_data)        
+    unless result
+      set_trace_func(tracer)
+      return nil
+    else
+      Thread.critical = old_critical
+      case block.arity
+        when 1 then yield(result)
+        else yield(result, extra_data)        
+      end
     end
   end
-end
+end