Checkout of Instiki Trunk 1/21/2007.

vendor/rails/actionpack/lib/action_controller/cgi_ext/cgi_ext.rb

@@ -0,0 +1,43 @@
+require 'cgi'
+require 'cgi/session'
+require 'cgi/session/pstore'
+require 'action_controller/cgi_ext/cgi_methods'
+
+# Wrapper around the CGIMethods that have been secluded to allow testing without 
+# an instantiated CGI object
+class CGI #:nodoc:
+  class << self
+    alias :escapeHTML_fail_on_nil :escapeHTML
+
+    def escapeHTML(string)
+      escapeHTML_fail_on_nil(string) unless string.nil?
+    end
+  end
+  
+  # Returns a parameter hash including values from both the request (POST/GET)
+  # and the query string with the latter taking precedence.
+  def parameters
+    request_parameters.update(query_parameters)
+  end
+
+  def query_parameters
+    CGIMethods.parse_query_parameters(query_string)
+  end
+
+  def request_parameters
+    CGIMethods.parse_request_parameters(params, env_table)
+  end
+
+  def redirect(where)
+     header({ 
+       "Status" => "302 Moved", 
+       "location" => "#{where}"
+    })
+  end
+  
+  def session(parameters = nil)
+    parameters = {} if parameters.nil?
+    parameters['database_manager'] = CGI::Session::PStore
+    CGI::Session.new(self, parameters)
+  end
+end

vendor/rails/actionpack/lib/action_controller/cgi_ext/cgi_methods.rb

@@ -0,0 +1,217 @@
+require 'cgi'
+require 'action_controller/vendor/xml_simple'
+require 'action_controller/vendor/xml_node'
+
+# Static methods for parsing the query and request parameters that can be used in
+# a CGI extension class or testing in isolation.
+class CGIMethods #:nodoc:
+  public
+    # Returns a hash with the pairs from the query string. The implicit hash construction that is done in
+    # parse_request_params is not done here.
+    def CGIMethods.parse_query_parameters(query_string)
+      parsed_params = {}
+  
+      query_string.split(/[&;]/).each { |p| 
+        # Ignore repeated delimiters.
+        next if p.empty?
+
+        k, v = p.split('=',2)
+        v = nil if (v && v.empty?)
+
+        k = CGI.unescape(k) if k
+        v = CGI.unescape(v) if v
+
+        unless k.include?(?[)
+          parsed_params[k] = v
+        else
+          keys = split_key(k)
+          last_key = keys.pop
+          last_key = keys.pop if (use_array = last_key.empty?)
+          parent = keys.inject(parsed_params) {|h, k| h[k] ||= {}}
+          
+          if use_array then (parent[last_key] ||= []) << v
+          else parent[last_key] = v
+          end
+        end
+      }
+  
+      parsed_params
+    end
+
+    # Returns the request (POST/GET) parameters in a parsed form where pairs such as "customer[address][street]" / 
+    # "Somewhere cool!" are translated into a full hash hierarchy, like
+    # { "customer" => { "address" => { "street" => "Somewhere cool!" } } }
+    def CGIMethods.parse_request_parameters(params)
+      parsed_params = {}
+
+      for key, value in params
+        value = [value] if key =~ /.*\[\]$/
+        unless key.include?('[')
+          # much faster to test for the most common case first (GET)
+          # and avoid the call to build_deep_hash
+          parsed_params[key] = get_typed_value(value[0])
+        else
+          build_deep_hash(get_typed_value(value[0]), parsed_params, get_levels(key))
+        end
+      end
+    
+      parsed_params
+    end
+
+    def self.parse_formatted_request_parameters(mime_type, raw_post_data)
+      params = case strategy = ActionController::Base.param_parsers[mime_type]
+        when Proc
+          strategy.call(raw_post_data)
+        when :xml_simple
+          raw_post_data.blank? ? nil :
+            typecast_xml_value(XmlSimple.xml_in(raw_post_data,
+              'forcearray'   => false,
+              'forcecontent' => true,
+              'keeproot'     => true,
+              'contentkey'   => '__content__'))
+        when :yaml
+          YAML.load(raw_post_data)
+        when :xml_node
+          node = XmlNode.from_xml(raw_post_data)
+          { node.node_name => node }
+      end
+      
+      dasherize_keys(params || {})
+    rescue Object => e
+      { "exception" => "#{e.message} (#{e.class})", "backtrace" => e.backtrace, 
+        "raw_post_data" => raw_post_data, "format" => mime_type }
+    end
+
+    def self.typecast_xml_value(value)
+      case value
+      when Hash
+        if value.has_key?("__content__")
+          content = translate_xml_entities(value["__content__"])
+          case value["type"]
+          when "integer"  then content.to_i
+          when "boolean"  then content == "true"
+          when "datetime" then Time.parse(content)
+          when "date"     then Date.parse(content)
+          else                 content
+          end
+        else
+          value.empty? ? nil : value.inject({}) do |h,(k,v)|
+            h[k] = typecast_xml_value(v)
+            h
+          end
+        end
+      when Array
+        value.map! { |i| typecast_xml_value(i) }
+        case value.length
+        when 0 then nil
+        when 1 then value.first
+        else value
+        end
+      else
+        raise "can't typecast #{value.inspect}"
+      end
+    end
+
+  private
+
+    def self.translate_xml_entities(value)
+      value.gsub(/&lt;/,   "<").
+            gsub(/&gt;/,   ">").
+            gsub(/&quot;/, '"').
+            gsub(/&apos;/, "'").
+            gsub(/&amp;/,  "&")
+    end
+
+    def self.dasherize_keys(params)
+      case params.class.to_s
+      when "Hash"
+        params.inject({}) do |h,(k,v)|
+          h[k.to_s.tr("-", "_")] = dasherize_keys(v)
+          h
+        end
+      when "Array"
+        params.map { |v| dasherize_keys(v) }
+      else
+        params
+      end
+    end
+
+    # Splits the given key into several pieces. Example keys are 'name', 'person[name]',
+    # 'person[name][first]', and 'people[]'. In each instance, an Array instance is returned.
+    # 'person[name][first]' produces ['person', 'name', 'first']; 'people[]' produces ['people', '']
+    def CGIMethods.split_key(key)
+      if /^([^\[]+)((?:\[[^\]]*\])+)$/ =~ key
+        keys = [$1]
+        
+        keys.concat($2[1..-2].split(']['))
+        keys << '' if key[-2..-1] == '[]' # Have to add it since split will drop empty strings
+        
+        keys
+      else
+        [key]
+      end
+    end
+    
+    def CGIMethods.get_typed_value(value)
+      # test most frequent case first
+      if value.is_a?(String)
+        value
+      elsif value.respond_to?(:content_type) && ! value.content_type.blank?
+        # Uploaded file
+        unless value.respond_to?(:full_original_filename)
+          class << value
+            alias_method :full_original_filename, :original_filename
+
+            # Take the basename of the upload's original filename.
+            # This handles the full Windows paths given by Internet Explorer
+            # (and perhaps other broken user agents) without affecting
+            # those which give the lone filename.
+            # The Windows regexp is adapted from Perl's File::Basename.
+            def original_filename
+              if md = /^(?:.*[:\\\/])?(.*)/m.match(full_original_filename)
+                md.captures.first
+              else
+                File.basename full_original_filename
+              end
+            end
+          end
+        end
+
+        # Return the same value after overriding original_filename.
+        value
+
+      elsif value.respond_to?(:read)
+        # Value as part of a multipart request
+        value.read
+      elsif value.class == Array
+        value.collect { |v| CGIMethods.get_typed_value(v) }
+      else
+        # other value (neither string nor a multipart request)
+        value.to_s
+      end
+    end
+  
+    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
+    end
+
+    def CGIMethods.build_deep_hash(value, hash, levels)
+      if levels.length == 0
+        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

vendor/rails/actionpack/lib/action_controller/cgi_ext/cookie_performance_fix.rb

@@ -0,0 +1,125 @@
+CGI.module_eval { remove_const "Cookie" }
+
+class CGI #:nodoc:
+  # This is a cookie class that fixes the performance problems with the default one that ships with 1.8.1 and below.
+  # It replaces the inheritance on SimpleDelegator with DelegateClass(Array) following the suggestion from Matz on
+  # http://groups.google.com/groups?th=e3a4e68ba042f842&seekm=c3sioe%241qvm%241%40news.cybercity.dk#link14
+  class Cookie < DelegateClass(Array)
+    # Create a new CGI::Cookie object.
+    #
+    # The contents of the cookie can be specified as a +name+ and one
+    # or more +value+ arguments.  Alternatively, the contents can
+    # be specified as a single hash argument.  The possible keywords of
+    # this hash are as follows:
+    #
+    # name:: the name of the cookie.  Required.
+    # value:: the cookie's value or list of values.
+    # path:: the path for which this cookie applies.  Defaults to the
+    #        base directory of the CGI script.
+    # domain:: the domain for which this cookie applies.
+    # expires:: the time at which this cookie expires, as a +Time+ object.
+    # secure:: whether this cookie is a secure cookie or not (default to
+    #          false).  Secure cookies are only transmitted to HTTPS 
+    #          servers.
+    #
+    # These keywords correspond to attributes of the cookie object.
+    def initialize(name = '', *value)
+      if name.kind_of?(String)
+        @name = name
+        @value = Array(value)
+        @domain = nil
+        @expires = nil
+        @secure = false
+        @path = nil
+      else
+        @name = name['name']
+        @value = Array(name['value'])
+        @domain = name['domain']
+        @expires = name['expires']
+        @secure = name['secure'] || false
+        @path = name['path']
+      end
+      
+      unless @name
+        raise ArgumentError, "`name' required"
+      end
+
+      # simple support for IE
+      unless @path
+        %r|^(.*/)|.match(ENV['SCRIPT_NAME'])
+        @path = ($1 or '')
+      end
+
+      super(@value)
+    end
+
+    def __setobj__(obj)
+      @_dc_obj = obj
+    end
+
+    attr_accessor("name", "value", "path", "domain", "expires")
+    attr_reader("secure")
+
+    # Set whether the Cookie is a secure cookie or not.
+    #
+    # +val+ must be a boolean.
+    def secure=(val)
+      @secure = val if val == true or val == false
+      @secure
+    end
+
+    # Convert the Cookie to its string representation.
+    def to_s
+      buf = ""
+      buf << @name << '='
+
+      if @value.kind_of?(String)
+        buf << CGI::escape(@value)
+      else
+        buf << @value.collect{|v| CGI::escape(v) }.join("&")
+      end
+
+      if @domain
+        buf << '; domain=' << @domain
+      end
+
+      if @path
+        buf << '; path=' << @path
+      end
+
+      if @expires
+        buf << '; expires=' << CGI::rfc1123_date(@expires)
+      end
+
+      if @secure == true
+        buf << '; secure'
+      end
+
+      buf
+    end
+
+    # Parse a raw cookie string into a hash of cookie-name=>Cookie
+    # pairs.
+    #
+    #   cookies = CGI::Cookie::parse("raw_cookie_string")
+    #     # { "name1" => cookie1, "name2" => cookie2, ... }
+    #
+    def self.parse(raw_cookie)
+      cookies = Hash.new([])
+
+      if raw_cookie
+        raw_cookie.split(/; ?/).each do |pairs|
+          name, values = pairs.split('=',2)
+          next unless name and values
+          name = CGI::unescape(name)
+          values = values.split('&').collect!{|v| CGI::unescape(v) }
+          unless cookies.has_key?(name)
+            cookies[name] = new(name, *values)
+          end
+        end
+      end
+
+      cookies
+    end
+  end # class Cookie
+end

vendor/rails/actionpack/lib/action_controller/cgi_ext/raw_post_data_fix.rb

@@ -0,0 +1,74 @@
+class CGI #:nodoc:
+  # Add @request.env['RAW_POST_DATA'] for the vegans.
+  module QueryExtension
+    # Initialize the data from the query.
+    #
+    # Handles multipart forms (in particular, forms that involve file uploads).
+    # Reads query parameters in the @params field, and cookies into @cookies.
+    def initialize_query()
+      @cookies = CGI::Cookie::parse(env_table['HTTP_COOKIE'] || env_table['COOKIE'])
+
+      #fix some strange request environments
+      if method = env_table['REQUEST_METHOD']
+        method = method.to_s.downcase.intern
+      else
+        method = :get
+      end
+
+      if method == :post && (boundary = multipart_form_boundary)
+        @multipart = true
+        @params = read_multipart(boundary, Integer(env_table['CONTENT_LENGTH']))
+      else
+        @multipart = false
+        @params = CGI::parse(read_query_params(method) || "")
+      end
+    end
+
+    private
+      unless defined?(MULTIPART_FORM_BOUNDARY_RE)
+        MULTIPART_FORM_BOUNDARY_RE = %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n #"
+      end
+
+      def multipart_form_boundary
+        MULTIPART_FORM_BOUNDARY_RE.match(env_table['CONTENT_TYPE']).to_a.pop
+      end
+
+      if defined? MOD_RUBY
+        def read_params_from_query
+          Apache::request.args || ''
+        end
+      else
+        def read_params_from_query
+          # fixes CGI querystring parsing for lighttpd
+          env_qs = env_table['QUERY_STRING']
+          if env_qs.blank? && !(uri = env_table['REQUEST_URI']).blank?
+            uri.split('?', 2)[1] || ''
+          else
+            env_qs
+          end
+        end
+      end
+
+      def read_params_from_post
+        stdinput.binmode if stdinput.respond_to?(:binmode)
+        content = stdinput.read(Integer(env_table['CONTENT_LENGTH'])) || ''
+        # fix for Safari Ajax postings that always append \000
+        content.chop! if content[-1] == 0
+        content.gsub! /&_=$/, ''
+        env_table['RAW_POST_DATA'] = content.freeze
+      end
+
+      def read_query_params(method)
+        case method
+          when :get
+            read_params_from_query
+          when :post, :put
+            read_params_from_post
+          when :cmd
+            read_from_cmdline
+          else # when :head, :delete, :options
+            read_params_from_query
+        end
+      end
+  end # module QueryExtension
+end