diamond-mechanize 2.1 → 2.2

data/lib/mechanize/parser.rb

@@ -1,173 +0,0 @@
-##
-# The parser module provides standard methods for accessing the headers and
-# content of a response that are shared across pluggable parsers.
-
-module Mechanize::Parser
-
-  extend Forwardable
-
-  special_filenames = Regexp.union %w[
-    AUX
-    COM1
-    COM2
-    COM3
-    COM4
-    COM5
-    COM6
-    COM7
-    COM8
-    COM9
-    CON
-    LPT1
-    LPT2
-    LPT3
-    LPT4
-    LPT5
-    LPT6
-    LPT7
-    LPT8
-    LPT9
-    NUL
-    PRN
-  ]
-
-  ##
-  # Special filenames that must be escaped
-
-  SPECIAL_FILENAMES = /\A#{special_filenames}/i
-
-  ##
-  # The URI this file was retrieved from
-
-  attr_accessor :uri
-
-  ##
-  # The Mechanize::Headers for this file
-
-  attr_accessor :response
-
-  alias header response
-
-  ##
-  # The HTTP response code
-
-  attr_accessor :code
-
-  ##
-  # :method: [](header)
-  #
-  # Access HTTP +header+ by name
-
-  def_delegator :header, :[], :[]
-
-  ##
-  # :method: []=(header, value)
-  #
-  # Set HTTP +header+ to +value+
-
-  def_delegator :header, :[]=, :[]=
-
-  ##
-  # :method: key?(header)
-  #
-  # Is the named +header+ present?
-
-  def_delegator :header, :key?, :key?
-
-  ##
-  # :method: each
-  #
-  # Enumerate HTTP headers
-
-  def_delegator :header, :each, :each
-
-  ##
-  # :method: each
-  #
-  # Enumerate HTTP headers in capitalized (canonical) form
-
-  def_delegator :header, :canonical_each, :canonical_each
-
-  ##
-  # Extracts the filename from a Content-Disposition header in the #response
-  # or from the URI.  If +full_path+ is true the filename will include the
-  # host name and path to the resource, otherwise a filename in the current
-  # directory is given.
-
-  def extract_filename full_path = @full_path
-    handled = false
-
-    if @uri then
-      uri = @uri
-      uri += 'index.html' if uri.path.end_with? '/'
-
-      path     = uri.path.split(/\//)
-      filename = path.pop || 'index.html'
-    else
-      path     = []
-      filename = 'index.html'
-    end
-
-    # Set the filename
-    if disposition = @response['content-disposition'] then
-      content_disposition =
-        Mechanize::HTTP::ContentDispositionParser.parse disposition
-
-      if content_disposition then
-        filename = content_disposition.filename
-        filename = filename.split(/[\\\/]/).last
-        handled = true
-      end
-    end
-
-    if not handled and @uri then
-      filename << '.html' unless filename =~ /\./
-      filename << "?#{@uri.query}" if @uri.query
-    end
-
-    if SPECIAL_FILENAMES =~ filename then
-      filename = "_#{filename}"
-    end
-
-    filename = filename.tr "\x00-\x20<>:\"/\\|?*", '_'
-
-    @filename = if full_path then
-                  File.join @uri.host, path, filename
-                else
-                  filename
-                end
-  end
-
-  ##
-  # Creates a Mechanize::Header from the Net::HTTPResponse +response+.
-  #
-  # This allows the Net::HTTPResponse to be garbage collected sooner.
-
-  def fill_header response
-    @response = Mechanize::Headers.new
-
-    response.each { |k,v|
-      @response[k] = v
-    } if response
-
-    @response
-  end
-
-  ##
-  # Finds a free filename based on +filename+, but is not race-free
-
-  def find_free_name filename
-    filename = @filename unless filename
-
-    number = 1
-
-    while File.exist? filename do
-      filename = "#{@filename}.#{number}"
-      number += 1
-    end
-
-    filename
-  end
-
-end
-

data/lib/mechanize/pluggable_parsers.rb

@@ -1,144 +0,0 @@
-require 'mechanize/file'
-require 'mechanize/file_saver'
-require 'mechanize/page'
-
-##
-# This class is used to register and maintain pluggable parsers for Mechanize
-# to use.
-#
-# Mechanize allows different parsers for different content types.  Mechanize
-# uses PluggableParser to determine which parser to use for any content type.
-# To use your own pluggable parser or to change the default pluggable parsers,
-# register them with this class.
-#
-# The default parser for unregistered content types is Mechanize::File.
-#
-# The module Mechanize::Parser provides basic functionality for any content
-# type, so you may use it in custom parsers you write.  For small files you
-# wish to perform in-memory operations on, you should subclass
-# Mechanize::File.  For large files you should subclass Mechanize::Download as
-# the content is only loaded into memory in small chunks.
-#
-# == Example
-#
-# To create your own parser, just create a class that takes four parameters in
-# the constructor.  Here is an example of registering a pluggable parser that
-# handles CSV files:
-#
-#   require 'csv'
-#
-#   class CSVParser < Mechanize::File
-#     attr_reader :csv
-#
-#     def initialize uri = nil, response = nil, body = nil, code = nil
-#       super uri, response, body, code
-#       @csv = CSV.parse body
-#     end
-#   end
-#
-#   agent = Mechanize.new
-#   agent.pluggable_parser.csv = CSVParser
-#   agent.get('http://example.com/test.csv')  # => CSVParser
-#
-# Now any response with a content type of 'text/csv' will initialize a
-# CSVParser and return that object to the caller.
-#
-# To register a pluggable parser for a content type that pluggable parser does
-# not know about, use the hash syntax:
-#
-#   agent.pluggable_parser['text/something'] = SomeClass
-#
-# To set the default parser, use #default:
-#
-#   agent.pluggable_parser.default = Mechanize::Download
-#
-# Now all unknown content types will be saved to disk and not loaded into
-# memory.
-
-class Mechanize::PluggableParser
-
-  CONTENT_TYPES = {
-    :html  => 'text/html',
-    :wap   => 'application/vnd.wap.xhtml+xml',
-    :xhtml => 'application/xhtml+xml',
-    :pdf   => 'application/pdf',
-    :csv   => 'text/csv',
-    :xml   => 'text/xml',
-  }
-
-  attr_accessor :default
-
-  def initialize
-    @parsers = {
-      CONTENT_TYPES[:html]  => Mechanize::Page,
-      CONTENT_TYPES[:xhtml] => Mechanize::Page,
-      CONTENT_TYPES[:wap]   => Mechanize::Page,
-    }
-
-    @default = Mechanize::File
-  end
-
-  ##
-  # Returns the parser registered for the given +content_type+
-
-  def parser(content_type)
-    content_type.nil? ? default : @parsers[content_type] || default
-  end
-
-  def register_parser(content_type, klass) # :nodoc:
-    @parsers[content_type] = klass
-  end
-
-  ##
-  # Registers +klass+ as the parser for text/html and application/xhtml+xml
-  # content
-
-  def html=(klass)
-    register_parser(CONTENT_TYPES[:html], klass)
-    register_parser(CONTENT_TYPES[:xhtml], klass)
-  end
-
-  ##
-  # Registers +klass+ as the parser for application/xhtml+xml content
-
-  def xhtml=(klass)
-    register_parser(CONTENT_TYPES[:xhtml], klass)
-  end
-
-  ##
-  # Registers +klass+ as the parser for application/pdf content
-
-  def pdf=(klass)
-    register_parser(CONTENT_TYPES[:pdf], klass)
-  end
-
-  ##
-  # Registers +klass+ as the parser for text/csv content
-
-  def csv=(klass)
-    register_parser(CONTENT_TYPES[:csv], klass)
-  end
-
-  ##
-  # Registers +klass+ as the parser for text/xml content
-
-  def xml=(klass)
-    register_parser(CONTENT_TYPES[:xml], klass)
-  end
-
-  ##
-  # Retrieves the parser for +content_type+ content
-
-  def [](content_type)
-    @parsers[content_type]
-  end
-
-  ##
-  # Sets the parser for +content_type+ content to +klass+
-
-  def []=(content_type, klass)
-    @parsers[content_type] = klass
-  end
-
-end
-

data/lib/mechanize/redirect_limit_reached_error.rb

@@ -1,19 +0,0 @@
-##
-# Raised when too many redirects are sent
-
-class Mechanize::RedirectLimitReachedError < Mechanize::Error
-
-  attr_reader :page
-  attr_reader :redirects
-  attr_reader :response_code
-
-  def initialize page, redirects
-    @page          = page
-    @redirects     = redirects
-    @response_code = page.code
-
-    super "Redirect limit of #{redirects} reached"
-  end
-
-end
-

data/lib/mechanize/redirect_not_get_or_head_error.rb

@@ -1,21 +0,0 @@
-##
-# Raised when a POST, PUT, or DELETE request results in a redirect
-# see RFC 2616 10.3.2, 10.3.3 http://www.ietf.org/rfc/rfc2616.txt
-
-class Mechanize::RedirectNotGetOrHeadError < Mechanize::Error
-  attr_reader :page, :response_code, :verb, :uri
-  def initialize(page, verb)
-    @page           = page
-    @verb           = verb
-    @uri            = page.uri
-    @response_code  = page.code
-  end
-
-  def to_s
-    method = @verb.to_s.upcase
-    "#{@response_code} redirect received after a #{method} request"
-  end
-
-  alias :inspect :to_s
-end
-

data/lib/mechanize/response_code_error.rb

@@ -1,21 +0,0 @@
-# This error is raised when Mechanize encounters a response code it does not
-# know how to handle.  Currently, this exception will be thrown if Mechanize
-# encounters response codes other than 200, 301, or 302.  Any other response
-# code is up to the user to handle.
-
-class Mechanize::ResponseCodeError < Mechanize::Error
-  attr_reader :response_code
-  attr_reader :page
-
-  def initialize(page)
-    @page          = page
-    @response_code = page.code.to_s
-  end
-
-  def to_s
-    "#{@response_code} => #{Net::HTTPResponse::CODE_TO_OBJ[@response_code]}"
-  end
-
-  alias inspect to_s
-end
-

data/lib/mechanize/response_read_error.rb

@@ -1,27 +0,0 @@
-##
-# Raised when Mechanize encounters an error while reading the response body
-# from the server.  Contains the response headers and the response body up to
-# the error along with the initial error.
-
-class Mechanize::ResponseReadError < Mechanize::Error
-
-  attr_reader :body_io
-  attr_reader :error
-  attr_reader :response
-
-  ##
-  # Creates a new ResponseReadError with the +error+ raised, the +response+
-  # and the +body_io+ for content read so far.
-
-  def initialize error, response, body_io
-    @error = error
-    @response = response
-    @body_io = body_io
-  end
-
-  def message # :nodoc:
-    "#{@error.message} (#{self.class})"
-  end
-
-end
-

data/lib/mechanize/robots_disallowed_error.rb

@@ -1,28 +0,0 @@
-# Exception that is raised when an access to a resource is disallowed by
-# robots.txt or by HTML document itself.
-
-class Mechanize::RobotsDisallowedError < Mechanize::Error
-  def initialize(url)
-    if url.is_a?(URI)
-      @url = url.to_s
-      @uri = url
-    else
-      @url = url.to_s
-    end
-  end
-
-  # Returns the URL (string) of the resource that caused this error.
-  attr_reader :url
-
-  # Returns the URL (URI object) of the resource that caused this
-  # error.  URI::InvalidURIError may be raised if the URL happens to
-  # be invalid or not understood by the URI library.
-  def uri
-    @uri ||= URI.parse(url)
-  end
-
-  def to_s
-    "Robots access is disallowed for URL: #{url}"
-  end
-  alias :inspect :to_s
-end

data/lib/mechanize/test_case.rb

@@ -1,663 +0,0 @@
-require 'mechanize'
-require 'logger'
-require 'tempfile'
-require 'tmpdir'
-require 'webrick'
-require 'zlib'
-
-require 'rubygems'
-
-begin
-  gem 'minitest'
-rescue Gem::LoadError
-end
-
-require 'minitest/autorun'
-
-class Mechanize::TestCase < MiniTest::Unit::TestCase
-
-  TEST_DIR = File.expand_path '../../../test', __FILE__
-  REQUESTS = []
-
-  def setup
-    super
-
-    REQUESTS.clear
-    @mech = Mechanize.new
-    @ssl_private_key = nil
-    @ssl_certificate = nil
-  end
-
-  def fake_page agent = @mech
-    uri = URI 'http://fake.example/'
-    html = <<-END
-<html>
-<body>
-<form><input type="submit" value="submit" /></form>
-</body>
-</html>
-    END
-
-    response = { 'content-type' => 'text/html' }
-
-    Mechanize::Page.new uri, response, html, 200, agent
-  end
-
-  def have_encoding?
-    Object.const_defined? :Encoding
-  end
-
-  def html_page body
-    uri = URI 'http://example/'
-    Mechanize::Page.new uri, { 'content-type' => 'text/html' }, body, 200, @mech
-  end
-
-  def in_tmpdir
-    Dir.mktmpdir do |dir|
-      Dir.chdir dir do
-        yield
-      end
-    end
-  end
-
-  def node element, attributes = {}
-    doc = Nokogiri::HTML::Document.new
-
-    node = Nokogiri::XML::Node.new element, doc
-
-    attributes.each do |name, value|
-      node[name] = value
-    end
-
-    node
-  end
-
-  def page uri, content_type = 'text/html', body = '', code = 200
-    uri = URI uri unless URI::Generic === uri
-
-    Mechanize::Page.new(uri, { 'content-type' => content_type }, body, code,
-                        @mech)
-  end
-
-  def requests
-    REQUESTS
-  end
-
-  def ssl_private_key
-    @ssl_private_key ||= OpenSSL::PKey::RSA.new <<-KEY
------BEGIN RSA PRIVATE KEY-----
-MIG7AgEAAkEA8pmEfmP0Ibir91x6pbts4JmmsVZd3xvD5p347EFvBCbhBW1nv1Gs
-bCBEFlSiT1q2qvxGb5IlbrfdhdgyqdTXUQIBAQIBAQIhAPumXslvf6YasXa1hni3
-p80joKOug2UUgqOLD2GUSO//AiEA9ssY6AFxjHWuwo/+/rkLmkfO2s1Lz3OeUEWq
-6DiHOK8CAQECAQECIQDt8bc4vS6wh9VXApNSKIpVygtxSFe/IwLeX26n77j6Qg==
------END RSA PRIVATE KEY-----
-    KEY
-  end
-
-  def ssl_certificate
-    @ssl_certificate ||= OpenSSL::X509::Certificate.new <<-CERT
------BEGIN CERTIFICATE-----
-MIIBQjCB7aADAgECAgEAMA0GCSqGSIb3DQEBBQUAMCoxDzANBgNVBAMMBm5vYm9k
-eTEXMBUGCgmSJomT8ixkARkWB2V4YW1wbGUwIBcNMTExMTAzMjEwODU5WhgPOTk5
-OTEyMzExMjU5NTlaMCoxDzANBgNVBAMMBm5vYm9keTEXMBUGCgmSJomT8ixkARkW
-B2V4YW1wbGUwWjANBgkqhkiG9w0BAQEFAANJADBGAkEA8pmEfmP0Ibir91x6pbts
-4JmmsVZd3xvD5p347EFvBCbhBW1nv1GsbCBEFlSiT1q2qvxGb5IlbrfdhdgyqdTX
-UQIBATANBgkqhkiG9w0BAQUFAANBAAAB////////////////////////////////
-//8AMCEwCQYFKw4DAhoFAAQUePiv+QrJxyjtEJNnH5pB9OTWIqA=
------END CERTIFICATE-----
-    CERT
-  end
-
-end
-
-class BasicAuthServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req,res)
-    htpd = WEBrick::HTTPAuth::Htpasswd.new('dot.htpasswd')
-    htpd.set_passwd('Blah', 'user', 'pass')
-    authenticator = WEBrick::HTTPAuth::BasicAuth.new({
-      :UserDB => htpd,
-      :Realm  => 'Blah',
-      :Logger => Logger.new(nil)
-    }
-                                                    )
-                                                    begin
-                                                      authenticator.authenticate(req,res)
-                                                      res.body = 'You are authenticated'
-                                                    rescue WEBrick::HTTPStatus::Unauthorized
-                                                      res.status = 401
-                                                    end
-                                                    FileUtils.rm('dot.htpasswd')
-  end
-  alias :do_POST :do_GET
-end
-
-class ContentTypeServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    ct = req.query['ct'] || "text/html; charset=utf-8"
-    res['Content-Type'] = ct
-    res.body = "Hello World"
-  end
-end
-
-class DigestAuthServlet < WEBrick::HTTPServlet::AbstractServlet
-  htpd = WEBrick::HTTPAuth::Htdigest.new('digest.htpasswd')
-  htpd.set_passwd('Blah', 'user', 'pass')
-  @@authenticator = WEBrick::HTTPAuth::DigestAuth.new({
-    :UserDB => htpd,
-    :Realm  => 'Blah',
-    :Algorithm => 'MD5',
-    :Logger => Logger.new(nil)
-  }
-                                                     )
-                                                     def do_GET(req,res)
-                                                       def req.request_time; Time.now; end
-                                                       def req.request_uri; '/digest_auth'; end
-                                                       def req.request_method; "GET"; end
-
-                                                       begin
-                                                         @@authenticator.authenticate(req,res)
-                                                         res.body = 'You are authenticated'
-                                                       rescue WEBrick::HTTPStatus::Unauthorized
-                                                         res.status = 401
-                                                       end
-                                                       FileUtils.rm('digest.htpasswd') if File.exists?('digest.htpasswd')
-                                                     end
-                                                     alias :do_POST :do_GET
-end
-
-class FileUploadServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_POST(req, res)
-    res.body = req.body
-  end
-end
-
-class FormServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    res.body = "<HTML><body>"
-    req.query.each_key { |k|
-      req.query[k].each_data { |data|
-        res.body << "<a href=\"#\">#{WEBrick::HTTPUtils.unescape(k)}:#{WEBrick::HTTPUtils.unescape(data)}</a><br />"
-      }
-    }
-    res.body << "<div id=\"query\">#{res.query}</div></body></HTML>"
-    res['Content-Type'] = "text/html"
-  end
-
-  def do_POST(req, res)
-    res.body = "<HTML><body>"
-
-    req.query.each_key { |k|
-      req.query[k].each_data { |data|
-        res.body << "<a href=\"#\">#{k}:#{data}</a><br />"
-      }
-    }
-
-    res.body << "<div id=\"query\">#{req.body}</div></body></HTML>"
-    res['Content-Type'] = "text/html"
-  end
-end
-
-class GzipServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    if req['Accept-Encoding'] =~ /gzip/
-      if name = req.query['file'] then
-        open("#{Mechanize::TestCase::TEST_DIR}/htdocs/#{name}", 'r') do |io|
-          string = ""
-          zipped = StringIO.new string, 'w'
-          Zlib::GzipWriter.wrap zipped do |gz|
-            gz.write io.read
-          end
-          res.body = string
-        end
-      else
-        res.body = ''
-      end
-    res['Content-Encoding'] = req['X-ResponseContentEncoding'] || 'gzip'
-    res['Content-Type'] = "text/html"
-    else
-      res.code = 400
-      res.body = 'no gzip'
-    end
-  end
-end
-
-class HeaderServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    res['Content-Type'] = "text/html"
-
-    req.query.each do |x,y|
-      res[x] = y
-    end
-
-    body = ''
-    req.each_header do |k,v|
-      body << "#{k}|#{v}\n"
-    end
-    res.body = body
-  end
-end
-
-class HttpRefreshServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    res['Content-Type'] = req.query['ct'] || "text/html"
-    refresh_time = req.query['refresh_time'] || 0
-    refresh_url = req.query['refresh_url'] || '/index.html'
-    res['Refresh'] = " #{refresh_time};url=#{refresh_url}\r\n";
-  end
-end
-
-class InfiniteRedirectServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    res['Content-Type'] = req.query['ct'] || "text/html"
-    res.status = req.query['code'] ? req.query['code'].to_i : '302'
-    number = req.query['q'] ? req.query['q'].to_i : 0
-    res['Location'] = "/infinite_redirect?q=#{number + 1}"
-  end
-  alias :do_POST :do_GET
-end
-
-class InfiniteRefreshServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    res['Content-Type'] = req.query['ct'] || "text/html"
-    res.status = req.query['code'] ? req.query['code'].to_i : '302'
-    number = req.query['q'] ? req.query['q'].to_i : 0
-    res['Refresh'] = " 0;url=http://localhost/infinite_refresh?q=#{number + 1}\r\n";
-  end
-end
-
-class ManyCookiesAsStringServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    cookies = []
-    name_cookie = WEBrick::Cookie.new("name", "Aaron")
-    name_cookie.path = "/"
-    name_cookie.expires = Time.now + 86400
-    name_cookie.domain = 'localhost'
-    cookies << name_cookie
-    cookies << name_cookie
-    cookies << name_cookie
-    cookies << "#{name_cookie}; HttpOnly"
-
-    expired_cookie = WEBrick::Cookie.new("expired", "doh")
-    expired_cookie.path = "/"
-    expired_cookie.expires = Time.now - 86400
-    cookies << expired_cookie
-
-    different_path_cookie = WEBrick::Cookie.new("a_path", "some_path")
-    different_path_cookie.path = "/some_path"
-    different_path_cookie.expires = Time.now + 86400
-    cookies << different_path_cookie
-
-    no_path_cookie = WEBrick::Cookie.new("no_path", "no_path")
-    no_path_cookie.expires = Time.now + 86400
-    cookies << no_path_cookie
-
-    no_exp_path_cookie = WEBrick::Cookie.new("no_expires", "nope")
-    no_exp_path_cookie.path = "/"
-    cookies << no_exp_path_cookie
-
-    res['Set-Cookie'] = cookies.join(', ')
-
-    res['Content-Type'] = "text/html"
-    res.body = "<html><body>hello</body></html>"
-  end
-end
-
-class ManyCookiesServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    name_cookie = WEBrick::Cookie.new("name", "Aaron")
-    name_cookie.path = "/"
-    name_cookie.expires = Time.now + 86400
-    res.cookies << name_cookie
-    res.cookies << name_cookie
-    res.cookies << name_cookie
-    res.cookies << name_cookie
-
-    expired_cookie = WEBrick::Cookie.new("expired", "doh")
-    expired_cookie.path = "/"
-    expired_cookie.expires = Time.now - 86400
-    res.cookies << expired_cookie
-
-    different_path_cookie = WEBrick::Cookie.new("a_path", "some_path")
-    different_path_cookie.path = "/some_path"
-    different_path_cookie.expires = Time.now + 86400
-    res.cookies << different_path_cookie
-
-    no_path_cookie = WEBrick::Cookie.new("no_path", "no_path")
-    no_path_cookie.expires = Time.now + 86400
-    res.cookies << no_path_cookie
-
-    no_exp_path_cookie = WEBrick::Cookie.new("no_expires", "nope")
-    no_exp_path_cookie.path = "/"
-    res.cookies << no_exp_path_cookie
-
-    res['Content-Type'] = "text/html"
-    res.body = "<html><body>hello</body></html>"
-  end
-end
-
-class ModifiedSinceServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    s_time = 'Fri, 04 May 2001 00:00:38 GMT'
-
-    my_time = Time.parse(s_time)
-
-    if req['If-Modified-Since']
-      your_time = Time.parse(req['If-Modified-Since'])
-      if my_time > your_time
-        res.body = 'This page was updated since you requested'
-      else
-        res.status = 304
-      end
-    else
-      res.body = 'You did not send an If-Modified-Since header'
-    end
-
-    res['Last-Modified'] = s_time
-  end
-end
-
-class NTLMServlet < WEBrick::HTTPServlet::AbstractServlet
-
-  def do_GET(req, res)
-    if req['Authorization'] =~ /^NTLM (.*)/ then
-      authorization = $1.unpack('m*').first
-
-      if authorization =~ /^NTLMSSP\000\001/ then
-        type_2 = 'TlRMTVNTUAACAAAADAAMADAAAAABAoEAASNFZ4mr' \
-          'ze8AAAAAAAAAAGIAYgA8AAAARABPAE0AQQBJAE4A' \
-          'AgAMAEQATwBNAEEASQBOAAEADABTAEUAUgBWAEUA' \
-          'UgAEABQAZABvAG0AYQBpAG4ALgBjAG8AbQADACIA' \
-          'cwBlAHIAdgBlAHIALgBkAG8AbQBhAGkAbgAuAGMA' \
-          'bwBtAAAAAAA='
-
-        res['WWW-Authenticate'] = "NTLM #{type_2}"
-        res.status = 401
-      elsif authorization =~ /^NTLMSSP\000\003/ then
-        res.body = 'ok'
-      else
-        res['WWW-Authenticate'] = 'NTLM'
-        res.status = 401
-      end
-    else
-      res['WWW-Authenticate'] = 'NTLM'
-      res.status = 401
-    end
-  end
-
-end
-
-class OneCookieNoSpacesServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    cookie = WEBrick::Cookie.new("foo", "bar")
-    cookie.path = "/"
-    cookie.expires = Time.now + 86400
-    res.cookies << cookie.to_s.gsub(/; /, ';')
-    res['Content-Type'] = "text/html"
-    res.body = "<html><body>hello</body></html>"
-  end
-end
-
-class OneCookieServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    cookie = WEBrick::Cookie.new("foo", "bar")
-    cookie.path = "/"
-    cookie.expires = Time.now + 86400
-    res.cookies << cookie
-    res['Content-Type'] = "text/html"
-    res.body = "<html><body>hello</body></html>"
-  end
-end
-
-class QuotedValueCookieServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    cookie = WEBrick::Cookie.new("quoted", "\"value\"")
-    cookie.path = "/"
-    cookie.expires = Time.now + 86400
-    res.cookies << cookie
-    res['Content-Type'] = "text/html"
-    res.body = "<html><body>hello</body></html>"
-  end
-end
-
-class RedirectServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    res['Content-Type'] = req.query['ct'] || "text/html"
-    res.status = req.query['code'] ? req.query['code'].to_i : '302'
-    res['Location'] = "/verb"
-  end
-
-  alias :do_POST :do_GET
-  alias :do_HEAD :do_GET
-  alias :do_PUT :do_GET
-  alias :do_DELETE :do_GET
-end
-
-class RefererServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    res['Content-Type'] = "text/html"
-    res.body = req['Referer'] || ''
-  end
-
-  def do_POST(req, res)
-    res['Content-Type'] = "text/html"
-    res.body = req['Referer'] || ''
-  end
-end
-
-class RefreshWithoutUrl < WEBrick::HTTPServlet::AbstractServlet
-  @@count = 0
-  def do_GET(req, res)
-    res['Content-Type'] = "text/html"
-    @@count += 1
-    if @@count > 1
-      res['Refresh'] = "0; url=http://localhost/index.html";
-    else
-      res['Refresh'] = "0";
-    end
-  end
-end
-
-class RefreshWithEmptyUrl < WEBrick::HTTPServlet::AbstractServlet
-  @@count = 0
-  def do_GET(req, res)
-    res['Content-Type'] = "text/html"
-    @@count += 1
-    if @@count > 1
-      res['Refresh'] = "0; url=http://localhost/index.html";
-    else
-      res['Refresh'] = "0; url=";
-    end
-  end
-end
-
-class ResponseCodeServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    res['Content-Type'] = req.query['ct'] || "text/html"
-    if req.query['code']
-      code = req.query['code'].to_i
-      case code
-      when 300, 301, 302, 303, 304, 305, 307
-        res['Location'] = "/index.html"
-      end
-      res.status = code
-    else
-    end
-  end
-end
-
-class SendCookiesServlet < WEBrick::HTTPServlet::AbstractServlet
-  def do_GET(req, res)
-    res['Content-Type'] = "text/html"
-    res.body = "<html><body>"
-    req.cookies.each { |c|
-      res.body << "<a href=\"#\">#{c.name}:#{c.value}</a>"
-    }
-    res.body << "</body></html>"
-  end
-end
-
-class VerbServlet < WEBrick::HTTPServlet::AbstractServlet
-  %w(HEAD GET POST PUT DELETE).each do |verb|
-    eval(<<-eomethod)
-      def do_#{verb}(req, res)
-        res.header['X-Request-Method'] = #{verb.dump}
-      end
-        eomethod
-  end
-end
-
-class Net::HTTP
-  alias :old_do_start :do_start
-
-  def do_start
-    @started = true
-  end
-
-  SERVLETS = {
-    '/gzip'                   => GzipServlet,
-    '/form_post'              => FormServlet,
-    '/basic_auth'             => BasicAuthServlet,
-    '/form post'              => FormServlet,
-    '/response_code'          => ResponseCodeServlet,
-    '/http_refresh'           => HttpRefreshServlet,
-    '/content_type_test'      => ContentTypeServlet,
-    '/referer'                => RefererServlet,
-    '/file_upload'            => FileUploadServlet,
-    '/one_cookie'             => OneCookieServlet,
-    '/one_cookie_no_space'    => OneCookieNoSpacesServlet,
-    '/many_cookies'           => ManyCookiesServlet,
-    '/many_cookies_as_string' => ManyCookiesAsStringServlet,
-    '/ntlm'                   => NTLMServlet,
-    '/send_cookies'           => SendCookiesServlet,
-    '/quoted_value_cookie'    => QuotedValueCookieServlet,
-    '/if_modified_since'      => ModifiedSinceServlet,
-    '/http_headers'           => HeaderServlet,
-    '/infinite_redirect'      => InfiniteRedirectServlet,
-    '/infinite_refresh'       => InfiniteRefreshServlet,
-    '/redirect'               => RedirectServlet,
-    '/refresh_without_url'    => RefreshWithoutUrl,
-    '/refresh_with_empty_url' => RefreshWithEmptyUrl,
-    '/digest_auth'            => DigestAuthServlet,
-    '/verb'                   => VerbServlet,
-  }
-
-  PAGE_CACHE = {}
-
-  alias :old_request :request
-
-  def request(req, *data, &block)
-    url = URI.parse(req.path)
-    path = WEBrick::HTTPUtils.unescape(url.path)
-
-    path = '/index.html' if path == '/'
-
-    res = ::Response.new
-    res.query_params = url.query
-
-    req.query = if 'POST' != req.method && url.query then
-                  WEBrick::HTTPUtils.parse_query url.query
-                elsif req['content-type'] =~ /www-form-urlencoded/ then
-                  WEBrick::HTTPUtils.parse_query req.body
-                elsif req['content-type'] =~ /boundary=(.+)/ then
-                  boundary = WEBrick::HTTPUtils.dequote $1
-                  WEBrick::HTTPUtils.parse_form_data req.body, boundary
-                else
-                  {}
-                end
-
-    req.cookies = WEBrick::Cookie.parse(req['Cookie'])
-
-    Mechanize::TestCase::REQUESTS << req
-
-    if servlet_klass = SERVLETS[path]
-      servlet = servlet_klass.new({})
-      servlet.send "do_#{req.method}", req, res
-    else
-      filename = "htdocs#{path.gsub(/[^\/\\.\w\s]/, '_')}"
-      unless PAGE_CACHE[filename]
-        open("#{Mechanize::TestCase::TEST_DIR}/#{filename}", 'rb') { |io|
-          PAGE_CACHE[filename] = io.read
-        }
-      end
-
-      res.body = PAGE_CACHE[filename]
-      case filename
-      when /\.txt$/
-        res['Content-Type'] = 'text/plain'
-      when /\.jpg$/
-        res['Content-Type'] = 'image/jpeg'
-      end
-    end
-
-    res['Content-Type'] ||= 'text/html'
-    res.code ||= "200"
-
-    response_klass = Net::HTTPResponse::CODE_TO_OBJ[res.code.to_s]
-    response = response_klass.new res.http_version, res.code, res.message
-
-    res.header.each do |k,v|
-      v = v.first if v.length == 1
-      response[k] = v
-    end
-
-    res.cookies.each do |cookie|
-      response.add_field 'Set-Cookie', cookie.to_s
-    end
-
-    response['Content-Type'] ||= 'text/html'
-    response['Content-Length'] = res['Content-Length'] || res.body.length.to_s
-
-    io = StringIO.new(res.body)
-    response.instance_variable_set :@socket, io
-    def io.read clen, dest, _
-      dest << string[0, clen]
-    end
-
-    body_exist = req.response_body_permitted? &&
-      response_klass.body_permitted?
-
-    response.instance_variable_set :@body_exist, body_exist
-
-    yield response if block_given?
-
-    response
-  end
-end
-
-class Net::HTTPRequest
-  attr_accessor :query, :body, :cookies, :user
-end
-
-class Response
-  include Net::HTTPHeader
-
-  attr_reader :code
-  attr_accessor :body, :query, :cookies
-  attr_accessor :query_params, :http_version
-  attr_accessor :header
-
-  def code=(c)
-    @code = c.to_s
-  end
-
-  alias :status :code
-  alias :status= :code=
-
-    def initialize
-      @header = {}
-      @body = ''
-      @code = nil
-      @query = nil
-      @cookies = []
-      @http_version = '1.1'
-    end
-
-  def read_body
-    yield body
-  end
-
-  def message
-    ''
-  end
-end
-