actionpack 1.9.1 → 1.10.1

data/lib/action_controller/helpers.rb

@@ -16,11 +16,6 @@ module ActionController #:nodoc:
           alias_method :inherited_without_helper, :inherited
           alias_method :inherited, :inherited_with_helper
         end
-
-        # Wrap initialize_template_class to extend new template class
-        # instances with the master helper module.
-        alias_method :initialize_template_class_without_helper, :initialize_template_class
-        alias_method :initialize_template_class, :initialize_template_class_with_helper
       end
     end
 
@@ -50,7 +45,7 @@ module ActionController #:nodoc:
       # 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) #:nodoc:
-        master_helper_module.module_eval "include #{helper_module}"
+        master_helper_module.send(:include, helper_module)
       end
 
       # Declare a helper:
@@ -124,13 +119,5 @@ module ActionController #:nodoc:
           end
         end        
     end
-
-    private
-      # Extend the template class instance with our controller's helper module.
-      def initialize_template_class_with_helper(response)
-        returning(initialize_template_class_without_helper(response)) do
-          response.template.extend self.class.master_helper_module
-        end
-      end
   end
 end

data/lib/action_controller/layout.rb

@@ -194,65 +194,76 @@ module ActionController #:nodoc:
     # weblog/standard, but <tt>layout "standard"</tt> will return layouts/standard.
     def active_layout(passed_layout = nil)
       layout = passed_layout || self.class.read_inheritable_attribute("layout")
+
       active_layout = case layout
         when Symbol then send(layout)
         when Proc   then layout.call(self)
         when String then layout
       end
+
       active_layout.include?("/") ? active_layout : "layouts/#{active_layout}" if active_layout
     end
 
-    def render_with_a_layout(options = {}, deprecated_status = nil, deprecated_layout = nil) #:nodoc:
-      options = render_with_a_layout_options(options)
-      if (layout = pick_layout(options, deprecated_layout))
-        logger.info("Rendering #{options[:template]} within #{layout}") unless logger.nil?
+    def render_with_a_layout(options = nil, deprecated_status = nil, deprecated_layout = nil) #:nodoc:
+      template_with_options = options.is_a?(Hash)
 
-        @content_for_layout = render_with_no_layout(options.merge(:layout => false))
-        erase_render_results
+      if apply_layout?(template_with_options, options) && (layout = pick_layout(template_with_options, options, deprecated_layout))
+        options = options.merge :layout => false if template_with_options
+        logger.info("Rendering #{options} within #{layout}") if logger
+
+        if template_with_options
+          content_for_layout = render_with_no_layout(options)
+          deprecated_status = options[:status] || deprecated_status
+        else
+          content_for_layout = render_with_no_layout(options, deprecated_status)
+        end
 
-        add_variables_to_assigns
-        render_with_no_layout(options.merge({ :text => @template.render_file(layout, true), :status => options[:status] || deprecated_status }))
+        erase_render_results
+        @template.instance_variable_set("@content_for_layout", content_for_layout)
+        render_text(@template.render_file(layout, true), deprecated_status)
       else
         render_with_no_layout(options, deprecated_status)
       end
     end
 
     private
-      def render_with_a_layout_options(options)
-        return { :template => options } unless options.is_a?(Hash)
-        if options.values_at(:text, :file, :inline, :partial, :nothing).compact.empty?
-          options
+      def apply_layout?(template_with_options, options)
+        if template_with_options
+          (options.has_key?(:layout) && options[:layout]!=false) || options.values_at(:text, :file, :inline, :partial, :nothing).compact.empty?
         else
-          { :layout => false }.merge(options)
+          true
         end
       end
 
-      def pick_layout(options = {}, deprecated_layout = nil)
-        return deprecated_layout if !deprecated_layout.nil?
-
-        if options.is_a?(Hash)
-          case options[:layout]
+      def pick_layout(template_with_options, options, deprecated_layout)
+        if deprecated_layout
+          deprecated_layout
+        elsif template_with_options
+          case layout = options[:layout]
             when FalseClass
               nil
             when NilClass, TrueClass
               active_layout if action_has_layout?
             else
-              active_layout(options[:layout])
+              active_layout(layout)
           end
         else
-          (deprecated_layout || active_layout) if action_has_layout?
+          active_layout if action_has_layout?
         end
       end
-    
+
       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
+        if conditions = self.class.layout_conditions
+          case
+            when only = conditions[:only]
+              only.include?(action_name)
+            when except = conditions[:except]
+              !except.include?(action_name) 
+            else
+              true
+          end
+        else
+          true
         end
       end
   end

data/lib/action_controller/macros/auto_complete.rb

@@ -0,0 +1,52 @@
+module ActionController
+  # Macros are class-level calls that add pre-defined actions to the controller based on the parameters passed in.
+  # Currently, they're used to bridge the JavaScript macros, like autocompletion and in-place editing, with the controller
+  # backing.
+  module Macros
+    module AutoComplete #:nodoc:
+      def self.append_features(base) #:nodoc:
+        super
+        base.extend(ClassMethods)
+      end
+
+      # Example:
+      #
+      #   # Controller
+      #   class BlogController < ApplicationController
+      #     auto_complete_for :post, :title
+      #   end
+      #
+      #   # View
+      #   <%= text_field_with_auto_complete :post, title %>
+      #
+      # By default, auto_complete_for limits the results to 10 entries,
+      # and sorts by the given field.
+      # 
+      # auto_complete_for takes a third parameter, an options hash to
+      # the find method used to search for the records:
+      #
+      #   auto_complete_for :post, :title, :limit => 15, :order => 'created_at DESC'
+      #
+      # For help on defining text input fields with autocompletion, 
+      # see ActionView::Helpers::JavaScriptHelper.
+      #
+      # For more examples, see script.aculo.us:
+      # * http://script.aculo.us/demos/ajax/autocompleter
+      # * http://script.aculo.us/demos/ajax/autocompleter_customized
+      module ClassMethods
+        def auto_complete_for(object, method, options = {})
+          define_method("auto_complete_for_#{object}_#{method}") do
+            find_options = { 
+              :conditions => [ "LOWER(#{method}) LIKE ?", '%' + params[object][method].downcase + '%' ], 
+              :order => "#{method} ASC",
+              :limit => 10 }.merge!(options)
+            
+            @items = object.to_s.camelize.constantize.find(:all, find_options)
+
+            render :inline => "<%= auto_complete_result @items, '#{method}' %>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_controller/macros/in_place_editing.rb

@@ -0,0 +1,32 @@
+module ActionController
+  module Macros
+    module InPlaceEditing #:nodoc:
+      def self.append_features(base) #:nodoc:
+        super
+        base.extend(ClassMethods)
+      end
+
+      # Example:
+      #
+      #   # Controller
+      #   class BlogController < ApplicationController
+      #     in_place_edit_for :post, :title
+      #   end
+      #
+      #   # View
+      #   <%= in_place_editor_field :post, title %>
+      #
+      # For help on defining an in place editor in the browser,
+      # see ActionView::Helpers::JavaScriptHelper.
+      module ClassMethods
+        def in_place_edit_for(object, attribute, options = {})
+          define_method("set_#{object}_#{attribute}") do
+            @item = object.to_s.camelize.constantize.find(params[:id])
+            @item.update_attribute(attribute, params[:value])
+            render :text => @item.send(attribute)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_controller/pagination.rb

@@ -21,7 +21,7 @@ module ActionController
   #   class PersonController < ApplicationController   
   #     model :person
   #
-  #     paginate :people, :order_by => 'last_name, first_name',
+  #     paginate :people, :order => 'last_name, first_name',
   #              :per_page => 20
   #     
   #     # ...
@@ -37,7 +37,7 @@ module ActionController
   #
   #   def list
   #     @person_pages, @people =
-  #       paginate :people, :order_by => 'last_name, first_name'
+  #       paginate :people, :order => 'last_name, first_name'
   #   end
   #
   # Like the previous example, but explicitly creates <tt>@person_pages</tt>
@@ -48,8 +48,8 @@ module ActionController
   #
   #   def list
   #     @person_pages = Paginator.new self, Person.count, 10, @params['page']
-  #     @people = Person.find_all nil, 'last_name, first_name', 
-  #               @person_pages.current.to_sql
+  #     @people = Person.find :all, :order => 'last_name, first_name', 
+  #               :conditions => @person_pages.current.to_sql
   #   end
   # 
   # Explicitly creates the paginator from the previous example and uses 
@@ -63,10 +63,15 @@ module ActionController
       # The default options for pagination
       DEFAULT_OPTIONS = {
         :class_name => nil,
+        :singular_name => nil,
         :per_page   => 10,
         :conditions => nil,
         :order_by   => nil,
+        :order      => nil,
         :join       => nil,
+        :joins      => nil,
+        :include    => nil,
+        :select     => nil,
         :parameter  => 'page'
       }
     end
@@ -87,7 +92,7 @@ module ActionController
             "Unknown options: #{unknown_option_keys.join(', ')}" unless
               unknown_option_keys.empty?
 
-      options[:singular_name] = Inflector.singularize(collection_id.to_s)
+      options[:singular_name] ||= Inflector.singularize(collection_id.to_s)
       options[:class_name]  ||= Inflector.camelize(options[:singular_name])
     end
 
@@ -97,14 +102,21 @@ module ActionController
     # ClassMethods#paginate.
     #
     # +options+ are:
-    # <tt>:class_name</tt>:: the class name to use, if it can't be inferred by
+    # <tt>:singular_name</tt>:: the singular name to use, if it can't be inferred by
     #                        singularizing the collection name
+    # <tt>:class_name</tt>:: the class name to use, if it can't be inferred by
+    #                        camelizing the singular name
     # <tt>:per_page</tt>::   the maximum number of items to include in a 
     #                        single page. Defaults to 10
-    # <tt>:conditions</tt>:: optional conditions passed to Model.find_all and
+    # <tt>:conditions</tt>:: optional conditions passed to Model.find(:all, *params) and
     #                        Model.count
-    # <tt>:order_by</tt>::   optional order parameter passed to Model.find_all
-    # <tt>:join</tt>::       optional join parameter passed to Model.find_all
+    # <tt>:order</tt>::      optional order parameter passed to Model.find(:all, *params)
+    # <tt>:order_by</tt>::   (deprecated, used :order) optional order parameter passed to Model.find(:all, *params)
+    # <tt>:joins</tt>::      optional joins parameter passed to Model.find(:all, *params)
+    #                        and Model.count
+    # <tt>:join</tt>::       (deprecated, used :joins or :include) optional join parameter passed to Model.find(:all, *params)
+    #                        and Model.count
+    # <tt>:include</tt>::    optional eager loading parameter passed to Model.find(:all, *params)
     #                        and Model.count
     def paginate(collection_id, options={})
       Pagination.validate_options!(collection_id, options, true)
@@ -154,11 +166,15 @@ module ActionController
       model.count(conditions,joins)
     end
   
-    # Returns a collection of items for the given +model+ and +conditions+,
-    # ordered by +order_by+, for the current page in the given +paginator+.
+    # Returns a collection of items for the given +model+ and +options[conditions]+,
+    # ordered by +options[order]+, for the current page in the given +paginator+.
     # Override this method to implement a custom finder.
-    def find_collection_for_pagination(model, conditions, order_by, join, paginator)
-      model.find_all(conditions, order_by, paginator.current.to_sql, join)
+    def find_collection_for_pagination(model, options, paginator)
+      model.find(:all, :conditions => options[:conditions],
+                 :order => options[:order_by] || options[:order],
+                 :joins => options[:join] || options[:joins], :include => options[:include],
+                 :select => options[:select], :limit => options[:per_page],
+                 :offset => paginator.current.offset)
     end
   
     protected :create_paginators_and_retrieve_collections,
@@ -168,12 +184,11 @@ module ActionController
     def paginator_and_collection_for(collection_id, options) #:nodoc:
       klass = options[:class_name].constantize
       page  = @params[options[:parameter]]
-      count = count_collection_for_pagination(klass, options[:conditions], options[:join])
+      count = count_collection_for_pagination(klass, options[:conditions],
+                                              options[:join] || options[:joins])
 
       paginator = Paginator.new(self, count, options[:per_page], page)
-      
-      collection = find_collection_for_pagination(klass,
-        options[:conditions], options[:order_by], options[:join], paginator)
+      collection = find_collection_for_pagination(klass, options, paginator)
       
       return paginator, collection 
     end
@@ -196,6 +211,7 @@ module ActionController
         @controller = controller
         @item_count = item_count || 0
         @items_per_page = items_per_page
+        @pages = {}
         
         self.current_page = current_page
       end
@@ -210,44 +226,44 @@ module ActionController
             page.paginator == self
         end
         page = page.to_i
-        @current_page = has_page_number?(page) ? page : 1
+        @current_page_number = has_page_number?(page) ? page : 1
       end
 
       # Returns a Page object representing this paginator's current page.
       def current_page
-        self[@current_page]
+        @current_page ||= self[@current_page_number]
       end
       alias current :current_page
 
       # Returns a new Page representing the first page in this paginator.
       def first_page
-        self[1]
+        @first_page ||= self[1]
       end
       alias first :first_page
 
       # Returns a new Page representing the last page in this paginator.
       def last_page
-        self[page_count] 
+        @last_page ||= self[page_count] 
       end
       alias last :last_page
 
       # Returns the number of pages in this paginator.
       def page_count
-        return 1 if @item_count.zero?
-        (@item_count / @items_per_page.to_f).ceil
+        @page_count ||= @item_count.zero? ? 1 :
+                          (q,r=@item_count.divmod(@items_per_page); r==0? q : q+1)
       end
+
       alias length :page_count
 
       # Returns true if this paginator contains the page of index +number+.
       def has_page_number?(number)
-        return false unless number.is_a? Fixnum
         number >= 1 and number <= page_count
       end
 
       # Returns a new Page representing the page with the given index
       # +number+.
       def [](number)
-        Page.new(self, number)
+        @pages[number] ||= Page.new(self, number)
       end
 
       # Successively yields all the paginator's pages to the given block.
@@ -318,13 +334,13 @@ module ActionController
         # Returns a new Page object representing the page just before this
         # page, or nil if this is the first page.
         def previous
-          if first? then nil else Page.new(@paginator, @number - 1) end
+          if first? then nil else @paginator[@number - 1] end
         end
 
         # Returns a new Page object representing the page just after this
         # page, or nil if this is the last page.
         def next
-          if last? then nil else Page.new(@paginator, @number + 1) end
+          if last? then nil else @paginator[@number + 1] end
         end
 
         # Returns a new Window object for this page with the specified 
@@ -368,7 +384,7 @@ module ActionController
 
         # Returns an array of Page objects in the current window.
         def pages
-          (@first.number..@last.number).to_a.map {|n| @paginator[n]}
+          (@first.number..@last.number).to_a.collect! {|n| @paginator[n]}
         end
         alias to_a :pages
       end

data/lib/action_controller/request.rb

@@ -51,30 +51,31 @@ module ActionController
     # For backward compatibility, the post format is extracted from the
     # X-Post-Data-Format HTTP header if present.
     def post_format
-      if env['HTTP_X_POST_DATA_FORMAT']
-        env['HTTP_X_POST_DATA_FORMAT'].downcase.to_sym
-      else
-        case env['CONTENT_TYPE'].to_s.downcase
-          when 'application/xml', 'text/xml'        then :xml
-          when 'application/x-yaml', 'text/x-yaml'  then :yaml
-          else :url_encoded
-        end
-      end
+      @post_format ||=
+           if env['HTTP_X_POST_DATA_FORMAT']
+             env['HTTP_X_POST_DATA_FORMAT'].downcase.to_sym
+           else
+             case env['CONTENT_TYPE'].to_s.downcase
+             when 'application/xml', 'text/xml'        then :xml
+             when 'application/x-yaml', 'text/x-yaml'  then :yaml
+             else :url_encoded
+             end
+           end
     end
 
     # Is this a POST request formatted as XML or YAML?
     def formatted_post?
-      [ :xml, :yaml ].include?(post_format) && post?
+      post? && (post_format == :xml || post_format == :yaml)
     end
 
     # Is this a POST request formatted as XML?
     def xml_post?
-      post_format == :xml && post?
+      post? && post_format == :xml
     end
 
     # Is this a POST request formatted as YAML?
     def yaml_post?
-      post_format == :yaml && post?
+      post? && post_format == :yaml
     end
 
     # Returns true if the request's "X-Requested-With" header contains
@@ -102,12 +103,14 @@ module ActionController
         return remote_ips.first.strip unless remote_ips.empty?
       end
 
-      return env['REMOTE_ADDR']
+      env['REMOTE_ADDR']
     end
 
     # Returns the domain part of a host, such as rubyonrails.org in "www.rubyonrails.org". You can specify
     # a different <tt>tld_length</tt>, such as 2 to catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
     def domain(tld_length = 1)
+      return nil if !/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/.match(host).nil? or host.nil?
+        
       host.split('.').last(1 + tld_length).join('.')
     end
 
@@ -115,8 +118,9 @@ module ActionController
     # You can specify a different <tt>tld_length</tt>, such as 2 to catch ["www"] instead of ["www", "rubyonrails"]
     # in "www.rubyonrails.co.uk".
     def subdomains(tld_length = 1)
+      return [] unless host
       parts = host.split('.')
-      parts - parts.last(1 + tld_length)
+      parts[0..-(tld_length+2)]
     end
 
     # Receive the raw post data. 
@@ -126,26 +130,30 @@ module ActionController
       env['RAW_POST_DATA']
     end
     
+    # Returns the request URI correctly, taking into account the idiosyncracies
+    # of the various servers.
     def request_uri
-      unless env['REQUEST_URI'].nil?
-        (%r{^\w+\://[^/]+(/.*|$)$} =~ env['REQUEST_URI']) ? $1 : env['REQUEST_URI'] # Remove domain, which webrick puts into the request_uri.
+      if uri = env['REQUEST_URI']
+        (%r{^\w+\://[^/]+(/.*|$)$} =~ uri) ? $1 : uri # Remove domain, which webrick puts into the request_uri.
       else  # REQUEST_URI is blank under IIS - get this from PATH_INFO and SCRIPT_NAME
-        script_filename = env["SCRIPT_NAME"].to_s.match(%r{[^/]+$})
-        request_uri = env["PATH_INFO"]
-        request_uri.sub!(/#{script_filename}\//, '') unless script_filename.nil?
-        request_uri += '?' + env["QUERY_STRING"] unless env["QUERY_STRING"].nil? || env["QUERY_STRING"].empty?
-        return request_uri
+        script_filename = env['SCRIPT_NAME'].to_s.match(%r{[^/]+$})
+        uri = env['PATH_INFO']
+        uri = uri.sub(/#{script_filename}\//, '') unless script_filename.nil?
+        unless (env_qs = env['QUERY_STRING']).nil? || env_qs.empty?
+          uri << '?' << env_qs
+        end
+        uri
       end
     end
 
     # Return 'https://' if this is an SSL request and 'http://' otherwise.
     def protocol
-      env["HTTPS"] == "on" ? 'https://' : 'http://'
+      ssl? ? 'https://' : 'http://'
     end
 
     # Is this an SSL request?
     def ssl?
-      protocol == 'https://'
+      env['HTTPS'] == 'on' 
     end
   
     # Returns the interpreted path to requested resource after all the installation directory of this application was taken into account
@@ -153,34 +161,40 @@ module ActionController
       path = (uri = request_uri) ? uri.split('?').first : ''
 
       # Cut off the path to the installation directory if given
-      if root = relative_url_root
-        path[root.length..-1]
-      else
-        path
-      end
-    end    
+      root = relative_url_root
+      path[0, root.length] = '' if root
+      path || ''
+    end
     
     # Returns the path minus the web server relative installation directory.
     # This method returns nil unless the web server is apache.
     def relative_url_root
-      @@relative_url_root ||= File.dirname(env["SCRIPT_NAME"].to_s).gsub(/(^\.$|^\/$)/, '') if server_software == 'apache'
+      @@relative_url_root ||= server_software == 'apache' ? File.dirname(env["SCRIPT_NAME"].to_s).gsub(/(^\.$|^\/$)/, '') : ''
     end
 
     # Returns the port number of this request as an integer.
     def port
-      env['SERVER_PORT'].to_i
+      @port_as_int ||= env['SERVER_PORT'].to_i
+    end
+    
+    # Returns the standard port number for this request's protocol
+    def standard_port
+      case protocol
+        when 'https://' then 443
+        else 80
+      end
     end
 
     # Returns a port suffix like ":8080" if the port number of this request
     # is not the default HTTP port 80 or HTTPS port 443.
     def port_string
-      (protocol == 'http://' && port == 80) || (protocol == 'https://' && port == 443) ? '' : ":#{port}"
+      (port == standard_port) ? '' : ":#{port}"
     end
 
     # Returns a host:port string for this request, such as example.com or
     # example.com:8080.
     def host_with_port
-      env['HTTP_HOST'] || host + port_string
+      host + port_string
     end
   
     def path_parameters=(parameters)
@@ -204,25 +218,25 @@ module ActionController
     #--
     # Must be implemented in the concrete request
     #++
-    def query_parameters
+    def query_parameters #:nodoc:
     end
 
-    def request_parameters
+    def request_parameters #:nodoc:
     end
 
-    def env
+    def env #:nodoc:
     end
 
-    def host
+    def host #:nodoc:
     end
 
-    def cookies
+    def cookies #:nodoc:
     end
 
-    def session
+    def session #:nodoc:
     end
 
-    def reset_session
+    def reset_session #:nodoc:
     end    
   end
 end