class Mechanize

# File lib/mechanize.rb, line 188
def initialize(connection_name = 'mechanize')
  @agent = Mechanize::HTTP::Agent.new(connection_name)
  @agent.context = self
  @log = nil

  # attr_accessors
  @agent.user_agent = AGENT_ALIASES['Mechanize']
  @watch_for_set    = nil
  @history_added    = nil

  # attr_readers
  @pluggable_parser = PluggableParser.new

  @keep_alive_time  = 0

  # Proxy
  @proxy_addr = nil
  @proxy_port = nil
  @proxy_user = nil
  @proxy_pass = nil

  @html_parser = self.class.html_parser

  @default_encoding = nil
  @force_default_encoding = false

  # defaults
  @agent.max_history = 50

  yield self if block_given?

  @agent.set_proxy @proxy_addr, @proxy_port, @proxy_user, @proxy_pass
end

# File lib/mechanize.rb, line 163
def self.start
  instance = new
  yield(instance)
ensure
  instance.shutdown
end

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

# File lib/mechanize.rb, line 236
def current_page
  @agent.current_page
end

# File lib/mechanize.rb, line 245
def history
  @agent.history
end

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

# File lib/mechanize.rb, line 268
def max_history= length
  @agent.history.max_size = length
end

# File lib/mechanize.rb, line 275
def visited? url
  url = url.href if url.respond_to? :href

  @agent.visited_page url
end

# File lib/mechanize.rb, line 296
def content_encoding_hooks
  @agent.content_encoding_hooks
end

# File lib/mechanize.rb, line 309
def post_connect_hooks
  @agent.post_connect_hooks
end

# File lib/mechanize.rb, line 317
def pre_connect_hooks
  @agent.pre_connect_hooks
end

# File lib/mechanize.rb, line 330
def click link
  case link
  when Page::Link then
    referer = link.page || current_page()
    if @agent.robots
      if (referer.is_a?(Page) and referer.parser.nofollow?) or
         link.rel?('nofollow') then
        raise RobotsDisallowedError.new(link.href)
      end
    end
    if link.noreferrer?
      href = @agent.resolve(link.href, link.page || current_page)
      referer = Page.new
    else
      href = link.href
    end
    get href, [], referer
  when String, Regexp then
    if real_link = page.link_with(:text => link)
      click real_link
    else
      button = nil
      # Note that this will not work if we have since navigated to a different page.
      # Should rather make each button aware of its parent form.
      form = page.forms.find do |f|
        button = f.button_with(:value => link)
        button.is_a? Form::Submit
      end
      submit form, button if form
    end
  when Form::Submit, Form::ImageButton then
    # Note that this will not work if we have since navigated to a different page.
    # Should rather make each button aware of its parent form.
    form = page.forms.find do |f|
      f.buttons.include?(link)
    end
    submit form, link if form
  else
    referer = current_page()
    href = link.respond_to?(:href) ? link.href :
      (link['href'] || link['src'])
    get href, [], referer
  end
end

# File lib/mechanize.rb, line 424
def delete(uri, query_params = {}, headers = {})
  page = @agent.fetch(uri, :delete, headers, query_params)
  add_to_history(page)
  page
end

# File lib/mechanize.rb, line 389
def download uri, io_or_filename, parameters = [], referer = nil, headers = {}
  page = transact do
    get uri, parameters, referer, headers
  end

  io = if io_or_filename.respond_to? :write then
         io_or_filename
       else
         open io_or_filename, 'wb'
       end

  case page
  when Mechanize::File then
    io.write page.body
  else
    body_io = page.body_io

    until body_io.eof? do
      io.write body_io.read 16384
    end
  end

  page
ensure
  io.close if io and not io_or_filename.respond_to? :write
end

# File lib/mechanize.rb, line 439
def get(uri, parameters = [], referer = nil, headers = {})
  method = :get

  referer ||=
    if uri.to_s =~ %r{\Ahttps?://}
      Page.new
    else
      current_page || Page.new
    end

  # FIXME: Huge hack so that using a URI as a referer works.  I need to
  # refactor everything to pass around URIs but still support
  # Mechanize::Page#base
  unless Mechanize::Parser === referer then
    referer = if referer.is_a?(String) then
                Page.new URI(referer)
              else
                Page.new referer
              end
  end

  # fetch the page
  headers ||= {}
  page = @agent.fetch uri, method, headers, parameters, referer
  add_to_history(page)
  yield page if block_given?
  page
end

# File lib/mechanize.rb, line 471
def get_file(url)
  get(url).body
end

# File lib/mechanize.rb, line 483
def head(uri, query_params = {}, headers = {})
  page = @agent.fetch uri, :head, headers, query_params

  yield page if block_given?

  page
end

# File lib/mechanize.rb, line 508
def post(uri, query = {}, headers = {})
  return request_with_entity(:post, uri, query, headers) if String === query

  node = {}
  # Create a fake form
  class << node
    def search(*args); []; end
  end
  node['method'] = 'POST'
  node['enctype'] = 'application/x-www-form-urlencoded'

  form = Form.new(node)

  Mechanize::Util.each_parameter(query) { |k, v|
    if v.is_a?(IO)
      form.enctype = 'multipart/form-data'
      ul = Form::FileUpload.new({'name' => k.to_s},::File.basename(v.path))
      ul.file_data = v.read
      form.file_uploads << ul
    elsif v.is_a?(Form::FileUpload)
      form.enctype = 'multipart/form-data'
      form.file_uploads << v
    else
      form.fields << Form::Field.new({'name' => k.to_s},v)
    end
  }
  post_form(uri, form, headers)
end

# File lib/mechanize.rb, line 542
def put(uri, entity, headers = {})
  request_with_entity(:put, uri, entity, headers)
end

# File lib/mechanize.rb, line 550
def request_with_entity(verb, uri, entity, headers = {})
  cur_page = current_page || Page.new

  log.debug("query: #{ entity.inspect }") if log

  headers = {
    'Content-Type' => 'application/octet-stream',
    'Content-Length' => entity.size.to_s,
  }.update headers

  page = @agent.fetch uri, verb, headers, [entity], cur_page
  add_to_history(page)
  page
end

# File lib/mechanize.rb, line 577
def submit(form, button = nil, headers = {})
  form.add_button_to_query(button) if button

  case form.method.upcase
  when 'POST'
    post_form(form.action, form, headers)
  when 'GET'
    get(form.action.gsub(/\?[^\?]*$/, ''),
        form.build_query,
        form.page,
        headers)
  else
    raise ArgumentError, "unsupported method: #{form.method.upcase}"
  end
end

# File lib/mechanize.rb, line 597
def transact
  history_backup = @agent.history.dup
  begin
    yield self
  ensure
    @agent.history = history_backup
  end
end

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

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

# File lib/mechanize.rb, line 1095
def cert
  @agent.certificate
end

# File lib/mechanize.rb, line 1103
def cert= cert
  @agent.certificate = cert
end

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

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

# File lib/mechanize.rb, line 1154
def key
  @agent.private_key
end

# File lib/mechanize.rb, line 1162
def key= key
  @agent.private_key = key
end

# File lib/mechanize.rb, line 1169
def pass
  @agent.pass
end

# File lib/mechanize.rb, line 1176
def pass= pass
  @agent.pass = pass
end

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

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

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

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

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

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

# File lib/mechanize.rb, line 721
def add_auth uri, user, password, realm = nil, domain = nil
  @agent.add_auth uri, user, password, realm, domain
end

# File lib/mechanize.rb, line 698
  def auth user, password, domain = nil
    caller.first =~ /(.*?):(\d+).*?$/

    warn <<-WARNING
At #{$1} line #{$2}

Use of #auth and #basic_auth are deprecated due to a security vulnerability.

    WARNING

    @agent.add_default_auth user, password, domain
  end

# File lib/mechanize.rb, line 728
def conditional_requests
  @agent.conditional_requests
end

# File lib/mechanize.rb, line 735
def conditional_requests= enabled
  @agent.conditional_requests = enabled
end

# File lib/mechanize.rb, line 742
def cookie_jar
  @agent.cookie_jar
end

# File lib/mechanize.rb, line 749
def cookie_jar= cookie_jar
  @agent.cookie_jar = cookie_jar
end

# File lib/mechanize.rb, line 756
def cookies
  @agent.cookie_jar.to_a
end

# File lib/mechanize.rb, line 764
def follow_meta_refresh
  @agent.follow_meta_refresh
end

# File lib/mechanize.rb, line 772
def follow_meta_refresh= follow
  @agent.follow_meta_refresh = follow
end

# File lib/mechanize.rb, line 782
def follow_meta_refresh_self
  @agent.follow_meta_refresh_self
end

# File lib/mechanize.rb, line 790
def follow_meta_refresh_self= follow
  @agent.follow_meta_refresh_self = follow
end

# File lib/mechanize.rb, line 797
def gzip_enabled
  @agent.gzip_enabled
end

# File lib/mechanize.rb, line 804
def gzip_enabled=enabled
  @agent.gzip_enabled = enabled
end

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

# File lib/mechanize.rb, line 819
def idle_timeout= idle_timeout
  @agent.idle_timeout = idle_timeout
end

# File lib/mechanize.rb, line 833
def ignore_bad_chunking
  @agent.ignore_bad_chunking
end

# File lib/mechanize.rb, line 841
def ignore_bad_chunking= ignore_bad_chunking
  @agent.ignore_bad_chunking = ignore_bad_chunking
end

# File lib/mechanize.rb, line 848
def keep_alive
  @agent.keep_alive
end

# File lib/mechanize.rb, line 859
def keep_alive= enable
  @agent.keep_alive = enable
end

# File lib/mechanize.rb, line 866
def log
  @log || Mechanize.log
end

# File lib/mechanize.rb, line 873
def log= logger
  @log = logger
end

# File lib/mechanize.rb, line 883
def max_file_buffer
  @agent.max_file_buffer
end

# File lib/mechanize.rb, line 900
def max_file_buffer= bytes
  @agent.max_file_buffer = bytes
end

# File lib/mechanize.rb, line 907
def open_timeout
  @agent.open_timeout
end

# File lib/mechanize.rb, line 914
def open_timeout= open_timeout
  @agent.open_timeout = open_timeout
end

# File lib/mechanize.rb, line 921
def read_timeout
  @agent.read_timeout
end

# File lib/mechanize.rb, line 929
def read_timeout= read_timeout
  @agent.read_timeout = read_timeout
end

# File lib/mechanize.rb, line 941
def redirect_ok
  @agent.redirect_ok
end

# File lib/mechanize.rb, line 951
def redirect_ok= follow
  @agent.redirect_ok = follow
end

# File lib/mechanize.rb, line 960
def redirection_limit
  @agent.redirection_limit
end

# File lib/mechanize.rb, line 967
def redirection_limit= limit
  @agent.redirection_limit = limit
end

# File lib/mechanize.rb, line 980
def request_headers
  @agent.request_headers
end

# File lib/mechanize.rb, line 988
def request_headers= request_headers
  @agent.request_headers = request_headers
end

# File lib/mechanize.rb, line 973
def resolve link
  @agent.resolve link
end

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

# File lib/mechanize.rb, line 1009
def retry_change_requests= retry_change_requests
  @agent.retry_change_requests = retry_change_requests
end

# File lib/mechanize.rb, line 1016
def robots
  @agent.robots
end

# File lib/mechanize.rb, line 1024
def robots= enabled
  @agent.robots = enabled
end

# File lib/mechanize.rb, line 1031
def scheme_handlers
  @agent.scheme_handlers
end

# File lib/mechanize.rb, line 1038
def scheme_handlers= scheme_handlers
  @agent.scheme_handlers = scheme_handlers
end

# File lib/mechanize.rb, line 1045
def user_agent
  @agent.user_agent
end

# File lib/mechanize.rb, line 1053
def user_agent= user_agent
  @agent.user_agent = user_agent
end

# File lib/mechanize.rb, line 1062
def user_agent_alias= name
  self.user_agent = AGENT_ALIASES[name] ||
    raise(ArgumentError, "unknown agent alias #{name.inspect}")
end

# File lib/mechanize.rb, line 1238
def parse uri, response, body
  content_type = nil

  unless response['Content-Type'].nil?
    data, = response['Content-Type'].split ';', 2
    content_type, = data.downcase.split ',', 2 unless data.nil?
  end

  parser_klass = @pluggable_parser.parser content_type

  unless parser_klass <= Mechanize::Download then
    body = case body
           when IO, Tempfile, StringIO then
             body.read
           else
             body
           end
  end

  parser_klass.new uri, response, body, response.code do |parser|
    parser.mech = self if parser.respond_to? :mech=

    parser.watch_for_set = @watch_for_set if
      @watch_for_set and parser.respond_to?(:watch_for_set=)
  end
end

# File lib/mechanize.rb, line 1289
def reset
  @agent.reset
end

# File lib/mechanize.rb, line 1277
def set_proxy address, port, user = nil, password = nil
  @proxy_addr = address
  @proxy_port = port
  @proxy_user = user
  @proxy_pass = password

  @agent.set_proxy address, port, user, password
end

# File lib/mechanize.rb, line 1297
def shutdown
  reset
  @agent.shutdown
end