jstorimer-deep-test 0.1.0

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

@@ -0,0 +1,211 @@
+require 'cgi'
+require 'action_controller/vendor/xml_node'
+require 'strscan'
+
+# 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:
+  class << self
+    # DEPRECATED: Use parse_form_encoded_parameters
+    def parse_query_parameters(query_string)
+      pairs = query_string.split('&').collect do |chunk|
+        next if chunk.empty?
+        key, value = chunk.split('=', 2)
+        next if key.empty?
+        value = (value.nil? || value.empty?) ? nil : CGI.unescape(value)
+        [ CGI.unescape(key), value ]
+      end.compact
+
+      FormEncodedPairParser.new(pairs).result
+    end
+
+    # DEPRECATED: Use parse_form_encoded_parameters
+    def parse_request_parameters(params)
+      parser = FormEncodedPairParser.new
+
+      params = params.dup
+      until params.empty?
+        for key, value in params
+          if key.blank?
+            params.delete key
+          elsif !key.include?('[')
+            # much faster to test for the most common case first (GET)
+            # and avoid the call to build_deep_hash
+            parser.result[key] = get_typed_value(value[0])
+            params.delete key
+          elsif value.is_a?(Array)
+            parser.parse(key, get_typed_value(value.shift))
+            params.delete key if value.empty?
+          else
+            raise TypeError, "Expected array, found #{value.inspect}"
+          end
+        end
+      end
+    
+      parser.result
+    end
+
+    def parse_formatted_request_parameters(mime_type, raw_post_data)
+      case strategy = ActionController::Base.param_parsers[mime_type]
+        when Proc
+          strategy.call(raw_post_data)
+        when :xml_simple
+          raw_post_data.blank? ? {} : Hash.from_xml(raw_post_data)
+        when :yaml
+          YAML.load(raw_post_data)
+        when :xml_node
+          node = XmlNode.from_xml(raw_post_data)
+          { node.node_name => node }
+      end
+    rescue Exception => e # YAML, XML or Ruby code block errors
+      { "exception" => "#{e.message} (#{e.class})", "backtrace" => e.backtrace, 
+        "raw_post_data" => raw_post_data, "format" => mime_type }
+    end
+
+    private
+      def get_typed_value(value)
+        case value
+          when String
+            value
+          when NilClass
+            ''
+          when Array
+            value.map { |v| get_typed_value(v) }
+          else
+            # Uploaded file provides content type and filename.
+            if value.respond_to?(:content_type) &&
+                  !value.content_type.blank? &&
+                  !value.original_filename.blank?
+              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
+
+            # Multipart values may have content type, but no filename.
+            elsif value.respond_to?(:read)
+              result = value.read
+              value.rewind
+              result
+
+            # Unknown value, neither string nor multipart.
+            else
+              raise "Unknown form value: #{value.inspect}"
+            end
+        end
+      end
+  end
+
+  class FormEncodedPairParser < StringScanner #:nodoc:
+    attr_reader :top, :parent, :result
+
+    def initialize(pairs = [])
+      super('')
+      @result = {}
+      pairs.each { |key, value| parse(key, value) }
+    end
+     
+    KEY_REGEXP = %r{([^\[\]=&]+)}
+    BRACKETED_KEY_REGEXP = %r{\[([^\[\]=&]+)\]}
+    
+    # Parse the query string
+    def parse(key, value)
+      self.string = key
+      @top, @parent = result, nil
+      
+      # First scan the bare key
+      key = scan(KEY_REGEXP) or return
+      key = post_key_check(key)
+            
+      # Then scan as many nestings as present
+      until eos? 
+        r = scan(BRACKETED_KEY_REGEXP) or return
+        key = self[1]
+        key = post_key_check(key)
+      end
+ 
+      bind(key, value)
+    end
+
+    private
+      # After we see a key, we must look ahead to determine our next action. Cases:
+      # 
+      #   [] follows the key. Then the value must be an array.
+      #   = follows the key. (A value comes next)
+      #   & or the end of string follows the key. Then the key is a flag.
+      #   otherwise, a hash follows the key. 
+      def post_key_check(key)
+        if scan(/\[\]/) # a[b][] indicates that b is an array
+          container(key, Array)
+          nil
+        elsif check(/\[[^\]]/) # a[b] indicates that a is a hash
+          container(key, Hash)
+          nil
+        else # End of key? We do nothing.
+          key
+        end
+      end
+    
+      # Add a container to the stack.
+      # 
+      def container(key, klass)
+        type_conflict! klass, top[key] if top.is_a?(Hash) && top.key?(key) && ! top[key].is_a?(klass)
+        value = bind(key, klass.new)
+        type_conflict! klass, value unless value.is_a?(klass)
+        push(value)
+      end
+    
+      # Push a value onto the 'stack', which is actually only the top 2 items.
+      def push(value)
+        @parent, @top = @top, value
+      end
+    
+      # Bind a key (which may be nil for items in an array) to the provided value.
+      def bind(key, value)
+        if top.is_a? Array
+          if key
+            if top[-1].is_a?(Hash) && ! top[-1].key?(key)
+              top[-1][key] = value
+            else
+              top << {key => value}.with_indifferent_access
+              push top.last
+            end
+          else
+            top << value
+          end
+        elsif top.is_a? Hash
+          key = CGI.unescape(key)
+          parent << (@top = {}) if top.key?(key) && parent.is_a?(Array)
+          return top[key] ||= value
+        else
+          raise ArgumentError, "Don't know what to do: top is #{top.inspect}"
+        end
+
+        return value
+      end
+      
+      def type_conflict!(klass, value)
+        raise TypeError, 
+          "Conflicting types for parameter containers. " +
+          "Expected an instance of #{klass}, but found an instance of #{value.class}. " +
+          "This can be caused by passing Array and Hash based paramters qs[]=value&qs[key]=value. "
+      end
+      
+    end
+end

data/sample_rails_project/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

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

@@ -0,0 +1,95 @@
+class CGI #:nodoc:
+  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
+
+      # POST assumes missing Content-Type is application/x-www-form-urlencoded.
+      content_type = env_table['CONTENT_TYPE']
+      if content_type.blank? && method == :post
+        content_type = 'application/x-www-form-urlencoded'
+      end
+
+      # Force content length to zero if missing.
+      content_length = env_table['CONTENT_LENGTH'].to_i
+
+      # Set multipart to false by default.
+      @multipart = false
+
+      # POST and PUT may have params in entity body. If content type is
+      # missing for POST, assume urlencoded. If content type is missing
+      # for PUT, don't assume anything and don't parse the parameters:
+      # it's likely binary data.
+      #
+      # The other HTTP methods have their params in the query string.
+      if method == :post || method == :put
+        if boundary = extract_multipart_form_boundary(content_type)
+          @multipart = true
+          @params = read_multipart(boundary, content_length)
+        elsif content_type.blank? || content_type !~ %r{application/x-www-form-urlencoded}i
+          read_params(method, content_length)
+          @params = {}
+        end
+      end
+
+      @params ||= CGI.parse(read_params(method, content_length))
+    end
+
+    private
+      unless defined?(MULTIPART_FORM_BOUNDARY_RE)
+        MULTIPART_FORM_BOUNDARY_RE = %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n #"
+      end
+
+      def extract_multipart_form_boundary(content_type)
+        MULTIPART_FORM_BOUNDARY_RE.match(content_type).to_a.pop
+      end
+
+      if defined? MOD_RUBY
+        def read_query
+          Apache::request.args || ''
+        end
+      else
+        def read_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_body(content_length)
+        stdinput.binmode if stdinput.respond_to?(:binmode)
+        content = stdinput.read(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_params(method, content_length)
+        case method
+          when :get
+            read_query
+          when :post, :put
+            read_body(content_length)
+          when :cmd
+            read_from_cmdline
+          else # :head, :delete, :options, :trace, :connect
+            read_query
+        end
+      end
+  end # module QueryExtension
+end

data/sample_rails_project/vendor/rails/actionpack/lib/action_controller/cgi_ext/session_performance_fix.rb

@@ -0,0 +1,30 @@
+# CGI::Session#create_new_id requires 'digest/md5' on every call.  This makes
+# sense when spawning processes per request, but is unnecessarily expensive
+# when serving requests from a long-lived process.
+#
+# http://railsexpress.de/blog/articles/2005/11/22/speeding-up-the-creation-of-new-sessions
+require 'cgi/session'
+require 'digest/md5'
+
+class CGI
+  class Session #:nodoc:
+    private
+      # Create a new session id.
+      #
+      # The session id is an MD5 hash based upon the time,
+      # a random number, and a constant string.  This routine
+      # is used internally for automatically generated
+      # session ids.
+      def create_new_id
+        md5 = Digest::MD5::new
+        now = Time::now
+        md5.update(now.to_s)
+        md5.update(String(now.usec))
+        md5.update(String(rand(0)))
+        md5.update(String($$))
+        md5.update('foobar')
+        @new_session = true
+        md5.hexdigest
+      end
+  end
+end

data/sample_rails_project/vendor/rails/actionpack/lib/action_controller/cgi_process.rb

@@ -0,0 +1,231 @@
+require 'action_controller/cgi_ext/cgi_ext'
+require 'action_controller/cgi_ext/cookie_performance_fix'
+require 'action_controller/cgi_ext/raw_post_data_fix'
+require 'action_controller/cgi_ext/session_performance_fix'
+
+module ActionController #:nodoc:
+  class Base
+    # Process a request extracted from an CGI object and return a response. Pass false as <tt>session_options</tt> to disable
+    # sessions (large performance increase if sessions are not needed). The <tt>session_options</tt> are the same as for CGI::Session:
+    #
+    # * <tt>:database_manager</tt> - standard options are CGI::Session::FileStore, CGI::Session::MemoryStore, and CGI::Session::PStore
+    #   (default). Additionally, there is CGI::Session::DRbStore and CGI::Session::ActiveRecordStore. Read more about these in
+    #   lib/action_controller/session.
+    # * <tt>:session_key</tt> - the parameter name used for the session id. Defaults to '_session_id'.
+    # * <tt>:session_id</tt> - the session id to use.  If not provided, then it is retrieved from the +session_key+ parameter
+    #   of the request, or automatically generated for a new session.
+    # * <tt>:new_session</tt> - if true, force creation of a new session.  If not set, a new session is only created if none currently
+    #   exists.  If false, a new session is never created, and if none currently exists and the +session_id+ option is not set,
+    #   an ArgumentError is raised.
+    # * <tt>:session_expires</tt> - the time the current session expires, as a +Time+ object.  If not set, the session will continue
+    #   indefinitely.
+    # * <tt>:session_domain</tt> -  the hostname domain for which this session is valid. If not set, defaults to the hostname of the
+    #   server.
+    # * <tt>:session_secure</tt> - if +true+, this session will only work over HTTPS.
+    # * <tt>:session_path</tt> - the path for which this session applies.  Defaults to the directory of the CGI script.
+    def self.process_cgi(cgi = CGI.new, session_options = {})
+      new.process_cgi(cgi, session_options)
+    end
+
+    def process_cgi(cgi, session_options = {}) #:nodoc:
+      process(CgiRequest.new(cgi, session_options), CgiResponse.new(cgi)).out
+    end
+  end
+
+  class CgiRequest < AbstractRequest #:nodoc:
+    attr_accessor :cgi, :session_options
+
+    DEFAULT_SESSION_OPTIONS = {
+      :database_manager => CGI::Session::PStore,
+      :prefix           => "ruby_sess.",
+      :session_path     => "/"
+    } unless const_defined?(:DEFAULT_SESSION_OPTIONS)
+
+    def initialize(cgi, session_options = {})
+      @cgi = cgi
+      @session_options = session_options
+      @env = @cgi.send(:env_table)
+      super()
+    end
+
+    def query_string
+      if (qs = @cgi.query_string) && !qs.empty?
+        qs
+      elsif uri = @env['REQUEST_URI']
+        parts = uri.split('?')
+        parts.shift
+        parts.join('?')
+      else
+        @env['QUERY_STRING'] || ''
+      end
+    end
+
+    def query_parameters
+      @query_parameters ||=
+        (qs = self.query_string).empty? ? {} : CGIMethods.parse_query_parameters(qs)
+    end
+
+    def request_parameters
+      @request_parameters ||=
+        if ActionController::Base.param_parsers.has_key?(content_type)
+          CGIMethods.parse_formatted_request_parameters(content_type, @env['RAW_POST_DATA'])
+        else
+          CGIMethods.parse_request_parameters(@cgi.params)
+        end
+    end
+
+    def cookies
+      @cgi.cookies.freeze
+    end
+
+    def host_with_port
+      if forwarded = env["HTTP_X_FORWARDED_HOST"]
+        forwarded.split(/,\s?/).last
+      elsif http_host = env['HTTP_HOST']
+        http_host
+      elsif server_name = env['SERVER_NAME']
+        server_name
+      else
+        "#{env['SERVER_ADDR']}:#{env['SERVER_PORT']}"
+      end
+    end
+
+    def host
+      host_with_port[/^[^:]+/]
+    end
+
+    def port
+      if host_with_port =~ /:(\d+)$/
+        $1.to_i
+      else
+        standard_port
+      end
+    end
+
+    def session
+      unless defined?(@session)
+        if @session_options == false
+          @session = Hash.new
+        else
+          stale_session_check! do
+            case value = session_options_with_string_keys['new_session']
+              when true
+                @session = new_session
+              when false
+                begin
+                  @session = CGI::Session.new(@cgi, session_options_with_string_keys)
+                # CGI::Session raises ArgumentError if 'new_session' == false
+                # and no session cookie or query param is present.
+                rescue ArgumentError
+                  @session = Hash.new
+                end
+              when nil
+                @session = CGI::Session.new(@cgi, session_options_with_string_keys)
+              else
+                raise ArgumentError, "Invalid new_session option: #{value}"
+            end
+            @session['__valid_session']
+          end
+        end
+      end
+      @session
+    end
+
+    def reset_session
+      @session.delete if defined?(@session) && @session.is_a?(CGI::Session)
+      @session = new_session
+    end
+
+    def method_missing(method_id, *arguments)
+      @cgi.send(method_id, *arguments) rescue super
+    end
+
+    private
+      # Delete an old session if it exists then create a new one.
+      def new_session
+        if @session_options == false
+          Hash.new
+        else
+          CGI::Session.new(@cgi, session_options_with_string_keys.merge("new_session" => false)).delete rescue nil
+          CGI::Session.new(@cgi, session_options_with_string_keys.merge("new_session" => true))
+        end
+      end
+
+      def stale_session_check!
+        yield
+      rescue ArgumentError => argument_error
+        if argument_error.message =~ %r{undefined class/module ([\w:]+)}
+          begin
+            Module.const_missing($1)
+          rescue LoadError, NameError => const_error
+            raise ActionController::SessionRestoreError, <<-end_msg
+Session contains objects whose class definition isn\'t available.
+Remember to require the classes for all objects kept in the session.
+(Original exception: #{const_error.message} [#{const_error.class}])
+end_msg
+          end
+
+          retry
+        else
+          raise
+        end
+      end
+
+      def session_options_with_string_keys
+        @session_options_with_string_keys ||= DEFAULT_SESSION_OPTIONS.merge(@session_options).stringify_keys
+      end
+  end
+
+  class CgiResponse < AbstractResponse #:nodoc:
+    def initialize(cgi)
+      @cgi = cgi
+      super()
+    end
+
+    def out(output = $stdout)
+      convert_content_type!
+      set_content_length!
+
+      output.binmode      if output.respond_to?(:binmode)
+      output.sync = false if output.respond_to?(:sync=)
+
+      begin
+        output.write(@cgi.header(@headers))
+
+        if @cgi.send(:env_table)['REQUEST_METHOD'] == 'HEAD'
+          return
+        elsif @body.respond_to?(:call)
+          # Flush the output now in case the @body Proc uses
+          # #syswrite.
+          output.flush if output.respond_to?(:flush)
+          @body.call(self, output)
+        else
+          output.write(@body)
+        end
+
+        output.flush if output.respond_to?(:flush)
+      rescue Errno::EPIPE, Errno::ECONNRESET
+        # lost connection to parent process, ignore output
+      end
+    end
+
+    private
+      def convert_content_type!
+        if content_type = @headers.delete("Content-Type")
+          @headers["type"] = content_type
+        end
+        if content_type = @headers.delete("Content-type")
+          @headers["type"] = content_type
+        end
+        if content_type = @headers.delete("content-type")
+          @headers["type"] = content_type
+        end
+      end
+      
+      # Don't set the Content-Length for block-based bodies as that would mean reading it all into memory. Not nice
+      # for, say, a 2GB streaming file.
+      def set_content_length!
+        @headers["Content-Length"] = @body.size unless @body.respond_to?(:call)
+      end
+  end
+end