mechanize 2.0.1 → 2.1.pre.1

data/lib/mechanize/download.rb

@@ -0,0 +1,59 @@
+##
+# Download is a pluggable parser for downloading files without loading them
+# into memory first.  You may subclass this class to handle content types you
+# do not wish to load into memory first.
+#
+# See Mechanize::PluggableParser for instructions on using this class.
+
+class Mechanize::Download
+
+  include Mechanize::Parser
+
+  ##
+  # Accessor for the IO-like that contains the body
+
+  attr_reader :body_io
+
+  alias content body_io
+
+  ##
+  # Creates a new download retrieved from the given +uri+ and +response+
+  # object.  The +body_io+ is an IO-like containing the HTTP response body and
+  # +code+ is the HTTP status.
+
+  def initialize uri = nil, response = nil, body_io = nil, code = nil
+    @uri      = uri
+    @body_io  = body_io
+    @code     = code
+
+    @full_path = false unless defined? @full_path
+
+    fill_header response
+    extract_filename
+
+    yield self if block_given?
+  end
+
+  ##
+  # Saves a copy of the body_io to +filename+
+
+  def save filename = nil
+    filename = find_free_name filename
+
+    dirname = File.dirname filename
+    FileUtils.mkdir_p dirname
+
+    # Ruby 1.8.7 implements StringIO#path, can't use respond_to? :path
+    if StringIO === @body_io then
+      open filename, 'wb' do |io|
+        until @body_io.eof? do
+          io.write @body_io.read 16384
+        end
+      end
+    else
+      FileUtils.cp @body_io.path, filename
+    end
+  end
+
+end
+

data/lib/mechanize/element_matcher.rb

@@ -8,6 +8,7 @@ module Mechanize::ElementMatcher
                    else
                      criteria.map do |k, v|
                        k = :dom_id if k.to_sym == :id
+                       k = :dom_class if k.to_sym == :class
                        [k, v]
                      end
                    end

data/lib/mechanize/file.rb

@@ -1,80 +1,65 @@
-class Mechanize
-  # = Synopsis
-  # This is the default (and base) class for the Pluggable Parsers.  If
-  # Mechanize cannot find an appropriate class to use for the content type,
-  # this class will be used.  For example, if you download a JPG, Mechanize
-  # will not know how to parse it, so this class will be instantiated.
-  #
-  # This is a good class to use as the base class for building your own
-  # pluggable parsers.
-  #
-  # == Example
-  #  require 'rubygems'
-  #  require 'mechanize'
-  #
-  #  agent = Mechanize.new
-  #  agent.get('http://example.com/foo.jpg').class  #=> Mechanize::File
-  #
-  class File
-    extend Forwardable
-
-    attr_accessor :uri, :response, :body, :code, :filename
-    alias :header :response
-    def_delegator :header, :[], :[]
-    def_delegator :header, :[]=, :[]=
-    def_delegator :header, :key?, :key?
-    def_delegator :header, :each, :each
-    def_delegator :header, :canonical_each, :canonical_each
-
-    alias :content :body
-
-    def initialize(uri=nil, response=nil, body=nil, code=nil)
-      @uri = uri
-      @body = body
-      @code = code
-      @response = Headers.new
-
-      # Copy the headers in to a hash to prevent memory leaks
-      if response
-        response.each { |k,v|
-          @response[k] = v
-        }
-      end
-
-      @filename = 'index.html'
-
-      # Set the filename
-      if disposition = @response['content-disposition']
-        disposition.split(/;\s*/).each do |pair|
-          k,v = pair.split(/=/, 2)
-          @filename = v if k && k.downcase == 'filename'
-        end
-      else
-        if @uri
-          @filename = @uri.path.split(/\//).last || 'index.html'
-          @filename << ".html" unless @filename =~ /\./
-        end
-      end
-
-      yield self if block_given?
-    end
+##
+# This is the base class for the Pluggable Parsers.  If Mechanize cannot find
+# an appropriate class to use for the content type, this class will be used.
+# For example, if you download an image/jpeg, Mechanize will not know how to
+# parse it, so this class will be instantiated.
+#
+# This is a good class to use as the base class for building your own
+# pluggable parsers.
+#
+# == Example
+#
+#   require 'mechanize'
+#
+#   agent = Mechanize.new
+#   agent.get('http://example.com/foo.jpg').class  #=> Mechanize::File
 
-    # Use this method to save the content of this object to filename
-    def save_as(filename = nil)
-      if filename.nil?
-        filename = @filename
-        number = 1
-        while(::File.exists?(filename))
-          filename = "#{@filename}.#{number}"
-          number += 1
-        end
-      end
-
-      ::File::open(filename, "wb") { |f|
-        f.write body
-      }
-    end
+class Mechanize::File
+
+  include Mechanize::Parser
+
+  ##
+  # The HTTP response body, the raw file contents
+
+  attr_accessor :body
+
+  ##
+  # The filename for this file based on the content-disposition of the
+  # response or the basename of the URL
+
+  attr_accessor :filename
+
+  alias content body
+
+  ##
+  # Creates a new file retrieved from the given +uri+ and +response+ object.
+  # The +body+ is the HTTP response body and +code+ is the HTTP status.
+
+  def initialize uri = nil, response = nil, body = nil, code = nil
+    @uri  = uri
+    @body = body
+    @code = code
 
-    alias :save :save_as
+    @full_path = false unless defined? @full_path
+
+    fill_header response
+    extract_filename
+
+    yield self if block_given?
+  end
+
+  ##
+  # Use this method to save the content of this object to +filename+
+
+  def save filename = nil
+    filename = find_free_name filename
+
+    open filename, 'wb' do |f|
+      f.write body
+    end
   end
+
+  alias save_as save
+
 end
+

data/lib/mechanize/file_saver.rb

@@ -1,37 +1,39 @@
-class Mechanize
-  # = Synopsis
-  # This is a pluggable parser that automatically saves every file
-  # it encounters.  It saves the files as a tree, reflecting the
-  # host and file path.
-  #
-  # == Example to save all PDF's
-  #  require 'rubygems'
-  #  require 'mechanize'
-  #
-  #  agent = Mechanize.new
-  #  agent.pluggable_parser.pdf = Mechanize::FileSaver
-  #  agent.get('http://example.com/foo.pdf')
-  #
-  class FileSaver < File
-    attr_reader :filename
-
-    def initialize(uri=nil, response=nil, body=nil, code=nil)
-      super(uri, response, body, code)
-      path = uri.path.empty? ? 'index.html' : uri.path.gsub(/^[\/]*/, '')
-      path += 'index.html' if path =~ /\/$/
-
-      split_path = path.split(/\//)
-      filename = split_path.length > 0 ? split_path.pop : 'index.html'
-      joined_path = split_path.join(::File::SEPARATOR)
-      path = if joined_path.empty?
-               uri.host
-             else
-               "#{uri.host}#{::File::SEPARATOR}#{joined_path}"
-             end
-
-      @filename = "#{path}#{::File::SEPARATOR}#{filename}"
-      FileUtils.mkdir_p(path)
-      save_as(@filename)
-    end
+##
+# This is a pluggable parser that automatically saves every file it
+# encounters.  It saves the files as a tree, reflecting the host and file
+# path.
+#
+# == Example
+#
+# This example saves all .pdf files
+#
+#   require 'mechanize'
+#
+#   agent = Mechanize.new
+#   agent.pluggable_parser.pdf = Mechanize::FileSaver
+#   agent.get('http://example.com/foo.pdf')
+#
+#   Dir['example.com/*'] # => foo.pdf
+
+class Mechanize::FileSaver < Mechanize::Download
+
+  attr_reader :filename
+
+  def initialize uri = nil, response = nil, body_io = nil, code = nil
+    @full_path = true
+
+    super
+
+    save @filename
   end
+
+  ##
+  # The save_as alias is provided for backwards compatibility with mechanize
+  # 2.0.  It will be removed in mechanize 3.
+  #--
+  # TODO remove in mechanize 3
+
+  alias save_as save
+
 end
+

data/lib/mechanize/form.rb

@@ -1,478 +1,543 @@
 require 'mechanize/element_matcher'
-require 'mechanize/form/field'
-require 'mechanize/form/button'
-require 'mechanize/form/file_upload'
-require 'mechanize/form/image_button'
-require 'mechanize/form/multi_select_list'
-require 'mechanize/form/option'
-require 'mechanize/form/radio_button'
-require 'mechanize/form/check_box'
-require 'mechanize/form/select_list'
 
-class Mechanize
-  # =Synopsis
-  # This class encapsulates a form parsed out of an HTML page.  Each type
-  # of input fields available in a form can be accessed through this object.
-  # See GlobalForm for more methods.
-  #
-  # ==Example
-  # Find a form and print out its fields
-  #  form = page.forms.first # => Mechanize::Form
-  #  form.fields.each { |f| puts f.name }
-  # Set the input field 'name' to "Aaron"
-  #  form['name'] = 'Aaron'
-  #  puts form['name']
-  class Form
-
-    extend Mechanize::ElementMatcher
+# This class encapsulates a form parsed out of an HTML page.  Each type of
+# input fields available in a form can be accessed through this object.
+#
+# == Examples
+#
+# Find a form and print out its fields
+#
+#   form = page.forms.first # => Mechanize::Form
+#   form.fields.each { |f| puts f.name }
+#
+# Set the input field 'name' to "Aaron"
+#
+#   form['name'] = 'Aaron'
+#   puts form['name']
+
+class Mechanize::Form
+
+  extend Mechanize::ElementMatcher
+
+  attr_accessor :method, :action, :name
+
+  attr_reader :fields, :buttons, :file_uploads, :radiobuttons, :checkboxes
+
+  # Content-Type for form data (i.e. application/x-www-form-urlencoded)
+  attr_accessor :enctype
+
+  # Character encoding of form data (i.e. UTF-8)
+  attr_accessor :encoding
+
+  # When true, character encoding errors will never be never raised on form
+  # submission.  Default is false
+  attr_accessor :ignore_encoding_error
+
+  alias :elements :fields
+
+  attr_reader :form_node
+  attr_reader :page
+
+  def initialize(node, mech=nil, page=nil)
+    @enctype = node['enctype'] || 'application/x-www-form-urlencoded'
+    @form_node        = node
+    @action           = Mechanize::Util.html_unescape(node['action'])
+    @method           = (node['method'] || 'GET').upcase
+    @name             = node['name']
+    @clicked_buttons  = []
+    @page             = page
+    @mech             = mech
+
+    @encoding = node['accept-charset'] || (page && page.encoding) || nil
+    @ignore_encoding_error = false
+    parse
+  end
 
-    attr_accessor :method, :action, :name
+  # Returns whether or not the form contains a field with +field_name+
+  def has_field?(field_name)
+    fields.find { |f| f.name == field_name }
+  end
 
-    attr_reader :fields, :buttons, :file_uploads, :radiobuttons, :checkboxes
+  alias :has_key? :has_field?
 
-    # Content-Type for form data (i.e. application/x-www-form-urlencoded)
-    attr_accessor :enctype
+  def has_value?(value)
+    fields.find { |f| f.value == value }
+  end
 
-    # Character encoding of form data (i.e. UTF-8)
-    attr_accessor :encoding
+  def keys; fields.map { |f| f.name }; end
+
+  def values; fields.map { |f| f.value }; end
+
+  def submits  ; @submits   ||= buttons.select { |f| f.class == Submit   }; end
+  def resets   ; @resets    ||= buttons.select { |f| f.class == Reset    }; end
+  def texts    ; @texts     ||=  fields.select { |f| f.class == Text     }; end
+  def hiddens  ; @hiddens   ||=  fields.select { |f| f.class == Hidden   }; end
+  def textareas; @textareas ||=  fields.select { |f| f.class == Textarea }; end
+  def keygens  ; @keygens   ||=  fields.select { |f| f.class == Keygen   }; end
+
+  def submit_button?(button_name)   submits.find{|f| f.name == button_name}; end
+  def reset_button?(button_name)     resets.find{|f| f.name == button_name}; end
+  def text_field?(field_name)         texts.find{|f| f.name == field_name}; end
+  def hidden_field?(field_name)     hiddens.find{|f| f.name == field_name}; end
+  def textarea_field?(field_name) textareas.find{|f| f.name == field_name}; end
+
+  # This method is a shortcut to get form's DOM id.
+  # Common usage:
+  #   page.form_with(:dom_id => "foorm")
+  # Note that you can also use +:id+ to get to this method:
+  #   page.form_with(:id => "foorm")
+  def dom_id
+    form_node['id']
+  end
 
-    # When true, character encoding errors will never be never raised on form
-    # submission.  Default is false
-    attr_accessor :ignore_encoding_error
+  # This method is a shortcut to get form's DOM class.
+  # Common usage:
+  #   page.form_with(:dom_class => "foorm")
+  # Note that you can also use +:class+ to get to this method:
+  #   page.form_with(:class => "foorm")
+  def dom_class
+    form_node['class']
+  end
 
-    alias :elements :fields
+  # Add a field with +field_name+ and +value+
+  def add_field!(field_name, value = nil)
+    fields << Field.new({'name' => field_name}, value)
+  end
 
-    attr_reader :form_node
-    attr_reader :page
+  ##
+  # This method sets multiple fields on the form.  It takes a list of +fields+
+  # which are name, value pairs.
+  #
+  # If there is more than one field found with the same name, this method will
+  # set the first one found.  If you want to set the value of a duplicate
+  # field, use a value which is a Hash with the key as the index in to the
+  # form.  The index is zero based.
+  #
+  # For example, to set the second field named 'foo', you could do the
+  # following:
+  #
+  #   form.set_fields :foo => { 1 => 'bar' }
+
+  def set_fields fields = {}
+    fields.each do |name, v|
+      case v
+      when Hash
+        v.each do |index, value|
+          self.fields_with(:name => name.to_s)[index].value = value
+        end
+      else
+        value = nil
+        index = 0
 
-    def initialize(node, mech=nil, page=nil)
-      @enctype = node['enctype'] || 'application/x-www-form-urlencoded'
-      @form_node        = node
-      @action           = Util.html_unescape(node['action'])
-      @method           = (node['method'] || 'GET').upcase
-      @name             = node['name']
-      @clicked_buttons  = []
-      @page             = page
-      @mech             = mech
+        [v].flatten.each do |val|
+          index = val.to_i if value
+          value = val unless value
+        end
 
-      @encoding = node['accept-charset'] || (page && page.encoding) || nil
-      @ignore_encoding_error = false
-      parse
+        self.fields_with(:name => name.to_s)[index].value = value
+      end
     end
+  end
 
-    # Returns whether or not the form contains a field with +field_name+
-    def has_field?(field_name)
-      fields.find { |f| f.name == field_name }
+  # Fetch the value of the first input field with the name passed in
+  # ==Example
+  # Fetch the value set in the input field 'name'
+  #  puts form['name']
+  def [](field_name)
+    f = field(field_name)
+    f && f.value
+  end
+
+  # Set the value of the first input field with the name passed in
+  # ==Example
+  # Set the value in the input field 'name' to "Aaron"
+  #  form['name'] = 'Aaron'
+  def []=(field_name, value)
+    f = field(field_name)
+    if f
+      f.value = value
+    else
+      add_field!(field_name, value)
     end
+  end
 
-    alias :has_key? :has_field?
+  # Treat form fields like accessors.
+  def method_missing(meth, *args)
+    method = meth.to_s.gsub(/=$/, '')
 
-    def has_value?(value)
-      fields.find { |f| f.value == value }
+    if field(method)
+      return field(method).value if args.empty?
+      return field(method).value = args[0]
     end
 
-    def keys; fields.map { |f| f.name }; end
-
-    def values; fields.map { |f| f.value }; end
-
-    def submits  ; @submits   ||= buttons.select { |f| f.class == Submit   }; end
-    def resets   ; @resets    ||= buttons.select { |f| f.class == Reset    }; end
-    def texts    ; @texts     ||=  fields.select { |f| f.class == Text     }; end
-    def hiddens  ; @hiddens   ||=  fields.select { |f| f.class == Hidden   }; end
-    def textareas; @textareas ||=  fields.select { |f| f.class == Textarea }; end
-
-    def submit_button?(button_name)   submits.find{|f| f.name == button_name}; end
-    def reset_button?(button_name)     resets.find{|f| f.name == button_name}; end
-    def text_field?(field_name)         texts.find{|f| f.name == field_name}; end
-    def hidden_field?(field_name)     hiddens.find{|f| f.name == field_name}; end
-    def textarea_field?(field_name) textareas.find{|f| f.name == field_name}; end
-
-    # This method is a shortcut to get form's DOM id.
-    # Common usage:
-    #   page.form_with(:dom_id => "foorm")
-    # Note that you can also use +:id+ to get to this method:
-    #   page.form_with(:id => "foorm")
-    def dom_id
-      form_node['id']
-    end
+    super
+  end
 
-    # Add a field with +field_name+ and +value+
-    def add_field!(field_name, value = nil)
-      fields << Field.new({'name' => field_name}, value)
-    end
+  # Submit this form with the button passed in
+  def submit button=nil, headers = {}
+    @mech.submit(self, button, headers)
+  end
+
+  # Submit form using +button+. Defaults
+  # to the first button.
+  def click_button(button = buttons.first)
+    submit(button)
+  end
 
-    # This method sets multiple fields on the form.  It takes a list of field
-    # name, value pairs.  If there is more than one field found with the
-    # same name, this method will set the first one found.  If you want to
-    # set the value of a duplicate field, use a value which is a Hash with
-    # the key as the index in to the form.  The index
-    # is zero based.  For example, to set the second field named 'foo', you
-    # could do the following:
-    #  form.set_fields( :foo => { 1 => 'bar' } )
-    def set_fields(fields = {})
-      fields.each do |k,v|
-        case v
-        when Hash
-          v.each do |index, value|
-            self.fields_with(:name => k.to_s).[](index).value = value
-          end
-        else
-          value = nil
-          index = 0
-          [v].flatten.each do |val|
-            index = val.to_i if value
-            value = val unless value
-          end
-          self.fields_with(:name => k.to_s).[](index).value = value
+  # This method is sub-method of build_query.
+  # It converts charset of query value of fields into expected one.
+  def proc_query(field)
+    return unless field.query_value
+    field.query_value.map{|(name, val)|
+      [from_native_charset(name), from_native_charset(val.to_s)]
+    }
+  end
+  private :proc_query
+
+  def from_native_charset str
+    Mechanize::Util.from_native_charset(str, encoding, @ignore_encoding_error,
+                                        @mech && @mech.log)
+  end
+  private :from_native_charset
+
+  # This method builds an array of arrays that represent the query
+  # parameters to be used with this form.  The return value can then
+  # be used to create a query string for this form.
+  def build_query(buttons = [])
+    query = []
+    @mech.log.info("form encoding: #{encoding}") if @mech && @mech.log
+
+    successful_controls = []
+
+    (fields + checkboxes).sort.each do |f|
+      case f
+      when Mechanize::Form::CheckBox
+        if f.checked
+          successful_controls << f
         end
+      when Mechanize::Form::Field
+        successful_controls << f
       end
     end
 
-    # Fetch the value of the first input field with the name passed in
-    # ==Example
-    # Fetch the value set in the input field 'name'
-    #  puts form['name']
-    def [](field_name)
-      f = field(field_name)
-      f && f.value
+    radio_groups = {}
+    radiobuttons.each do |f|
+      fname = from_native_charset(f.name)
+      radio_groups[fname] ||= []
+      radio_groups[fname] << f
     end
 
-    # Set the value of the first input field with the name passed in
-    # ==Example
-    # Set the value in the input field 'name' to "Aaron"
-    #  form['name'] = 'Aaron'
-    def []=(field_name, value)
-      f = field(field_name)
-      if f
-        f.value = value
-      else
-        add_field!(field_name, value)
+    # take one radio button from each group
+    radio_groups.each_value do |g|
+      checked = g.select {|f| f.checked}
+
+      if checked.size == 1
+        f = checked.first
+        successful_controls << f
+      elsif checked.size > 1
+        raise Mechanize::Error,
+              "multiple radiobuttons are checked in the same group!"
       end
     end
 
-    # Treat form fields like accessors.
-    def method_missing(meth, *args)
-      method = meth.to_s.gsub(/=$/, '')
-
-      if field(method)
-        return field(method).value if args.empty?
-        return field(method).value = args[0]
-      end
+    @clicked_buttons.each { |b|
+      successful_controls << b
+    }
 
-      super
+    successful_controls.sort.each do |ctrl| # DOM order
+      qval = proc_query(ctrl)
+      query.push(*qval)
     end
 
-    # Submit this form with the button passed in
-    def submit button=nil, headers = {}
-      @mech.submit(self, button, headers)
-    end
+    query
+  end
 
-    # Submit form using +button+. Defaults
-    # to the first button.
-    def click_button(button = buttons.first)
-      submit(button)
-    end
+  # This method adds a button to the query.  If the form needs to be
+  # submitted with multiple buttons, pass each button to this method.
+  def add_button_to_query(button)
+    @clicked_buttons << button
+  end
 
-    # This method is sub-method of build_query.
-    # It converts charset of query value of fields into expected one.
-    def proc_query(field)
-      return unless field.query_value
-      field.query_value.map{|(name, val)|
-        [from_native_charset(name), from_native_charset(val.to_s)]
-      }
+  # This method calculates the request data to be sent back to the server
+  # for this form, depending on if this is a regular post, get, or a
+  # multi-part post,
+  def request_data
+    query_params = build_query()
+
+    case @enctype.downcase
+    when /^multipart\/form-data/
+      boundary = rand_string(20)
+      @enctype = "multipart/form-data; boundary=#{boundary}"
+
+      params = query_params.map do |k,v|
+        param_to_multipart(k, v) if k
+      end.compact
+
+      params.concat @file_uploads.map { |f| file_to_multipart(f) }
+
+      params.map do |part|
+        part.force_encoding('ASCII-8BIT') if part.respond_to? :force_encoding
+        "--#{boundary}\r\n#{part}"
+      end.join('') +
+        "--#{boundary}--\r\n"
+    else
+      Mechanize::Util.build_query_string(query_params)
     end
-    private :proc_query
+  end
 
-    def from_native_charset str
-      Util.from_native_charset(str, encoding, @ignore_encoding_error, @mech && @mech.log)
-    end
-    private :from_native_charset
-
-    # This method builds an array of arrays that represent the query
-    # parameters to be used with this form.  The return value can then
-    # be used to create a query string for this form.
-    def build_query(buttons = [])
-      query = []
-      @mech.log.info("form encoding: #{encoding}") if @mech && @mech.log
-
-      (fields + checkboxes).sort.each do |f|
-        case f
-        when Form::CheckBox
-          if f.checked
-            qval = proc_query(f)
-            query.push(*qval)
-          end
-        when Form::Field
-          qval = proc_query(f)
-          query.push(*qval)
-        end
-      end
+  # Removes all fields with name +field_name+.
+  def delete_field!(field_name)
+    @fields.delete_if{ |f| f.name == field_name}
+  end
 
-      radio_groups = {}
-      radiobuttons.each do |f|
-        fname = from_native_charset(f.name)
-        radio_groups[fname] ||= []
-        radio_groups[fname] << f
-      end
+  ##
+  # :method: field_with(criteria)
+  #
+  # Find one field that matches +criteria+
+  # Example:
+  #   form.field_with(:id => "exact_field_id").value = 'hello'
 
-      # take one radio button from each group
-      radio_groups.each_value do |g|
-        checked = g.select {|f| f.checked}
-
-        if checked.size == 1
-          f = checked.first
-          qval = proc_query(f)
-          query.push(*qval)
-        elsif checked.size > 1
-          raise Mechanize::Error,
-                "multiple radiobuttons are checked in the same group!"
-        end
-      end
+  ##
+  # :method: fields_with(criteria)
+  #
+  # Find all fields that match +criteria+
+  # Example:
+  #   form.fields_with(:value => /foo/).each do |field|
+  #     field.value = 'hello!'
+  #   end
 
-      @clicked_buttons.each { |b|
-        qval = proc_query(b)
-        query.push(*qval)
-      }
-      query
-    end
+  elements_with :field
 
-    # This method adds a button to the query.  If the form needs to be
-    # submitted with multiple buttons, pass each button to this method.
-    def add_button_to_query(button)
-      @clicked_buttons << button
-    end
+  ##
+  # :method: button_with(criteria)
+  #
+  # Find one button that matches +criteria+
+  # Example:
+  #   form.button_with(:value => /submit/).value = 'hello'
 
-    # This method calculates the request data to be sent back to the server
-    # for this form, depending on if this is a regular post, get, or a
-    # multi-part post,
-    def request_data
-      query_params = build_query()
+  ##
+  # :method: buttons_with(criteria)
+  #
+  # Find all buttons that match +criteria+
+  # Example:
+  #   form.buttons_with(:value => /submit/).each do |button|
+  #     button.value = 'hello!'
+  #   end
 
-      case @enctype.downcase
-      when /^multipart\/form-data/
-        boundary = rand_string(20)
-        @enctype = "multipart/form-data; boundary=#{boundary}"
+  elements_with :button
 
-        params = query_params.map do |k,v|
-          param_to_multipart(k, v) if k
-        end.compact
+  ##
+  # :method: file_upload_with(criteria)
+  #
+  # Find one file upload field that matches +criteria+
+  # Example:
+  #   form.file_upload_with(:file_name => /picture/).value = 'foo'
 
-        params.concat @file_uploads.map { |f| file_to_multipart(f) }
+  ##
+  # :method: file_uploads_with(criteria)
+  #
+  # Find all file upload fields that match +criteria+
+  # Example:
+  #   form.file_uploads_with(:file_name => /picutre/).each do |field|
+  #     field.value = 'foo!'
+  #   end
 
-        params.map do |part|
-          part.force_encoding('ASCII-8BIT') if part.respond_to? :force_encoding
-          "--#{boundary}\r\n#{part}"
-        end.join('') +
-          "--#{boundary}--\r\n"
-      else
-        Mechanize::Util.build_query_string(query_params)
-      end
-    end
+  elements_with :file_upload
 
-    # Removes all fields with name +field_name+.
-    def delete_field!(field_name)
-      @fields.delete_if{ |f| f.name == field_name}
-    end
+  ##
+  # :method: radiobutton_with(criteria)
+  #
+  # Find one radio button that matches +criteria+
+  # Example:
+  #   form.radiobutton_with(:name => /woo/).check
 
-    ##
-    # :method: field_with(criteria)
-    #
-    # Find one field that matches +criteria+
-    # Example:
-    #   form.field_with(:id => "exact_field_id").value = 'hello'
-
-    ##
-    # :method: fields_with(criteria)
-    #
-    # Find all fields that match +criteria+
-    # Example:
-    #   form.fields_with(:value => /foo/).each do |field|
-    #     field.value = 'hello!'
-    #   end
-
-    elements_with :field
-
-    ##
-    # :method: button_with(criteria)
-    #
-    # Find one button that matches +criteria+
-    # Example:
-    #   form.button_with(:value => /submit/).value = 'hello'
-
-    ##
-    # :method: buttons_with(criteria)
-    #
-    # Find all buttons that match +criteria+
-    # Example:
-    #   form.buttons_with(:value => /submit/).each do |button|
-    #     button.value = 'hello!'
-    #   end
-
-    elements_with :button
-
-    ##
-    # :method: file_upload_with(criteria)
-    #
-    # Find one file upload field that matches +criteria+
-    # Example:
-    #   form.file_upload_with(:file_name => /picture/).value = 'foo'
-
-    ##
-    # :method: file_uploads_with(criteria)
-    #
-    # Find all file upload fields that match +criteria+
-    # Example:
-    #   form.file_uploads_with(:file_name => /picutre/).each do |field|
-    #     field.value = 'foo!'
-    #   end
-
-    elements_with :file_upload
-
-    ##
-    # :method: radiobutton_with(criteria)
-    #
-    # Find one radio button that matches +criteria+
-    # Example:
-    #   form.radiobutton_with(:name => /woo/).check
-
-    ##
-    # :method: radiobuttons_with(criteria)
-    #
-    # Find all radio buttons that match +criteria+
-    # Example:
-    #   form.radiobuttons_with(:name => /woo/).each do |field|
-    #     field.check
-    #   end
-
-    elements_with :radiobutton
-
-    ##
-    # :method: checkbox_with(criteria)
-    #
-    # Find one checkbox that matches +criteria+
-    # Example:
-    #   form.checkbox_with(:name => /woo/).check
-
-    ##
-    # :method: checkboxes_with(criteria)
-    #
-    # Find all checkboxes that match +criteria+
-    # Example:
-    #   form.checkboxes_with(:name => /woo/).each do |field|
-    #     field.check
-    #   end
-
-    elements_with :checkbox,   :checkboxes
-
-    private
-
-    def parse
-      @fields       = []
-      @buttons      = []
-      @file_uploads = []
-      @radiobuttons = []
-      @checkboxes   = []
-
-      # Find all input tags
-      form_node.search('input').each do |node|
-        type = (node['type'] || 'text').downcase
-        name = node['name']
-        next if name.nil? && !%w[submit button image].include?(type)
-        case type
-        when 'radio'
-          @radiobuttons << RadioButton.new(node, self)
-        when 'checkbox'
-          @checkboxes << CheckBox.new(node, self)
-        when 'file'
-          @file_uploads << FileUpload.new(node, nil)
-        when 'submit'
-          @buttons << Submit.new(node)
-        when 'button'
-          @buttons << Button.new(node)
-        when 'reset'
-          @buttons << Reset.new(node)
-        when 'image'
-          @buttons << ImageButton.new(node)
-        when 'hidden'
-          @fields << Hidden.new(node, node['value'] || '')
-        when 'text'
-          @fields << Text.new(node, node['value'] || '')
-        when 'textarea'
-          @fields << Textarea.new(node, node['value'] || '')
-        else
-          @fields << Field.new(node, node['value'] || '')
-        end
-      end
+  ##
+  # :method: radiobuttons_with(criteria)
+  #
+  # Find all radio buttons that match +criteria+
+  # Example:
+  #   form.radiobuttons_with(:name => /woo/).each do |field|
+  #     field.check
+  #   end
 
-      # Find all textarea tags
-      form_node.search('textarea').each do |node|
-        next unless node['name']
-        @fields << Textarea.new(node, node.inner_text)
-      end
+  elements_with :radiobutton
+
+  ##
+  # :method: checkbox_with(criteria)
+  #
+  # Find one checkbox that matches +criteria+
+  # Example:
+  #   form.checkbox_with(:name => /woo/).check
 
-      # Find all select tags
-      form_node.search('select').each do |node|
-        next unless node['name']
-        if node.has_attribute? 'multiple'
-          @fields << MultiSelectList.new(node)
-        else
-          @fields << SelectList.new(node)
+  ##
+  # :method: checkboxes_with(criteria)
+  #
+  # Find all checkboxes that match +criteria+
+  # Example:
+  #   form.checkboxes_with(:name => /woo/).each do |field|
+  #     field.check
+  #   end
+
+  elements_with :checkbox,   :checkboxes
+
+  def pretty_print(q) # :nodoc:
+    q.object_group(self) {
+      q.breakable; q.group(1, '{name', '}') { q.breakable; q.pp name }
+      q.breakable; q.group(1, '{method', '}') { q.breakable; q.pp method }
+      q.breakable; q.group(1, '{action', '}') { q.breakable; q.pp action }
+      q.breakable; q.group(1, '{fields', '}') {
+        fields.each do |field|
+          q.breakable
+          q.pp field
         end
-      end
+      }
+      q.breakable; q.group(1, '{radiobuttons', '}') {
+        radiobuttons.each { |b| q.breakable; q.pp b }
+      }
+      q.breakable; q.group(1, '{checkboxes', '}') {
+        checkboxes.each { |b| q.breakable; q.pp b }
+      }
+      q.breakable; q.group(1, '{file_uploads', '}') {
+        file_uploads.each { |b| q.breakable; q.pp b }
+      }
+      q.breakable; q.group(1, '{buttons', '}') {
+        buttons.each { |b| q.breakable; q.pp b }
+      }
+    }
+  end
 
-      # Find all submit button tags
-      # FIXME: what can I do with the reset buttons?
-      form_node.search('button').each do |node|
-        type = (node['type'] || 'submit').downcase
-        next if type == 'reset'
+  alias inspect pretty_inspect # :nodoc:
+
+  private
+
+  def parse
+    @fields       = []
+    @buttons      = []
+    @file_uploads = []
+    @radiobuttons = []
+    @checkboxes   = []
+
+    # Find all input tags
+    form_node.search('input').each do |node|
+      type = (node['type'] || 'text').downcase
+      name = node['name']
+      next if name.nil? && !%w[submit button image].include?(type)
+      case type
+      when 'radio'
+        @radiobuttons << RadioButton.new(node, self)
+      when 'checkbox'
+        @checkboxes << CheckBox.new(node, self)
+      when 'file'
+        @file_uploads << FileUpload.new(node, nil)
+      when 'submit'
+        @buttons << Submit.new(node)
+      when 'button'
         @buttons << Button.new(node)
+      when 'reset'
+        @buttons << Reset.new(node)
+      when 'image'
+        @buttons << ImageButton.new(node)
+      when 'hidden'
+        @fields << Hidden.new(node, node['value'] || '')
+      when 'text'
+        @fields << Text.new(node, node['value'] || '')
+      when 'textarea'
+        @fields << Textarea.new(node, node['value'] || '')
+      else
+        @fields << Field.new(node, node['value'] || '')
       end
     end
 
-    def rand_string(len = 10)
-      chars = ("a".."z").to_a + ("A".."Z").to_a
-      string = ""
-      1.upto(len) { |i| string << chars[rand(chars.size-1)] }
-      string
+    # Find all textarea tags
+    form_node.search('textarea').each do |node|
+      next unless node['name']
+      @fields << Textarea.new(node, node.inner_text)
     end
 
-    def mime_value_quote(str)
-      str.gsub(/(["\r\\])/){|s| '\\' + s}
+    # Find all select tags
+    form_node.search('select').each do |node|
+      next unless node['name']
+      if node.has_attribute? 'multiple'
+        @fields << MultiSelectList.new(node)
+      else
+        @fields << SelectList.new(node)
+      end
     end
 
-    def param_to_multipart(name, value)
-      return "Content-Disposition: form-data; name=\"" +
-        "#{mime_value_quote(name)}\"\r\n" +
-        "\r\n#{value}\r\n"
+    # Find all submit button tags
+    # FIXME: what can I do with the reset buttons?
+    form_node.search('button').each do |node|
+      type = (node['type'] || 'submit').downcase
+      next if type == 'reset'
+      @buttons << Button.new(node)
     end
+    
+    # Find all keygen tags
+    form_node.search('keygen').each do |node|
+      @fields << Keygen.new(node, node['value'] || '')
+    end
+  end
 
-    def file_to_multipart(file)
-      file_name = file.file_name ? ::File.basename(file.file_name) : ''
-      body =  "Content-Disposition: form-data; name=\"" +
-        "#{mime_value_quote(file.name)}\"; " +
-        "filename=\"#{mime_value_quote(file_name)}\"\r\n" +
-        "Content-Transfer-Encoding: binary\r\n"
-
-      if file.file_data.nil? and file.file_name
-        file.file_data = open(file.file_name, "rb") { |f| f.read }
-        file.mime_type =
-          WEBrick::HTTPUtils.mime_type(file.file_name,
-                                       WEBrick::HTTPUtils::DefaultMimeTypes)
-      end
+  def rand_string(len = 10)
+    chars = ("a".."z").to_a + ("A".."Z").to_a
+    string = ""
+    1.upto(len) { |i| string << chars[rand(chars.size-1)] }
+    string
+  end
 
-      if file.mime_type
-        body << "Content-Type: #{file.mime_type}\r\n"
-      end
+  def mime_value_quote(str)
+    str.gsub(/(["\r\\])/){|s| '\\' + s}
+  end
 
-      body <<
-        if file.file_data.respond_to? :read
-          "\r\n#{file.file_data.read}\r\n"
-        else
-          "\r\n#{file.file_data}\r\n"
-        end
+  def param_to_multipart(name, value)
+    return "Content-Disposition: form-data; name=\"" +
+      "#{mime_value_quote(name)}\"\r\n" +
+      "\r\n#{value}\r\n"
+  end
 
-      body
+  def file_to_multipart(file)
+    file_name = file.file_name ? ::File.basename(file.file_name) : ''
+    body =  "Content-Disposition: form-data; name=\"" +
+      "#{mime_value_quote(file.name)}\"; " +
+      "filename=\"#{mime_value_quote(file_name)}\"\r\n" +
+      "Content-Transfer-Encoding: binary\r\n"
+
+    if file.file_data.nil? and file.file_name
+      file.file_data = open(file.file_name, "rb") { |f| f.read }
+      file.mime_type =
+        WEBrick::HTTPUtils.mime_type(file.file_name,
+                                     WEBrick::HTTPUtils::DefaultMimeTypes)
     end
 
+    if file.mime_type
+      body << "Content-Type: #{file.mime_type}\r\n"
+    end
+
+    body <<
+      if file.file_data.respond_to? :read
+        "\r\n#{file.file_data.read}\r\n"
+      else
+        "\r\n#{file.file_data}\r\n"
+      end
+
+    body
   end
+
 end
+
+require 'mechanize/form/field'
+require 'mechanize/form/button'
+require 'mechanize/form/hidden'
+require 'mechanize/form/text'
+require 'mechanize/form/textarea'
+require 'mechanize/form/submit'
+require 'mechanize/form/reset'
+require 'mechanize/form/file_upload'
+require 'mechanize/form/keygen'
+require 'mechanize/form/image_button'
+require 'mechanize/form/multi_select_list'
+require 'mechanize/form/option'
+require 'mechanize/form/radio_button'
+require 'mechanize/form/check_box'
+require 'mechanize/form/select_list'
+