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 190
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 94
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 110
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 307
def parse_form_data(io, boundary)
  boundary_regexp = /\A--#{Regexp.quote(boundary)}(--)?#{CRLF}\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
        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 119
def parse_header(raw)
  header = Hash.new([].freeze)
  field = nil
  raw.each_line{|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 286
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 170
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 155
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 197
def quote(str)
  '"' << str.gsub(/[\\"]/o, "\\\1") << '"'
end
            
split_header_value(str) click to toggle source
 
               # File webrick/httputils.rb, line 149
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 353
def _escape(str, regex) str.gsub(regex){ "%%%02X" % $1.ord } end
            
_make_regex(str) click to toggle source
 
               # File webrick/httputils.rb, line 351
    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.ord } 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 352
  def _make_regex!(str) /([^#{Regexp.escape(str)}])/n end
  def _escape(str, regex) str.gsub(regex){ "%%%02X" % $1.ord } 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 354
def _unescape(str, regex) str.gsub(regex){ $1.hex.chr } end
            
escape(str) click to toggle source
 
               # File webrick/httputils.rb, line 362
def escape(str)
  _escape(str, UNESCAPED)
end
            
escape8bit(str) click to toggle source
 
               # File webrick/httputils.rb, line 388
def escape8bit(str)
  _escape(str, NONASCII)
end
            
escape_form(str) click to toggle source
 
               # File webrick/httputils.rb, line 370
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 380
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 366
def unescape(str)
  _unescape(str, ESCAPED)
end
            
unescape_form(str) click to toggle source
 
               # File webrick/httputils.rb, line 376
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