class Mechanize::HTTP::Agent

# File lib/mechanize/http/agent.rb, line 119
def initialize
  @conditional_requests     = true
  @context                  = nil
  @content_encoding_hooks   = []
  @cookie_jar               = Mechanize::CookieJar.new
  @follow_meta_refresh      = false
  @follow_meta_refresh_self = false
  @gzip_enabled             = true
  @history                  = Mechanize::History.new
  @keep_alive               = true
  @max_file_buffer          = 100_000 # 5MB for response bodies
  @open_timeout             = nil
  @post_connect_hooks       = []
  @pre_connect_hooks        = []
  @read_timeout             = nil
  @redirect_ok              = true
  @redirection_limit        = 20
  @request_headers          = {}
  @robots                   = false
  @user_agent               = nil
  @webrobots                = nil

  # HTTP Authentication
  @authenticate_parser  = Mechanize::HTTP::WWWAuthenticateParser.new
  @authenticate_methods = Hash.new do |methods, uri|
    methods[uri] = Hash.new do |realms, auth_scheme|
      realms[auth_scheme] = []
    end
  end
  @digest_auth          = Net::HTTP::DigestAuth.new
  @digest_challenges    = {}
  @password             = nil # HTTP auth password
  @user                 = nil # HTTP auth user
  @domain               = nil # NTLM HTTP domain

  # SSL
  @pass = nil

  @scheme_handlers = Hash.new { |h, scheme|
    h[scheme] = lambda { |link, page|
      raise Mechanize::UnsupportedSchemeError, scheme
    }
  }

  @scheme_handlers['http']      = lambda { |link, page| link }
  @scheme_handlers['https']     = @scheme_handlers['http']
  @scheme_handlers['relative']  = @scheme_handlers['http']
  @scheme_handlers['file']      = @scheme_handlers['http']

  @http = Net::HTTP::Persistent.new 'mechanize'
  @http.idle_timeout = 5
  @http.keep_alive   = 300
end

# File lib/mechanize/http/agent.rb, line 181
def fetch uri, method = :get, headers = {}, params = [],
          referer = current_page, redirects = 0
  referer_uri = referer ? referer.uri : nil

  uri = resolve uri, referer

  uri, params = resolve_parameters uri, method, params

  request = http_request uri, method, params

  connection = connection_for uri

  request_auth             request, uri

  disable_keep_alive       request
  enable_gzip              request

  request_language_charset request
  request_cookies          request, uri
  request_host             request, uri
  request_referer          request, uri, referer_uri
  request_user_agent       request
  request_add_headers      request, headers

  pre_connect              request

  # Consult robots.txt
  if robots && uri.is_a?(URI::HTTP)
    robots_allowed?(uri) or raise Mechanize::RobotsDisallowedError.new(uri)
  end

  # Add If-Modified-Since if page is in history
  page = visited_page(uri)

  if (page = visited_page(uri)) and page.response['Last-Modified']
    request['If-Modified-Since'] = page.response['Last-Modified']
  end if(@conditional_requests)

  # Specify timeouts if given
  connection.open_timeout = @open_timeout if @open_timeout
  connection.read_timeout = @read_timeout if @read_timeout

  request_log request

  response_body_io = nil

  # Send the request
  response = connection.request(uri, request) { |res|
    response_log res

    response_body_io = response_read res, request, uri

    res
  }

  hook_content_encoding response, uri, response_body_io

  response_body_io = response_content_encoding response, response_body_io if
    request.response_body_permitted?

  post_connect uri, response, response_body_io

  page = response_parse response, response_body_io, uri

  response_cookies response, uri, page

  meta = response_follow_meta_refresh response, uri, page, redirects
  return meta if meta

  case response
  when Net::HTTPSuccess
    if robots && page.is_a?(Mechanize::Page)
      page.parser.noindex? and raise Mechanize::RobotsDisallowedError.new(uri)
    end

    page
  when Mechanize::FileResponse
    page
  when Net::HTTPNotModified
    log.debug("Got cached page") if log
    visited_page(uri) || page
  when Net::HTTPRedirection
    response_redirect response, method, page, redirects, referer
  when Net::HTTPUnauthorized
    response_authenticate(response, page, uri, request, headers, params,
                          referer)
  else
    raise Mechanize::ResponseCodeError.new(page), "Unhandled response"
  end
end

# File lib/mechanize/http/agent.rb, line 274
def proxy_uri
  @http.proxy_uri
end

# File lib/mechanize/http/agent.rb, line 279
def retry_change_requests
  @http.retry_change_requests
end

# File lib/mechanize/http/agent.rb, line 285
def retry_change_requests= retri
  @http.retry_change_requests = retri
end

# File lib/mechanize/http/agent.rb, line 291
def user_agent= user_agent
  @webrobots = nil if user_agent != @user_agent
  @user_agent = user_agent
end

# File lib/mechanize/http/agent.rb, line 300
def back
  @history.pop
end

# File lib/mechanize/http/agent.rb, line 307
def current_page
  @history.last
end

# File lib/mechanize/http/agent.rb, line 311
def max_history
  @history.max_size
end

# File lib/mechanize/http/agent.rb, line 315
def max_history=(length)
  @history.max_size = length
end

# File lib/mechanize/http/agent.rb, line 320
def visited_page url
  @history.visited_page resolve url
end

# File lib/mechanize/http/agent.rb, line 326
def hook_content_encoding response, uri, response_body_io
  @content_encoding_hooks.each do |hook|
    hook.call self, uri, response, response_body_io
  end
end

# File lib/mechanize/http/agent.rb, line 339
def post_connect uri, response, body_io # :yields: agent, uri, response, body
  @post_connect_hooks.each do |hook|
    begin
      hook.call self, uri, response, body_io.read
    ensure
      body_io.rewind
    end
  end
end

# File lib/mechanize/http/agent.rb, line 353
def pre_connect request # :yields: agent, request
  @pre_connect_hooks.each do |hook|
    hook.call self, request
  end
end

# File lib/mechanize/http/agent.rb, line 361
def connection_for uri
  case uri.scheme.downcase
  when 'http', 'https' then
    return @http
  when 'file' then
    return Mechanize::FileConnection.new
  end
end

# File lib/mechanize/http/agent.rb, line 374
def content_encoding_gunzip body_io
  log.debug('gzip response') if log

  zio = Zlib::GzipReader.new body_io
  out_io = auto_io 'mechanize-gunzip', 16384, zio
  zio.finish

  return out_io
rescue Zlib::Error
  log.error('unable to gunzip response, trying raw inflate') if log

  body_io.rewind
  body_io.read 10

  begin
    return inflate body_io, -Zlib::MAX_WBITS
  rescue Zlib::Error => e
    log.error("unable to gunzip response: #{e}") if log
    raise
  end
ensure
  zio.close if zio and not zio.closed?
  body_io.close unless body_io.closed?
end

# File lib/mechanize/http/agent.rb, line 403
def content_encoding_inflate body_io
  log.debug('deflate body') if log

  return inflate body_io
rescue Zlib::Error
  log.error('unable to inflate response, trying raw deflate') if log

  body_io.rewind

  begin
    return inflate body_io, -Zlib::MAX_WBITS
  rescue Zlib::Error => e
    log.error("unable to inflate response: #{e}") if log
    raise
  end
ensure
  body_io.close
end

# File lib/mechanize/http/agent.rb, line 422
def disable_keep_alive request
  request['connection'] = 'close' unless @keep_alive
end

# File lib/mechanize/http/agent.rb, line 426
def enable_gzip request
  request['accept-encoding'] = if @gzip_enabled
                                 'gzip,deflate,identity'
                               else
                                 'identity'
                               end
end

# File lib/mechanize/http/agent.rb, line 434
def http_request uri, method, params = nil
  case uri.scheme.downcase
  when 'http', 'https' then
    klass = Net::HTTP.const_get(method.to_s.capitalize)

    request ||= klass.new(uri.request_uri)
    request.body = params.first if params

    request
  when 'file' then
    Mechanize::FileRequest.new uri
  end
end

# File lib/mechanize/http/agent.rb, line 448
def request_add_headers request, headers = {}
  @request_headers.each do |k,v|
    request[k] = v
  end

  headers.each do |field, value|
    case field
    when :etag              then request["ETag"] = value
    when :if_modified_since then request["If-Modified-Since"] = value
    when Symbol then
      raise ArgumentError, "unknown header symbol #{field}"
    else
      request[field] = value
    end
  end
end

# File lib/mechanize/http/agent.rb, line 465
def request_auth request, uri
  base_uri = uri + '/'
  schemes = @authenticate_methods[base_uri]

  if realm = schemes[:digest].find { |r| r.uri == base_uri } then
    request_auth_digest request, uri, realm, base_uri, false
  elsif realm = schemes[:iis_digest].find { |r| r.uri == base_uri } then
    request_auth_digest request, uri, realm, base_uri, true
  elsif schemes[:basic].find { |r| r.uri == base_uri } then
    request.basic_auth @user, @password
  end
end

# File lib/mechanize/http/agent.rb, line 478
def request_auth_digest request, uri, realm, base_uri, iis
  challenge = @digest_challenges[realm]

  uri.user = @user
  uri.password = @password

  auth = @digest_auth.auth_header uri, challenge.to_s, request.method, iis
  request['Authorization'] = auth
end

# File lib/mechanize/http/agent.rb, line 488
def request_cookies request, uri
  return if @cookie_jar.empty? uri

  cookies = @cookie_jar.cookies uri

  return if cookies.empty?

  request.add_field 'Cookie', cookies.join('; ')
end

# File lib/mechanize/http/agent.rb, line 498
def request_host request, uri
  port = [80, 443].include?(uri.port.to_i) ? nil : uri.port
  host = uri.host

  request['Host'] = [host, port].compact.join ':'
end

# File lib/mechanize/http/agent.rb, line 505
def request_language_charset request
  request['accept-charset']  = 'ISO-8859-1,utf-8;q=0.7,*;q=0.7'
  request['accept-language'] = 'en-us,en;q=0.5'
end

# File lib/mechanize/http/agent.rb, line 511
def request_log request
  return unless log

  log.info("#{request.class}: #{request.path}")

  request.each_header do |k, v|
    log.debug("request-header: #{k} => #{v}")
  end
end

# File lib/mechanize/http/agent.rb, line 524
def request_referer request, uri, referer
  return unless referer
  return if 'https' == referer.scheme.downcase and
            'https' != uri.scheme.downcase
  if referer.fragment || referer.user || referer.password
    referer = referer.dup
    referer.fragment = referer.user = referer.password = nil
  end
  request['Referer'] = referer
end

# File lib/mechanize/http/agent.rb, line 535
def request_user_agent request
  request['User-Agent'] = @user_agent if @user_agent
end

# File lib/mechanize/http/agent.rb, line 539
def resolve(uri, referer = current_page)
  referer_uri = referer && referer.uri
  if uri.is_a?(URI)
    uri = uri.dup
  elsif uri.nil?
    if referer_uri
      return referer_uri
    end
    raise ArgumentError, "absolute URL needed (not nil)"
  else
    url = uri.to_s.strip
    if url.empty?
      if referer_uri
        return referer_uri.dup.tap { |u| u.fragment = nil }
      end
      raise ArgumentError, "absolute URL needed (not #{uri.inspect})"
    end

    url.gsub!(%r[^#{0.chr}-#{126.chr}]/) { |match|
      if RUBY_VERSION >= "1.9.0"
        Mechanize::Util.uri_escape(match)
      else
        sprintf('%%%X', match.unpack($KCODE == 'UTF8' ? 'U' : 'C')[0])
      end
    }

    escaped_url = Mechanize::Util.html_unescape(
      url.split(%r((?:%[0-9A-Fa-f]{2})+|#)/).each_slice(2).map { |x, y|
        "#{WEBrick::HTTPUtils.escape(x)}#{y}"
      }.join('')
    )

    begin
      uri = URI.parse(escaped_url)
    rescue
      uri = URI.parse(WEBrick::HTTPUtils.escape(escaped_url))
    end
  end

  scheme = uri.relative? ? 'relative' : uri.scheme.downcase
  uri = @scheme_handlers[scheme].call(uri, referer)

  if referer_uri
    if uri.path.length == 0 && uri.relative?
      uri.path = referer_uri.path
    end
  end

  uri.path = '/' if uri.path.length == 0

  if uri.relative?
    raise ArgumentError, "absolute URL needed (not #{uri})" unless
      referer_uri

    if referer.respond_to?(:bases) && referer.parser &&
        (lbase = referer.bases.last) && lbase.uri && lbase.uri.absolute?
      base = lbase
    else
      base = nil
    end

    uri = referer_uri + (base ? base.uri : referer_uri) + uri
    # Strip initial "/.." bits from the path
    uri.path.sub!(%r^(\/\.\.)+(?=\/)/, '')
  end

  unless ['http', 'https', 'file'].include?(uri.scheme.downcase)
    raise ArgumentError, "unsupported scheme: #{uri.scheme}"
  end

  uri
end

# File lib/mechanize/http/agent.rb, line 612
def resolve_parameters uri, method, parameters
  case method
  when :head, :get, :delete, :trace then
    if parameters and parameters.length > 0
      uri.query ||= ''
      uri.query << '&' if uri.query.length > 0
      uri.query << Mechanize::Util.build_query_string(parameters)
    end

    return uri, nil
  end

  return uri, parameters
end

# File lib/mechanize/http/agent.rb, line 629
def get_meta_refresh response, uri, page
  return nil unless @follow_meta_refresh

  if page.respond_to?(:meta_refresh) and
     (redirect = page.meta_refresh.first) then
    [redirect.delay, redirect.href] unless
      not @follow_meta_refresh_self and redirect.link_self
  elsif refresh = response['refresh']
    delay, href, link_self = Mechanize::Page::MetaRefresh.parse refresh, uri
    raise Mechanize::Error, 'Invalid refresh http header' unless delay
    [delay.to_f, href] unless
      not @follow_meta_refresh_self and link_self
  end
end

# File lib/mechanize/http/agent.rb, line 644
def response_authenticate(response, page, uri, request, headers, params,
                          referer)
  raise Mechanize::UnauthorizedError, page unless @user || @password

  www_authenticate = response['www-authenticate']

  raise Mechanize::UnauthorizedError, page unless www_authenticate

  challenges = @authenticate_parser.parse www_authenticate

  if challenge = challenges.find { |c| c.scheme =~ %r^Digest$/ } then
    realm = challenge.realm uri

    auth_scheme = if response['server'] =~ %rMicrosoft-IIS/ then
                    :iis_digest
                  else
                    :digest
                  end

    existing_realms = @authenticate_methods[realm.uri][auth_scheme]

    raise Mechanize::UnauthorizedError, page if
      existing_realms.include? realm

    existing_realms << realm
    @digest_challenges[realm] = challenge
  elsif challenge = challenges.find { |c| c.scheme == 'NTLM' } then
    existing_realms = @authenticate_methods[uri + '/'][:ntlm]

    raise Mechanize::UnauthorizedError, page if
      existing_realms.include?(realm) and not challenge.params

    existing_realms << realm

    if challenge.params then
      type_2 = Net::NTLM::Message.decode64 challenge.params

      type_3 = type_2.response({ :user => @user, :password => @password, :domain => @domain },
                               { :ntlmv2 => true }).encode64

      headers['Authorization'] = "NTLM #{type_3}"
    else
      type_1 = Net::NTLM::Message::Type1.new.encode64
      headers['Authorization'] = "NTLM #{type_1}"
    end
  elsif challenge = challenges.find { |c| c.scheme == 'Basic' } then
    realm = challenge.realm uri

    existing_realms = @authenticate_methods[realm.uri][:basic]

    raise Mechanize::UnauthorizedError, page if
      existing_realms.include? realm

    existing_realms << realm
  else
    raise Mechanize::UnauthorizedError, page
  end

  fetch uri, request.method.downcase.to_sym, headers, params, referer
end

# File lib/mechanize/http/agent.rb, line 705
def response_content_encoding response, body_io
  length = response.content_length ||
    case body_io
    when Tempfile, IO then
      body_io.stat.size
    else
      body_io.length
    end

  return body_io if length.zero?

  out_io = case response['Content-Encoding']
           when nil, 'none', '7bit' then
             body_io
           when 'deflate' then
             content_encoding_inflate body_io
           when 'gzip', 'x-gzip' then
             content_encoding_gunzip body_io
           else
             raise Mechanize::Error,
               "unsupported content-encoding: #{response['Content-Encoding']}"
           end

  out_io.flush
  out_io.rewind

  out_io
rescue Zlib::Error => e
  message = "error handling content-encoding #{response['Content-Encoding']}:"
  message << " #{e.message} (#{e.class})"
  raise Mechanize::Error, message
ensure
  begin
    if Tempfile === body_io and
       (StringIO === out_io or out_io.path != body_io.path) then
      body_io.close! 
    end
  rescue IOError
    # HACK ruby 1.8 raises IOError when closing the stream
  end
end

# File lib/mechanize/http/agent.rb, line 747
def response_cookies response, uri, page
  if Mechanize::Page === page and page.body =~ %rSet-Cookie/
    page.search('//head/meta[@http-equiv="Set-Cookie"]').each do |meta|
      save_cookies(uri, meta['content'])
    end
  end

  header_cookies = response.get_fields 'Set-Cookie'

  return unless header_cookies

  header_cookies.each do |set_cookie|
    save_cookies(uri, set_cookie)
  end
end

# File lib/mechanize/http/agent.rb, line 774
def response_follow_meta_refresh response, uri, page, redirects
  delay, new_url = get_meta_refresh(response, uri, page)
  return nil unless delay
  new_url = new_url ? resolve(new_url, page) : uri

  raise Mechanize::RedirectLimitReachedError.new(page, redirects) if
    redirects + 1 > @redirection_limit

  sleep delay
  @history.push(page, page.uri)
  fetch new_url, :get, {}, [],
        Mechanize::Page.new, redirects
end

# File lib/mechanize/http/agent.rb, line 788
def response_log response
  return unless log

  log.info("status: #{response.class} #{response.http_version} "               "#{response.code} #{response.message}")

  response.each_header do |k, v|
    log.debug("response-header: #{k} => #{v}")
  end
end

# File lib/mechanize/http/agent.rb, line 799
def response_parse response, body_io, uri
  @context.parse uri, response, body_io
end

# File lib/mechanize/http/agent.rb, line 803
def response_read response, request, uri
  content_length = response.content_length

  if use_tempfile? content_length then
    body_io = Tempfile.new 'mechanize-raw'
    body_io.unlink
    body_io.binmode if defined? body_io.binmode
  else
    body_io = StringIO.new
  end

  body_io.set_encoding Encoding::BINARY if body_io.respond_to? :set_encoding
  total = 0

  begin
    response.read_body { |part|
      total += part.length

      if StringIO === body_io and use_tempfile? total then
        new_io = Tempfile.new 'mechanize-raw'
        new_io.unlink
        new_io.binmode

        new_io.write body_io.string

        body_io = new_io
      end

      body_io.write(part)
      log.debug("Read #{part.length} bytes (#{total} total)") if log
    }
  rescue Net::HTTP::Persistent::Error => e
    body_io.rewind
    raise Mechanize::ResponseReadError.new(e, response, body_io, uri,
                                           @context)
  end

  body_io.flush
  body_io.rewind

  raise Mechanize::ResponseCodeError, response if
    Net::HTTPUnknownResponse === response

  content_length = response.content_length

  unless Net::HTTP::Head === request or Net::HTTPRedirection === response then
    raise EOFError, "Content-Length (#{content_length}) does not match "                        "response body length (#{body_io.length})" if
      content_length and content_length != body_io.length
  end

  body_io
end

# File lib/mechanize/http/agent.rb, line 857
def response_redirect response, method, page, redirects, referer = current_page
  case @redirect_ok
  when true, :all
    # shortcut
  when false, nil
    return page
  when :permanent
    return page unless Net::HTTPMovedPermanently === response
  end

  log.info("follow redirect to: #{response['Location']}") if log

  raise Mechanize::RedirectLimitReachedError.new(page, redirects) if
    redirects + 1 > @redirection_limit

  redirect_method = method == :head ? :head : :get

  @history.push(page, page.uri)
  new_uri = resolve response['Location'].to_s, page

  fetch new_uri, redirect_method, {}, [], referer, redirects + 1
end

# File lib/mechanize/http/agent.rb, line 763
def save_cookies(uri, set_cookie)
  log = log()  # reduce method calls
  Mechanize::Cookie.parse(uri, set_cookie, log) { |c|
    if @cookie_jar.add(uri, c)
      log.debug("saved cookie: #{c}") if log
    else
      log.debug("rejected cookie: #{c}") if log
    end
  }
end

# File lib/mechanize/http/agent.rb, line 889
def robots= value
  require 'webrobots' if value
  @webrobots = nil if value != @robots
  @robots = value
end

# File lib/mechanize/http/agent.rb, line 899
def robots_allowed? uri
  return true if uri.request_uri == '/robots.txt'

  webrobots.allowed? uri
end

# File lib/mechanize/http/agent.rb, line 907
def robots_disallowed? url
  !robots_allowed? url
end

# File lib/mechanize/http/agent.rb, line 913
def robots_error(url)
  webrobots.error(url)
end

# File lib/mechanize/http/agent.rb, line 919
def robots_error!(url)
  webrobots.error!(url)
end

# File lib/mechanize/http/agent.rb, line 924
def robots_reset(url)
  webrobots.reset(url)
end

# File lib/mechanize/http/agent.rb, line 928
def webrobots
  @webrobots ||= WebRobots.new(@user_agent, :http_get => method(:get_robots))
end

# File lib/mechanize/http/agent.rb, line 935
def ca_file
  @http.ca_file
end

# File lib/mechanize/http/agent.rb, line 940
def ca_file= ca_file
  @http.ca_file = ca_file
end

# File lib/mechanize/http/agent.rb, line 945
def cert_store
  @http.cert_store
end

# File lib/mechanize/http/agent.rb, line 950
def cert_store= cert_store
  @http.cert_store = cert_store
end

# File lib/mechanize/http/agent.rb, line 955
def certificate
  @http.certificate
end

# File lib/mechanize/http/agent.rb, line 961
def certificate= certificate
  certificate = if OpenSSL::X509::Certificate === certificate then
                  certificate
                else
                  OpenSSL::X509::Certificate.new File.read certificate
                end

  @http.certificate = certificate
end

# File lib/mechanize/http/agent.rb, line 972
def private_key
  @http.private_key
end

# File lib/mechanize/http/agent.rb, line 977
def private_key= private_key
  private_key = if OpenSSL::PKey::PKey === private_key then
                  private_key
                else
                  OpenSSL::PKey::RSA.new File.read(private_key), @pass
                end

  @http.private_key = private_key
end

# File lib/mechanize/http/agent.rb, line 988
def ssl_version
  @http.ssl_version
end

# File lib/mechanize/http/agent.rb, line 993
def ssl_version= ssl_version
  @http.ssl_version = ssl_version
end

# File lib/mechanize/http/agent.rb, line 1003
def verify_callback
  @http.verify_callback
end

# File lib/mechanize/http/agent.rb, line 1008
def verify_callback= verify_callback
  @http.verify_callback = verify_callback
end

# File lib/mechanize/http/agent.rb, line 1013
def verify_mode
  @http.verify_mode
end

# File lib/mechanize/http/agent.rb, line 1018
def verify_mode= verify_mode
  @http.verify_mode = verify_mode
end

# File lib/mechanize/http/agent.rb, line 1025
def idle_timeout
  @http.idle_timeout
end

# File lib/mechanize/http/agent.rb, line 1030
def idle_timeout= timeout
  @http.idle_timeout = timeout
end

# File lib/mechanize/http/agent.rb, line 1044
def auto_io name, read_size, input_io
  out_io = StringIO.new

  out_io.set_encoding Encoding::BINARY if out_io.respond_to? :set_encoding

  until input_io.eof? do
    if StringIO === out_io and use_tempfile? out_io.size then
      new_io = Tempfile.new name
      new_io.unlink
      new_io.binmode

      new_io.write out_io.string
      out_io = new_io
    end

    chunk = input_io.read read_size
    chunk = yield chunk if block_given?

    out_io.write chunk
  end

  out_io.rewind

  out_io
end

# File lib/mechanize/http/agent.rb, line 1070
def inflate compressed, window_bits = nil
  inflate = Zlib::Inflate.new window_bits

  out_io = auto_io 'mechanize-inflate', 1024, compressed do |chunk|
    inflate.inflate chunk
  end

  out_io.write inflate.finish

  out_io
ensure
  inflate.close
end

# File lib/mechanize/http/agent.rb, line 1084
def log
  @context.log
end

# File lib/mechanize/http/agent.rb, line 1093
def set_proxy addr, port, user = nil, pass = nil
  unless addr and port then
    @http.proxy = nil

    return
  end

  unless Integer === port then
    begin
      port = Socket.getservbyname port
    rescue SocketError
      begin
        port = Integer port
      rescue ArgumentError
        raise ArgumentError, "invalid value for port: #{port.inspect}"
      end
    end
  end

  proxy_uri = URI "http://#{addr}"
  proxy_uri.port = port
  proxy_uri.user     = user if user
  proxy_uri.password = pass if pass

  @http.proxy = proxy_uri
end

# File lib/mechanize/http/agent.rb, line 1120
def use_tempfile? size
  return false unless @max_file_buffer
  return false unless size

  size >= @max_file_buffer
end