stella 0.5.5 → 0.6.0

data/lib/utils/domainutil.rb

@@ -1,47 +0,0 @@
-
-require 'net/dns/packet'
-
-module DomainUtil
-
-  def DomainUtil.parse_domain_request(data=[])
-    return unless data && !data.empty?
-    data = data.split(/\r?\n/) unless data.kind_of? Array
-    data.shift while (data[0].empty? || data[0].nil?)   # Remove leading empties
-    
-    dns_data = Net::DNS::Packet.parse( data.join($/) )
-    return unless dns_data.header.query? 
-    domain_name = dns_data.question[0].qName
-    return dns_data, domain_name, dns_data.header
-  end
-  
-  def DomainUtil.parse_domain_response(data=[])
-    return unless data && !data.empty?
-    data = data.split(/\r?\n/) unless data.kind_of? Array
-    data.shift while (data[0].empty? || data[0].nil?)   # Remove leading empties
-    
-    # This is the heavy lifting. 
-    dns_data = Net::DNS::Packet.parse( data.join($/) )
-    
-    # We don't want queries or empty answers
-    return if dns_data.header.query? || dns_data.answer.nil? || dns_data.answer.empty?
-    
-    domain_name = dns_data.answer[0].name
-    
-    # Empty the lists if they are already populated
-    addresses = []
-    cnames = []
-
-    # Store the CNAMEs associated to this domain. Can be empty. 
-    dns_data.each_cname do |cname|
-      cnames << cname.to_s
-    end
-
-    # Store the IP address for this domain. If empty, the lookup was unsuccessful. 
-    dns_data.each_address do |ip|
-      addresses << ip.to_s
-    end
-    
-    return dns_data, domain_name, dns_data.header, addresses, cnames
-  end
-
-end

data/lib/utils/escape.rb

@@ -1,302 +0,0 @@
-# escape.rb - escape/unescape library for several formats
-#
-# Copyright (C) 2006,2007 Tanaka Akira  <akr@fsij.org>
-# 
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-# 
-#  1. Redistributions of source code must retain the above copyright notice, this
-#     list of conditions and the following disclaimer.
-#  2. Redistributions in binary form must reproduce the above copyright notice,
-#     this list of conditions and the following disclaimer in the documentation
-#     and/or other materials provided with the distribution.
-#  3. The name of the author may not be used to endorse or promote products
-#     derived from this software without specific prior written permission.
-# 
-# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
-# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
-# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-# Escape module provides several escape functions.
-# * URI
-# * HTML
-# * shell command
-module EscapeUtil
-  module_function
-
-  class StringWrapper
-    class << self
-      alias new_no_dup new
-      def new(str)
-        new_no_dup(str.dup)
-      end
-    end
-
-    def initialize(str)
-      @str = str
-    end
-
-    def to_s
-      @str.dup
-    end
-
-    def inspect
-      "\#<#{self.class}: #{@str}>"
-    end
-
-    def ==(other)
-      other.class == self.class && @str == other.instance_variable_get(:@str)
-    end
-    alias eql? ==
-
-    def hash
-      @str.hash
-    end
-  end
-
-  class ShellEscaped < StringWrapper
-  end
-
-  # Escape.shell_command composes
-  # a sequence of words to
-  # a single shell command line.
-  # All shell meta characters are quoted and
-  # the words are concatenated with interleaving space.
-  # It returns an instance of ShellEscaped.
-  #
-  #  Escape.shell_command(["ls", "/"]) #=> #<Escape::ShellEscaped: ls />
-  #  Escape.shell_command(["echo", "*"]) #=> #<Escape::ShellEscaped: echo '*'>
-  #
-  # Note that system(*command) and
-  # system(Escape.shell_command(command)) is roughly same.
-  # There are two exception as follows.
-  # * The first is that the later may invokes /bin/sh.
-  # * The second is an interpretation of an array with only one element: 
-  #   the element is parsed by the shell with the former but
-  #   it is recognized as single word with the later.
-  #   For example, system(*["echo foo"]) invokes echo command with an argument "foo".
-  #   But system(Escape.shell_command(["echo foo"])) invokes "echo foo" command without arguments (and it probably fails).
-  def shell_command(command)
-    s = command.map {|word| shell_single_word(word) }.join(' ')
-    ShellEscaped.new_no_dup(s)
-  end
-
-  # Escape.shell_single_word quotes shell meta characters.
-  # It returns an instance of ShellEscaped.
-  #
-  # The result string is always single shell word, even if
-  # the argument is "".
-  # Escape.shell_single_word("") returns #<Escape::ShellEscaped: ''>.
-  #
-  #  Escape.shell_single_word("") #=> #<Escape::ShellEscaped: ''>
-  #  Escape.shell_single_word("foo") #=> #<Escape::ShellEscaped: foo>
-  #  Escape.shell_single_word("*") #=> #<Escape::ShellEscaped: '*'>
-  def shell_single_word(str)
-    if str && str.empty?
-      ShellEscaped.new_no_dup("''")
-    elsif %r{\A[0-9A-Za-z+,./:=@_-]+\z} =~ str
-      ShellEscaped.new(str)
-    else
-      result = ''
-      str.scan(/('+)|[^']+/) {
-        if $1
-          result << %q{\'} * $1.length
-        else
-          result << "'#{$&}'"
-        end
-      }
-      ShellEscaped.new_no_dup(result)
-    end
-  end
-
-  class PercentEncoded < StringWrapper
-  end
-
-  # Escape.uri_segment escapes URI segment using percent-encoding.
-  # It returns an instance of PercentEncoded.
-  #
-  #  Escape.uri_segment("a/b") #=> #<Escape::PercentEncoded: a%2Fb>
-  #
-  # The segment is "/"-splitted element after authority before query in URI, as follows.
-  #
-  #   scheme://authority/segment1/segment2/.../segmentN?query#fragment
-  #
-  # See RFC 3986 for details of URI.
-  def uri_segment(str)
-    # pchar - pct-encoded = unreserved / sub-delims / ":" / "@"
-    # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
-    # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
-    s = str.gsub(%r{[^A-Za-z0-9\-._~!$&'()*+,;=:@]}n) {
-      '%' + $&.unpack("H2")[0].upcase
-    }
-    PercentEncoded.new_no_dup(s)
-  end
-
-  # Escape.uri_path escapes URI path using percent-encoding.
-  # The given path should be a sequence of (non-escaped) segments separated by "/".
-  # The segments cannot contains "/".
-  # It returns an instance of PercentEncoded.
-  #
-  #  Escape.uri_path("a/b/c") #=> #<Escape::PercentEncoded: a/b/c>
-  #  Escape.uri_path("a?b/c?d/e?f") #=> #<Escape::PercentEncoded: a%3Fb/c%3Fd/e%3Ff>
-  #
-  # The path is the part after authority before query in URI, as follows.
-  #
-  #   scheme://authority/path#fragment
-  #
-  # See RFC 3986 for details of URI.
-  #
-  # Note that this function is not appropriate to convert OS path to URI.
-  def uri_path(str)
-    s = str.gsub(%r{[^/]+}n) { uri_segment($&) }
-    PercentEncoded.new_no_dup(s)
-  end
-
-  # :stopdoc:
-  def html_form_fast(pairs, sep='&')
-    s = pairs.map {|k, v|
-      # query-chars - pct-encoded - x-www-form-urlencoded-delimiters =
-      #   unreserved / "!" / "$" / "'" / "(" / ")" / "*" / "," / ":" / "@" / "/" / "?"
-      # query-char - pct-encoded = unreserved / sub-delims / ":" / "@" / "/" / "?"
-      # query-char = pchar / "/" / "?" = unreserved / pct-encoded / sub-delims / ":" / "@" / "/" / "?"
-      # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
-      # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
-      # x-www-form-urlencoded-delimiters = "&" / "+" / ";" / "="
-      k = k.gsub(%r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n) {
-        '%' + $&.unpack("H2")[0].upcase
-      }
-      v = v.gsub(%r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n) {
-        '%' + $&.unpack("H2")[0].upcase
-      }
-      "#{k}=#{v}"
-    }.join(sep)
-    PercentEncoded.new_no_dup(s)
-  end
-  # :startdoc:
-
-  # Escape.html_form composes HTML form key-value pairs as a x-www-form-urlencoded encoded string.
-  # It returns an instance of PercentEncoded.
-  #
-  # Escape.html_form takes an array of pair of strings or
-  # an hash from string to string.
-  #
-  #  Escape.html_form([["a","b"], ["c","d"]]) #=> #<Escape::PercentEncoded: a=b&c=d>
-  #  Escape.html_form({"a"=>"b", "c"=>"d"}) #=> #<Escape::PercentEncoded: a=b&c=d>
-  #
-  # In the array form, it is possible to use same key more than once.
-  # (It is required for a HTML form which contains
-  # checkboxes and select element with multiple attribute.)
-  #
-  #  Escape.html_form([["k","1"], ["k","2"]]) #=> #<Escape::PercentEncoded: k=1&k=2>
-  #
-  # If the strings contains characters which must be escaped in x-www-form-urlencoded,
-  # they are escaped using %-encoding.
-  #
-  #  Escape.html_form([["k=","&;="]]) #=> #<Escape::PercentEncoded: k%3D=%26%3B%3D>
-  #
-  # The separator can be specified by the optional second argument.
-  #
-  #  Escape.html_form([["a","b"], ["c","d"]], ";") #=> #<Escape::PercentEncoded: a=b;c=d>
-  #
-  # See HTML 4.01 for details.
-  def html_form(pairs, sep='&')
-    r = ''
-    first = true
-    pairs.each {|k, v|
-      # query-chars - pct-encoded - x-www-form-urlencoded-delimiters =
-      #   unreserved / "!" / "$" / "'" / "(" / ")" / "*" / "," / ":" / "@" / "/" / "?"
-      # query-char - pct-encoded = unreserved / sub-delims / ":" / "@" / "/" / "?"
-      # query-char = pchar / "/" / "?" = unreserved / pct-encoded / sub-delims / ":" / "@" / "/" / "?"
-      # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
-      # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
-      # x-www-form-urlencoded-delimiters = "&" / "+" / ";" / "="
-      r << sep if !first
-      first = false
-      k.each_byte {|byte|
-        ch = byte.chr
-        if %r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n =~ ch
-          r << "%" << ch.unpack("H2")[0].upcase
-        else
-          r << ch
-        end
-      }
-      r << '='
-      v.each_byte {|byte|
-        ch = byte.chr
-        if %r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n =~ ch
-          r << "%" << ch.unpack("H2")[0].upcase
-        else
-          r << ch
-        end
-      }
-    }
-    PercentEncoded.new_no_dup(r)
-  end
-
-  class HTMLEscaped < StringWrapper
-  end
-
-  # :stopdoc:
-  HTML_TEXT_ESCAPE_HASH = {
-    '&' => '&amp;',
-    '<' => '&lt;',
-    '>' => '&gt;',
-  }
-  # :startdoc:
-
-  # Escape.html_text escapes a string appropriate for HTML text using character references.
-  # It returns an instance of HTMLEscaped.
-  #
-  # It escapes 3 characters:
-  # * '&' to '&amp;'
-  # * '<' to '&lt;'
-  # * '>' to '&gt;'
-  #
-  #  Escape.html_text("abc") #=> #<Escape::HTMLEscaped: abc>
-  #  Escape.html_text("a & b < c > d") #=> #<Escape::HTMLEscaped: a &amp; b &lt; c &gt; d>
-  #
-  # This function is not appropriate for escaping HTML element attribute
-  # because quotes are not escaped.
-  def html_text(str)
-    s = str.gsub(/[&<>]/) {|ch| HTML_TEXT_ESCAPE_HASH[ch] }
-    HTMLEscaped.new_no_dup(s)
-  end
-
-  # :stopdoc:
-  HTML_ATTR_ESCAPE_HASH = {
-    '&' => '&amp;',
-    '<' => '&lt;',
-    '>' => '&gt;',
-    '"' => '&quot;',
-  }
-  # :startdoc:
-
-  class HTMLAttrValue < StringWrapper
-  end
-
-  # Escape.html_attr_value encodes a string as a double-quoted HTML attribute using character references.
-  # It returns an instance of HTMLAttrValue.
-  #
-  #  Escape.html_attr_value("abc") #=> #<Escape::HTMLAttrValue: "abc">
-  #  Escape.html_attr_value("a&b") #=> #<Escape::HTMLAttrValue: "a&amp;b">
-  #  Escape.html_attr_value("ab&<>\"c") #=> #<Escape::HTMLAttrValue: "ab&amp;&lt;&gt;&quot;c">
-  #  Escape.html_attr_value("a'c") #=> #<Escape::HTMLAttrValue: "a'c">
-  #
-  # It escapes 4 characters:
-  # * '&' to '&amp;'
-  # * '<' to '&lt;'
-  # * '>' to '&gt;'
-  # * '"' to '&quot;'
-  #
-  def html_attr_value(str)
-    s = '"' + str.gsub(/[&<>"]/) {|ch| HTML_ATTR_ESCAPE_HASH[ch] } + '"'
-    HTMLAttrValue.new_no_dup(s)
-  end
-end

data/lib/utils/fileutil.rb

@@ -1,78 +0,0 @@
-require 'fileutils'
-
-module FileUtil
-  
-  def FileUtil.read_file(path)
-    FileUtil.read_file_to_array(path).join('')
-  end
-  
-  def FileUtil.read_file_to_array(path)
-    contents = []
-    return contents unless File.exists?(path)
-    
-    open(path, 'r') do |l|
-      contents = l.readlines
-    end
-
-    contents
-  end
-  def FileUtil.read_binary_file(path)
-    contents = ''
-    return contents unless File.exists?(path)
-    
-    open(path, 'rb') do |l|
-      while (!l.eof?)
-        contents << l.read(4096)
-      end
-    end
-
-    contents
-  end
-  
-  
-  
-  def FileUtil.write_file(path, content, flush=true)
-    FileUtil.write_or_append_file('w', path, content, flush)
-  end
-  
-  def FileUtil.append_file(path, content, flush=true)
-    FileUtil.write_or_append_file('a', path, content, flush)
-  end
-  
-  def FileUtil.write_or_append_file(write_or_append, path, content = '', flush = true)
-    #STDERR.puts "Writing to #{ path }..." 
-    FileUtil.create_dir(File.dirname(path))
-    
-    open(path, write_or_append) do |f| 
-      f.puts content
-      f.flush if flush;
-    end
-    File.chmod(0600, path)
-  end
-  
-  def FileUtil.create_file(filepath, perm='w', file_perms=nil, force=false)
-    raise Exception.new("File #{filepath} already exists!") if File.exists?(filepath) && !force
-    
-    newfile = File.new(filepath, perm)
-    begin
-    if file_perms && File.exists?(file_perms)
-      File.chown(File.stat(file_perms).uid.to_i, File.stat(file_perms).gid.to_i, filepath)
-    end
-rescue NotImplementedError => ex
-end
-
-    newfile
-  end
-
-  def FileUtil.create_dir(dirpath, dir_perms=nil)
-    return if File.directory?(dirpath)
-    
-    #STDERR.puts "Creating #{ dirpath }"
-    FileUtils.makedirs(dirpath)
-    
-    if dir_perms && File.exists?(dir_perms)
-      File.chown(File.stat(dir_perms).uid.to_i, File.stat(dir_perms).gid.to_i, dirpath)
-    end
-    
-  end
-end

data/lib/utils/httputil.rb

@@ -1,266 +0,0 @@
-
-require 'uri'
-require 'timeout'
-require 'net/http'
-
-  module HTTPUtil
-    VALID_METHODS = %w{GET HEAD POST PUT DELETE}
-    @@timeout = 20
-    
-    # Takes a string. See WEBrick::parse_header(string).
-    def HTTPUtil.parse_header(raw)
-      header = Hash.new([].freeze)
-      raw.each_line do |line|
-        case line
-        when /\A(.+?):\s+(.+)\z/om
-          name, value = $1, $2 
-          name = name.tr('-', '_').to_sym
-          value.strip!
-          
-          header[name] = [] unless header.has_key?(name)
-          header[name] << value
-        end
-      end
-      header
-    end
-    
-    # Takes a string or array. See parse_header_body for further info.
-    # Returns +method+, +http_version+, +uri+, +header+, +body+
-    def HTTPUtil.parse_http_request(data, host=:unknown, port=80)
-      return unless data && !data.empty?
-      data = data.split(/\r?\n/) unless data.kind_of? Array
-      data.shift while (data[0].empty? || data[0].nil?)   # Remove leading empties
-      request_line = data.shift                           # i.e. GET /path HTTP/1.1
-      method, path, http_version = nil
-      
-      # With WEBrick and other proxies, the entire URI is included in HTTP requests. 
-      # i.e. GET http://stellaaahhhh.com/streetcar.png HTTP/1.1
-      # The parser is expecting just the absolute path. 
-      if request_line =~ /^(\S+)\s+(http:\/\/.+)\s+(HTTP.+)?/mo
-        uri = URI.parse($2)
-        request_line = "#{$1} #{uri.request_uri} #{$3}"
-        host = uri.host
-      end
-      
-      if request_line =~ /^(\S+)\s+(\S+)(?:\s+HTTP\/(\d+\.\d+))?/mo
-        method = $1
-        http_version = $3 # Comes before $2 b/c the split resets the numbered vars
-        path, query_string   = $2.split('?')
-        
-        # We only process the header and body data when we know we're
-        # starting from the beginning of a request string. We don't
-        # want no partials. 
-        header, body = HTTPUtil.parse_header_body(data)
-        query = HTTPUtil.parse_query(method, query_string)
-        
-        
-        # TODO: Parse username/password
-        uri = URI::HTTP.build({
-          :scheme => 'http',
-          :host => header[:Host][0] || host.to_s, 
-          :port => port, 
-          :path => path, 
-          :query => query_string
-        })
-        
-      else
-        rl = request_line.sub(/\x0d?\x0a\z/o, '')
-        raise "Bad Request-Line `#{rl}'."
-      end
-      
-      return method, http_version, uri, header, body
-    end
-    
-    
-    # Takes a string or array. See parse_header_body for further info. 
-    # Returns +status+, +http_version+, +message+, +header+, +body+
-    def HTTPUtil.parse_http_response(data=[])
-      return unless data && !data.empty?
-      data = data.split(/\r?\n/) unless data.kind_of? Array
-      data.shift while (data[0].empty? || data[0].nil?)   # Remove leading empties
-      status_line = data.shift                            # ie. HTTP/1.1 200 OK
-      http_version, status, message = nil
-      
-      if status_line =~ /^HTTP\/(\d.+?)(\s+(\d\d\d)\s+(.+))?$/mo
-        http_version = $1
-        status   = $2
-        message   = $4
-        
-        header, body, query = HTTPUtil.parse_header_body(data)
-        
-      else  
-        raise "Bad Response-Line `#{status_line}'."
-      end
-      
-      return status, http_version, message, header, body
-    end
-    
-    # Process everything after the first line of an HTTP request or response:
-    # GET / HTTP/1.1
-    # HTTP/1.1 200 OK
-    # etc...
-    # Used by parse_http_request and parse_http_response but can be used separately. 
-    # Takes a string or array of strings. A string should be formatted like an HTTP 
-    # request or response. If a body is present it should be separated by two newlines.
-    # An array of string should contain an empty or nil element between the header 
-    # and body content. This will happen naturally if the raw lines were split by 
-    # a single line terminator. (i.e. /\n/ rather than /\n\n/)
-    # Returns header (hash), body (string)
-    def HTTPUtil.parse_header_body(data=[])
-      header, body = {}, nil
-      data = data.split(/\r?\n/) unless data.kind_of? Array
-      data.shift while (data[0].nil? || data[0].empty?)   # Remove leading empties
-      
-      return header, body unless data && !data.empty?
-      
-      #puts data.to_yaml
-      
-      # Skip that first line if it exists
-      data.shift if data[0].match(/\AHTTP|GET|POST|DELETE|PUT|HEAD/mo)
-      
-      header_lines = []
-      header_lines << data.shift while (!data[0].nil? && !data[0].empty?)
-      header = HTTPUtil::parse_header(header_lines.join($/))
-      
-      # We omit the blank line that delimits the header from the body
-      body = data[1..-1].join($/) unless data.empty? 
-      
-      return header, body
-    end
-    
-    def HTTPUtil.parse_query(request_method, query_string, content_type='', body='')
-      query = Hash.new([].freeze)
-
-        if request_method == "GET" || request_method == "HEAD"
-          query = HTTPUtil::parse_query_from_string(query_string)
-        elsif content_type =~ /^application\/x-www-form-urlencoded/
-          query = HTTPUtil::parse_query_from_string(body)
-        elsif content_type =~ /^multipart\/form-data; boundary=(.+)/
-          boundary = $1.tr('"', '')
-          query = HTTPUtil::parse_form_data(body, boundary)
-        else
-          query
-        end
-
-      query
-    end
-    
-    def HTTPUtil.validate_method(meth='GET')
-      (VALID_METHODS.member? meth.upcase) ? meth : VALID_METHODS[0]
-    end
-    
-    # Parses a query string by breaking it up at the '&'
-    # and ';' characters.  You can also use this to parse
-    # cookies by changing the characters used in the second
-    # parameter (which defaults to '&;'.
-    # Stolen from Mongrel
-    def HTTPUtil.parse_query_from_string(qs, d = '&;')
-      params = {}
-      (qs||'').split(/[#{d}] */n).inject(params) { |h,p|
-        k, v=unescape(p).split('=',2)
-        next unless k
-        k = k.tr('-', '_').to_sym
-        if cur = params[k]
-          if cur.class == Array
-            params[k] << v
-          else
-            params[k] = [cur, v]
-          end
-        else
-          params[k] = v
-        end
-      }
-
-      return params
-    end
-
-    
-    
-    # Based on WEBrick::HTTPutils::parse_form_data
-    def HTTPUtil.parse_form_data(io, boundary)
-      boundary_regexp = /\A--#{boundary}(--)?#{$/}\z/
-      form_data = Hash.new
-      return form_data unless io
-      data = nil
-      io.each_line{|line|
-        if boundary_regexp =~ line
-          if data
-            data.chop!
-            key = data.name.tr('-', '_').to_sym
-            if form_data.has_key?(key)
-              form_data[key].append_data(data)
-            else
-              form_data[key] = data 
-            end
-          end
-          data = FormData.new
-          next
-        else
-          if data
-            data << line
-          end
-        end
-      }
-      return form_data
-    end
-    
-    
-    # Extend the basic query string parser provided by the cgi module.
-    # converts single valued params (the most common case) to
-    # objects instead of arrays
-    #
-    # Input:
-    # the query string
-    #
-    # Output:
-    # hash of parameters, contains arrays for multivalued parameters
-    # (multiselect, checkboxes , etc)
-    # If no query string is provided (nil or "") returns an empty hash.
-    def HTTPUtil.query_to_hash(query_string)
-      return {} unless query_string
-
-      query_parameters = HTTPUtil.parse_query(query_string)
-
-      query_parameters.each { |key, val|
-        # replace the array with an object
-        query_parameters[key] = val[0] if 1 == val.length
-      }
-
-      # set default value to nil! cgi sets this to []
-      query_parameters.default = nil
-
-      return query_parameters
-    end
-    
-    def HTTPUtil.hash_to_query(parameters)
-      return '' unless parameters
-      pairs = []
-      parameters.each do |param, value|
-        pairs << "#{param}=#{URI.escape(value.to_s)}"
-      end
-      return pairs.join('&')
-      #return pairs.join(";")
-    end
-    
-
-    
-    # Performs URI escaping so that you can construct proper
-    # query strings faster.  Use this rather than the cgi.rb
-    # version since it's faster.  (Stolen from Mongrel/Camping).
-    def HTTPUtil.escape(s)
-      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
-        '%'+$1.unpack('H2'*$1.size).join('%').upcase
-      }.tr(' ', '+')
-    end
-
-
-    # Unescapes a URI escaped string. (Stolen from Mongrel/Camping).
-    def HTTPUtil.unescape(s)
-      s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
-        [$1.delete('%')].pack('H*')
-      }
-    end
-    
-    
-  end
-