Extended maintenance of Ruby versions 1.8.7 and 1.9.2 ended on July 31, 2014. Read more

In Files

  • webrick/httputils.rb

Class/Module Index [+]

Quicksearch

WEBrick::HTTPUtils

Public Class Methods

dequote(str) click to toggle source
 
               # File webrick/httputils.rb, line 189
def dequote(str)
  ret = (/\A"(.*)"\Z/ =~ str) ? $1 : str.dup
  ret.gsub!(/\(.)/, "\\1")
  ret
end
            
load_mime_types(file) click to toggle source

Load Apache compatible mime.types file.

 
               # File webrick/httputils.rb, line 93
def load_mime_types(file)
  open(file){ |io|
    hash = Hash.new
    io.each{ |line|
      next if /^#/ =~ line
      line.chomp!
      mimetype, ext0 = line.split(/\s+/, 2)
      next unless ext0   
      next if ext0.empty?
      ext0.split(/\s+/).each{ |ext| hash[ext] = mimetype }
    }
    hash
  }
end
            
mime_type(filename, mime_tab) click to toggle source
 
               # File webrick/httputils.rb, line 109
def mime_type(filename, mime_tab)
  suffix1 = (/\.(\w+)$/ =~ filename && $1.downcase)
  suffix2 = (/\.(\w+)\.[\w\-]+$/ =~ filename && $1.downcase)
  mime_tab[suffix1] || mime_tab[suffix2] || "application/octet-stream"
end
            
normalize_path(path) click to toggle source
 
               # File webrick/httputils.rb, line 21
def normalize_path(path)
  raise "abnormal path `#{path}'" if path[0] != ?/
  ret = path.dup

  ret.gsub!(%r{/+}o, '/')                    # //      => /
  while ret.sub!(%r'/\.(?:/|\Z)', '/'); end  # /.      => /
  while ret.sub!(%r'/(?!\.\./)[^/]+/\.\.(?:/|\Z)', '/'); end # /foo/.. => /foo

  raise "abnormal path `#{path}'" if %r{/\.\.(/|\Z)} =~ ret
  ret
end
            
parse_form_data(io, boundary) click to toggle source
 
               # File webrick/httputils.rb, line 306
def parse_form_data(io, boundary)
  boundary_regexp = /\A--#{boundary}(--)?#{CRLF}\z/
  form_data = Hash.new
  return form_data unless io
  data = nil
  io.each{|line|
    if boundary_regexp =~ line
      if data
        data.chop!
        key = data.name
        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
            
parse_header(raw) click to toggle source
 
               # File webrick/httputils.rb, line 118
def parse_header(raw)
  header = Hash.new([].freeze)
  field = nil
  raw.each{|line|
    case line
    when /^([A-Za-z0-9!\#$%&'*+\-.^_`|~]+):\s*(.*?)\s*\z/om
      field, value = $1, $2
      field.downcase!
      header[field] = [] unless header.has_key?(field)
      header[field] << value
    when /^\s+(.*?)\s*\z/om
      value = $1
      unless field
        raise HTTPStatus::BadRequest, "bad header '#{line}'."
      end
      header[field][-1] << " " << value
    else
      raise HTTPStatus::BadRequest, "bad header '#{line}'."
    end
  }
  header.each{|key, values|
    values.each{|value|
      value.strip!
      value.gsub!(/\s+/, " ")
    }
  }
  header
end
            
parse_query(str) click to toggle source
 
               # File webrick/httputils.rb, line 285
def parse_query(str)
  query = Hash.new
  if str
    str.split(/[&;]/).each{|x|
      next if x.empty? 
      key, val = x.split(/=/,2)
      key = unescape_form(key)
      val = unescape_form(val.to_s)
      val = FormData.new(val)
      val.name = key
      if query.has_key?(key)
        query[key].append_data(val)
        next
      end
      query[key] = val
    }
  end
  query
end
            
parse_qvalues(value) click to toggle source
 
               # File webrick/httputils.rb, line 169
def parse_qvalues(value)
  tmp = []
  if value
    parts = value.split(/,\s*/)
    parts.each {|part|
      if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
        val = m[1]
        q = (m[2] or 1).to_f
        tmp.push([val, q])
      end
    }
    tmp = tmp.sort_by{|val, q| -q}
    tmp.collect!{|val, q| val}
  end
  return tmp
end
            
parse_range_header(ranges_specifier) click to toggle source
 
               # File webrick/httputils.rb, line 154
def parse_range_header(ranges_specifier)
  if /^bytes=(.*)/ =~ ranges_specifier
    byte_range_set = split_header_value($1)
    byte_range_set.collect{|range_spec|
      case range_spec
      when /^(\d+)-(\d+)/ then $1.to_i .. $2.to_i
      when /^(\d+)-/      then $1.to_i .. -1
      when /^-(\d+)/      then -($1.to_i) .. -1
      else return nil
      end
    }
  end
end
            
quote(str) click to toggle source
 
               # File webrick/httputils.rb, line 196
def quote(str)
  '"' << str.gsub(/[\\"]/o, "\\\1") << '"'
end
            
split_header_value(str) click to toggle source
 
               # File webrick/httputils.rb, line 148
def split_header_value(str)
  str.scan(%r'\G((?:"(?:\.|[^"])+?"|[^",]+)+)
                (?:,\s*|\Z)'xn).flatten
end
            

Public Instance Methods

_escape(str, regex) click to toggle source
 
               # File webrick/httputils.rb, line 352
def _escape(str, regex) str.gsub(regex){ "%%%02X" % $1[0] } end
            
_make_regex(str) click to toggle source
 
               # File webrick/httputils.rb, line 350
    def _make_regex(str) /([#{Regexp.escape(str)}])/n end
    def _make_regex!(str) /([^#{Regexp.escape(str)}])/n end
    def _escape(str, regex) str.gsub(regex){ "%%%02X" % $1[0] } end
    def _unescape(str, regex) str.gsub(regex){ $1.hex.chr } end

    UNESCAPED = _make_regex(control+space+delims+unwise+nonascii)
    UNESCAPED_FORM = _make_regex(reserved+control+delims+unwise+nonascii)
    NONASCII  = _make_regex(nonascii)
    ESCAPED   = /%([0-9a-fA-F]{2})/
    UNESCAPED_PCHAR = _make_regex!(unreserved+":@&=+$,")

    def escape(str)
      _escape(str, UNESCAPED)
    end

    def unescape(str)
      _unescape(str, ESCAPED)
    end

    def escape_form(str)
      ret = _escape(str, UNESCAPED_FORM)
      ret.gsub!(/ /, "+")
      ret
    end

    def unescape_form(str)
      _unescape(str.gsub(/\+/, " "), ESCAPED)
    end

    def escape_path(str)
      result = ""
      str.scan(%r{/([^/]*)}).each{|i|
        result << "/" << _escape(i[0], UNESCAPED_PCHAR)
      }
      return result
    end

    def escape8bit(str)
      _escape(str, NONASCII)
    end
  end
end
            
_make_regex!(str) click to toggle source
 
               # File webrick/httputils.rb, line 351
  def _make_regex!(str) /([^#{Regexp.escape(str)}])/n end
  def _escape(str, regex) str.gsub(regex){ "%%%02X" % $1[0] } end
  def _unescape(str, regex) str.gsub(regex){ $1.hex.chr } end

  UNESCAPED = _make_regex(control+space+delims+unwise+nonascii)
  UNESCAPED_FORM = _make_regex(reserved+control+delims+unwise+nonascii)
  NONASCII  = _make_regex(nonascii)
  ESCAPED   = /%([0-9a-fA-F]{2})/
  UNESCAPED_PCHAR = _make_regex!(unreserved+":@&=+$,")

  def escape(str)
    _escape(str, UNESCAPED)
  end

  def unescape(str)
    _unescape(str, ESCAPED)
  end

  def escape_form(str)
    ret = _escape(str, UNESCAPED_FORM)
    ret.gsub!(/ /, "+")
    ret
  end

  def unescape_form(str)
    _unescape(str.gsub(/\+/, " "), ESCAPED)
  end

  def escape_path(str)
    result = ""
    str.scan(%r{/([^/]*)}).each{|i|
      result << "/" << _escape(i[0], UNESCAPED_PCHAR)
    }
    return result
  end

  def escape8bit(str)
    _escape(str, NONASCII)
  end
end
            
_unescape(str, regex) click to toggle source
 
               # File webrick/httputils.rb, line 353
def _unescape(str, regex) str.gsub(regex){ $1.hex.chr } end
            
escape(str) click to toggle source
 
               # File webrick/httputils.rb, line 361
def escape(str)
  _escape(str, UNESCAPED)
end
            
escape8bit(str) click to toggle source
 
               # File webrick/httputils.rb, line 387
def escape8bit(str)
  _escape(str, NONASCII)
end
            
escape_form(str) click to toggle source
 
               # File webrick/httputils.rb, line 369
def escape_form(str)
  ret = _escape(str, UNESCAPED_FORM)
  ret.gsub!(/ /, "+")
  ret
end
            
escape_path(str) click to toggle source
 
               # File webrick/httputils.rb, line 379
def escape_path(str)
  result = ""
  str.scan(%r{/([^/]*)}).each{|i|
    result << "/" << _escape(i[0], UNESCAPED_PCHAR)
  }
  return result
end
            
unescape(str) click to toggle source
 
               # File webrick/httputils.rb, line 365
def unescape(str)
  _unescape(str, ESCAPED)
end
            
unescape_form(str) click to toggle source
 
               # File webrick/httputils.rb, line 375
def unescape_form(str)
  _unescape(str.gsub(/\+/, " "), ESCAPED)
end
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus