mechanize 0.4.4 → 0.4.5

data/CHANGELOG

@@ -1,3 +1,13 @@
+== 0.4.5
+
+* Added support for multiple values of the same name
+* Updated build_query_string to take an array of arrays (Thanks Michal Janeczek)
+* Added WWW::Mechanize#body_filter= so that response bodies can be preprocessed
+* Added WWW::Page#body_filter= so that response bodies can be preprocessed
+* Added support for more date formats in the cookie parser
+* Fixed a bug with empty select lists
+* Fixing a problem with cookies not handling no spaces after semicolons
+
 == 0.4.4
 
 * Fixed error in method signature, basic_authetication is now basic_auth

data/EXAMPLES

@@ -53,3 +53,46 @@ This example uploads one image as two different images to flickr.
   
   agent.submit(form)
   
+== Page Body Filter
+This example shows how to preprocess a body before mechanize parses it.  The
+body filter sends the page body to the code block, and parses what the code
+block returns.  The filter on WWW::Page#body_filter is a "per-page" filter,
+meaning that it is only applied to one page object.
+
+  require 'rubygems'
+  require 'mechanize'
+  
+  agent = WWW::Mechanize.new
+  
+  page = agent.get('http://google.com/')
+  page.body_filter = lambda { |body|
+      body.gsub(/google/i, "Net::DAAP::Client")
+  }
+  puts page.body
+  
+  page = agent.get('http://google.com/')
+  puts page.body
+
+== Global Body Filter
+The body filter can be set on the WWW::Mechanize object for use as a global
+filter.  The filter set will be applied to every page that is requested.  The
+following example shows the global filter being used, then being set back to
+the original filter.
+
+  require 'rubygems'
+  require 'mechanize'
+  
+  agent = WWW::Mechanize.new
+  
+  old_filter = agent.body_filter
+  agent.body_filter = lambda { |body|
+    body.gsub(/(<a[^>]*>)[^<]*(<\/a[^>]*>)/i, "#{$1}Net::DAAP::Client#{$2}")
+  }
+  
+  page = agent.get('http://google.com/')
+  page.links.each { |l| puts l.text }
+  
+  agent.body_filter = old_filter
+  page = agent.get('http://google.com/')
+  page.links.each { |l| puts l.text }
+

data/NOTES

@@ -1,5 +1,20 @@
 = Mechanize Release Notes
 
+== 0.4.5
+
+This release comes with a new filtering system.  You can now manipulate the
+response body before mechanize parses it.  This can be useful if you know that
+the HTML you need to parse is broken, or if you want to speed up the parsing.
+This filter can be done on a global basis, or on a per page basis.  Check out
+the new examples in the EXAMPLES file for usage.
+
+This release is also starting to phase out the misspelled method
+WWW::Mechanize#basic_authetication.  If you are using that method, please
+switch to WWW::Mechanize#basic_auth.
+
+The 0.4.5 release has many bug fixes, most noteably better cookie parsing and
+better form support.
+
 == 0.4.4
 
 This release of mechanize comes with a new "Option" object that can be

data/lib/mechanize.rb

@@ -73,6 +73,7 @@ class Mechanize
   attr_accessor :watch_for_set
   attr_accessor :max_history
   attr_accessor :ca_file
+  attr_accessor :body_filter
   attr_reader :history
 
   def initialize
@@ -83,6 +84,7 @@ class Mechanize
     @read_timeout   = nil
     @watch_for_set  = nil
     @max_history    = nil
+    @body_filter    = lambda { |body| body }
     @cookie_jar = CookieJar.new
     @log = Logger.new(nil)
     yield self if block_given?
@@ -107,7 +109,10 @@ class Mechanize
     @password = password
   end
 
-  alias :basic_authetication :basic_auth
+  def basic_authetication(user, password)
+    $stderr.puts "This method will be deprecated, please change to 'basic_auth'"
+    basic_auth(user, password)
+  end
 
   def get(url)
     cur_page = current_page() || Page.new
@@ -121,7 +126,7 @@ class Mechanize
   def post(url, query={})
     cur_page = current_page() || Page.new
 
-    request_data = [build_query_string(query)]
+    request_data = [WWW::Mechanize.build_query_string(query)]
 
     # this is called before the request is sent
     pre_request_hook = proc {|request|
@@ -155,9 +160,9 @@ class Mechanize
       post_form(uri, form) 
     when 'GET'
       if uri.query.nil?
-        get(uri.to_s + "?" + build_query_string(query))
+        get(uri.to_s + "?" + WWW::Mechanize.build_query_string(query))
       else
-        get(uri.to_s + "&" + build_query_string(query))
+        get(uri.to_s + "&" + WWW::Mechanize.build_query_string(query))
       end
     else
       raise 'unsupported method'
@@ -290,7 +295,7 @@ class Mechanize
         page.code = response.code
 
         response.read_body
-        page.body = response.body
+        page.body = body_filter.call(response.body)
 
         log.info("status: #{ page.code }")
 
@@ -309,9 +314,9 @@ class Mechanize
     }
   end
 
-  def build_query_string(hash)
+  def self.build_query_string(parameters)
     vals = [] 
-    hash.each_pair {|k,v|
+    parameters.each { |k,v|
       vals <<
       [WEBrick::HTTPUtils.escape_form(k), 
        WEBrick::HTTPUtils.escape_form(v)].join("=")

data/lib/mechanize/cookie.rb

@@ -1,3 +1,5 @@
+require 'date'
+
 module WWW
   class Cookie
     attr_reader :name, :value, :path, :domain, :expires, :secure
@@ -8,7 +10,7 @@ module WWW
       @domain   = cookie[:domain]
       @expires  = cookie[:expires]
       @secure   = cookie[:secure]
-      @string   = "#{cookie[:name]}=#{URI::escape(cookie[:value])}"
+      @string   = "#{cookie[:name]}=#{cookie[:value]}"
     end
   
     def Cookie::parse(uri, raw_cookie, &block)
@@ -16,10 +18,10 @@ module WWW
       esc.split(/,/).each do |cookie_text|
         cookie_values = Hash.new
         cookie = Hash.new
-        cookie_text.split(/; /).each do |data|
+        cookie_text.split(/; ?/).each do |data|
           name, value = data.split('=', 2)
           next unless name
-          cookie[name] = value ? URI::unescape(value) : nil
+          cookie[name] = value
         end
   
         cookie_values[:path] = cookie.delete(
@@ -30,18 +32,48 @@ module WWW
         if expires_key
           time = nil
           expires_val = cookie.delete(expires_key)
+
+          # First lets try dates with timezones
           [ '%A %d-%b-%y %T %Z',
-            '%a, %d-%b-%Y %T %Z',
-            '%a %d %b %Y %T %Z'
+            '%a %d-%b-%Y %T %Z',
+            '%a %d %b %Y %T %Z',
+            '%d %b %y %H:%M %Z',      # 14 Apr 89 03:20 GMT
+            '%a %d %b %y %H:%M %Z',   # Fri, 17 Mar 89 4:01 GMT
+            '%a %b %d %H:%M %Z %Y',   # Mon Jan 16 16:12 PDT 1989
+            '%d %b %Y %H:%M-%Z (%A)', # 6 May 1992 16:41-JST (Wednesday)
+            '%y-%m-%d %T %Z',         # 95-06-08 19:32:48 EDT
           ].each { |fmt|
             begin
               time = DateTime.strptime(expires_val, fmt)
-            rescue ArgumentError
+            rescue ArgumentError => er
             else
               break
             end
           }
-          time = DateTime.parse(expires_val) if time == nil
+
+          # If it didn't have a timezone, we'll assume GMT, like Mozilla does
+          if time.nil?
+            [
+              '%d %b %y %T %Z',            # 14 Apr 89 03:20:12
+              '%a %d %b %y %T %Z',         # Fri, 17 Mar 89 4:01:33
+              #'%d-%b-%Y %H:%M:%S.%N %Z',   # 22-AUG-1993 10:59:12.82
+              '%d-%b-%Y %H:%M%P %Z',       # 22-AUG-1993 10:59pm
+              '%d-%b-%Y %H:%M %p %Z',      # 22-AUG-1993 12:59 PM
+              #'%A %B %d %Y %H:%M %p',   # Friday, August 04, 1995 3:54 PM
+              '%x %I:%M:%S %p %Z',         # 06/21/95 04:24:34 PM
+              '%d/%m/%y %H:%M %Z',         # 20/06/95 21:07
+            ].each { |fmt|
+              begin
+                time = DateTime.strptime("#{expires_val} GMT", fmt)
+              rescue ArgumentError => er
+              else
+                break
+              end
+            }
+          end
+
+          # If we couldn't parse it, set it to the current time
+          time = DateTime.now if time == nil
           cookie_values[:expires] = time
         end
 

data/lib/mechanize/form.rb

@@ -50,14 +50,15 @@ module WWW
     end
   
     def build_query(buttons = [])
-      query = {}
+      query = []
   
       fields().each do |f|
-        query[f.name] = f.value || ""
+        next unless f.value
+        query << [f.name, f.value]
       end
   
       checkboxes().each do |f|
-        query[f.name] = f.value || "on" if f.checked
+        query << [f.name, f.value || "on"] if f.checked
       end
   
       radio_groups = {}
@@ -72,7 +73,7 @@ module WWW
   
         if checked.size == 1
           f = checked.first
-          query[f.name] = f.value || ""
+          query << [f.name, f.value || ""]
         elsif checked.size > 1 
           raise "multiple radiobuttons are checked in the same group!" 
         end
@@ -102,7 +103,7 @@ module WWW
         query = params.collect { |p| "--#{boundary}\r\n#{p}" }.join('') +
           "--#{boundary}--\r\n"
       else
-        query = build_query_string(query_params)
+        query = WWW::Mechanize.build_query_string(query_params)
       end
   
       query
@@ -120,7 +121,7 @@ module WWW
         when 'input'
           case (node.attributes['type'] || 'text').downcase
           when 'text', 'password', 'hidden', 'int'
-            @fields << Field.new(node.attributes['name'], node.attributes['value']) 
+            @fields << Field.new(node.attributes['name'], node.attributes['value'] || '') 
           when 'radio'
             @radiobuttons << RadioButton.new(node.attributes['name'], node.attributes['value'], node.attributes.has_key?('checked'))
           when 'checkbox'
@@ -171,17 +172,6 @@ module WWW
   
       body
     end
-
-    def build_query_string(hash)
-      vals = []
-      hash.each_pair do |k,v|
-        vals << [
-          WEBrick::HTTPUtils.escape_form(k),
-          WEBrick::HTTPUtils.escape_form(v)
-        ].join("=")
-      end
-      vals.join("&")
-    end
   end
   
   class Form < GlobalForm

data/lib/mechanize/form_elements.rb

@@ -41,7 +41,7 @@ module WWW
     end
   
     def add_to_query(query)
-      query[@name] = @value || "" if @name
+      query << [@name, @value || ''] if @name
     end
   
     # Returns an array of Button objects
@@ -62,9 +62,9 @@ module WWW
     
     def add_to_query(query)
       if @name
-        query[@name] = @value || ""
-        query[@name+".x"] = (@x || "0").to_s
-        query[@name+".y"] = (@y || "0").to_s
+        query << [@name, @value || '']
+        query << [@name + ".x", (@x || 0).to_s]
+        query << [@name + ".y", (@y || 0).to_s]
       end
     end
   end
@@ -101,7 +101,7 @@ module WWW
           @value = option.value if option.selected
         end
       }
-      @value = @options.first.value if @value == nil
+      @value = @options.first.value if (@value == nil && @options.first)
     end
   end
 

data/lib/mechanize/mech_version.rb

@@ -1,5 +1,5 @@
 # DO NOT EDIT
 # This file is auto-generated by build scripts
 module WWW
-  MechVersion = '0.4.4'
+  MechVersion = '0.4.5'
 end

data/lib/mechanize/page.rb

@@ -22,6 +22,7 @@ module WWW
   class Page 
     attr_accessor :uri, :cookies, :response, :body, :code, :watch_for_set
     attr_finder :frames, :iframes, :links, :forms, :meta, :watches
+    attr_reader :body_filter
 
     # Alias our finders so that we can lazily parse the html
     alias :find_frames   :frames
@@ -33,15 +34,21 @@ module WWW
   
     def initialize(uri=nil, cookies=[], response=nil, body=nil, code=nil)
       @uri, @cookies, @response, @body, @code = uri, cookies, response, body, code
-      @frames   = nil
-      @iframes  = nil
-      @links    = nil
-      @forms    = nil
-      @meta     = nil
-      @watches  = nil
-      @root     = nil
+      @frames       = nil
+      @iframes      = nil
+      @links        = nil
+      @forms        = nil
+      @meta         = nil
+      @watches      = nil
+      @root         = nil
+      @body_filter  = lambda { |body| body }
     end
   
+    def body_filter=(filter)
+      @body_filter = filter
+      parse_html()
+    end
+
     def header
       @response.header
     end
@@ -96,7 +103,7 @@ module WWW
       # construct parser and feed with HTML
       parser = HTMLTree::XMLParser.new
       begin
-        parser.feed(@body)
+        parser.feed(body_filter.call(@body))
       rescue => ex
         if ex.message =~ /attempted adding second root element to document/ and
           # Put the whole document inside a single root element, which I simply name

data/test/README

@@ -1,7 +1,7 @@
 = Mechanize Testing
 
-These unit tests require a web server up and running.  To run the tests, first
-execute: 'server.rb'
+To run the tests, execute ts_mech.rb
 
-Once server.rb is up and running, execute 'ts_mech.rb' to run the tests.
+ts_mech.rb spawns a thread that has a WEBrick server in it to test against.
+The WEBrick server can be found in server.rb.
 

data/test/htdocs/file_upload.html

@@ -8,6 +8,8 @@
       Your name: <input type="text" name="name" /><br />
       File to process: <input name="userfile1" type="file" /><br />
       <input type="text" name="foo[aaron]" value="test" />
+      <select name="foo">
+      </select>
       <input type="submit" value="Send File" />
     </form>
     <form enctype="multipart/form-data" action="/file_upload" method="post">

data/test/htdocs/form_multival.html

@@ -0,0 +1,37 @@
+<html>
+  <head><title>Page Title</title></head>
+  <body>
+    <form name="post_form" method="post" action="/form_post">
+      <table>
+        <tr>
+          <td>First Name</td>
+          <td><input name="first" type="text" /></td>
+        </tr>
+        <tr>
+          <td>First Name Again</td>
+          <td><input name="first" type="text" /></td>
+        </tr>
+        <tr>
+          <td><input type="submit" value="Submit" /></td>
+          <td></td>
+        </tr>
+      </table>
+    </form>
+    <form name="get_form" method="get" action="/form_post">
+      <table>
+        <tr>
+          <td>First Name</td>
+          <td><input name="first" type="text" /></td>
+        </tr>
+        <tr>
+          <td>First Name Again</td>
+          <td><input name="first" type="text" /></td>
+        </tr>
+        <tr>
+          <td><input type="submit" value="Submit" /></td>
+          <td></td>
+        </tr>
+      </table>
+    </form>
+  </body>
+</html>

data/test/htdocs/form_test.html

@@ -32,6 +32,8 @@
         <option value="USA">USA</option>
         <option value="CANADA">CANADA</option>
       </select><br />
+      <select name="empty">
+      </select><br />
       <input type="submit" value="Submit" />
     </form>
     <h1>Get Form 1</h1>

data/test/server.rb

@@ -11,6 +11,7 @@ s = WEBrick::HTTPServer.new(
   :AccessLog      => Logger.new(nil)
 )
 s.mount("/one_cookie", OneCookieTest)
+s.mount("/one_cookie_no_space", OneCookieNoSpacesTest)
 s.mount("/many_cookies", ManyCookiesTest)
 s.mount("/many_cookies_as_string", ManyCookiesAsStringTest)
 s.mount("/send_cookies", SendCookiesTest)

data/test/servlets.rb

@@ -28,7 +28,9 @@ class FormTest < WEBrick::HTTPServlet::AbstractServlet
   def do_GET(req, res)
     res.body = "<HTML><body>"
     req.query.each_key { |k|
-      res.body << "<a href=\"#\">#{k}:#{req.query[k]}</a><br />"
+      req.query[k].each_data { |data|
+        res.body << "<a href=\"#\">#{k}:#{data}</a><br />"
+      }
     }
     res.body << "</body></HTML>"
     res['Content-Type'] = "text/html"
@@ -37,7 +39,9 @@ class FormTest < WEBrick::HTTPServlet::AbstractServlet
   def do_POST(req, res)
     res.body = "<HTML><body>"
     req.query.each_key { |k|
-      res.body << "<a href=\"#\">#{k}:#{req.query[k]}</a><br />"
+      req.query[k].each_data { |data|
+        res.body << "<a href=\"#\">#{k}:#{data}</a><br />"
+      }
     }
     res.body << "</body></HTML>"
     res['Content-Type'] = "text/html"
@@ -55,6 +59,17 @@ class OneCookieTest < WEBrick::HTTPServlet::AbstractServlet
   end
 end
 
+class OneCookieNoSpacesTest < 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 ManyCookiesTest < WEBrick::HTTPServlet::AbstractServlet
   def do_GET(req, res)
     name_cookie = WEBrick::Cookie.new("name", "Aaron")

data/test/tc_cookie_class.rb

@@ -0,0 +1,209 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'mechanize/cookie'
+require 'uri'
+require 'test_includes'
+
+module Enumerable
+  def combine
+    masks = inject([[], 1]){|(ar, m), e| [ar<<m, m<<1]}[0]
+    all = masks.inject(0){|al, m| al|m}
+
+    result = []
+    for i in 1..all do
+      tmp = []
+      each_with_index do |e, idx|
+        tmp << e unless (masks[idx] & i) == 0
+      end
+      result << tmp
+    end
+    result
+  end
+end
+
+class CookieClassTest < Test::Unit::TestCase
+  def test_parse_dates
+    url = URI.parse('http://localhost/')
+
+    yesterday = DateTime.now - 1
+
+    dates = [ "14 Apr 89 03:20:12",
+              "14 Apr 89 03:20 GMT",
+              "Fri, 17 Mar 89 4:01:33",
+              "Fri, 17 Mar 89 4:01 GMT",
+              "Mon Jan 16 16:12 PDT 1989",
+              "Mon Jan 16 16:12 +0130 1989",
+              "6 May 1992 16:41-JST (Wednesday)",
+              #"22-AUG-1993 10:59:12.82",
+              "22-AUG-1993 10:59pm",
+              "22-AUG-1993 12:59am",
+              "22-AUG-1993 12:59 PM",
+              #"Friday, August 04, 1995 3:54 PM",
+              "06/21/95 04:24:34 PM",
+              "20/06/95 21:07",
+              "95-06-08 19:32:48 EDT",
+    ]
+
+    dates.each do |date|
+      cookie = "PREF=1; expires=#{date}"
+      WWW::Cookie.parse(url, cookie) { |cookie|
+        assert_equal(true, cookie.expires < yesterday)
+      }
+    end
+  end
+
+  def test_parse_valid_cookie
+    url = URI.parse('http://rubyforge.org/')
+    cookie_params = {}
+    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
+    cookie_params['path']      = 'path=/'
+    cookie_params['domain']    = 'domain=.rubyforge.org'
+    cookie_params['httponly']  = 'HttpOnly'
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    expires = DateTime.strptime('Sun, 27-Sep-2037 00:00:00 GMT',
+              '%a, %d-%b-%Y %T %Z')
+    
+    cookie_params.keys.combine.each do |c|
+      cookie_text = "#{cookie_value}; "
+      c.each_with_index do |key, idx|
+        if idx == (c.length - 1)
+          cookie_text << "#{cookie_params[key]}"
+        else
+          cookie_text << "#{cookie_params[key]}; "
+        end
+      end
+      cookie = nil
+      WWW::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
+      assert_not_nil(cookie)
+      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
+      assert_equal('/', cookie.path)
+      assert_equal('rubyforge.org', cookie.domain)
+
+      # if expires was set, make sure we parsed it
+      if c.find { |k| k == 'expires' }
+        assert_equal(expires, cookie.expires)
+      else
+        assert_nil(cookie.expires)
+      end
+    end
+  end
+
+  # If no path was given, use the one from the URL
+  def test_cookie_using_url_path
+    url = URI.parse('http://rubyforge.org/login')
+    cookie_params = {}
+    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
+    cookie_params['path']      = 'path=/'
+    cookie_params['domain']    = 'domain=.rubyforge.org'
+    cookie_params['httponly']  = 'HttpOnly'
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    expires = DateTime.strptime('Sun, 27-Sep-2037 00:00:00 GMT',
+              '%a, %d-%b-%Y %T %Z')
+    
+    cookie_params.keys.combine.each do |c|
+      next if c.find { |k| k == 'path' }
+      cookie_text = "#{cookie_value}; "
+      c.each_with_index do |key, idx|
+        if idx == (c.length - 1)
+          cookie_text << "#{cookie_params[key]}"
+        else
+          cookie_text << "#{cookie_params[key]}; "
+        end
+      end
+      cookie = nil
+      WWW::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
+      assert_not_nil(cookie)
+      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
+      assert_equal('rubyforge.org', cookie.domain)
+      assert_equal('/login', cookie.path)
+
+      # if expires was set, make sure we parsed it
+      if c.find { |k| k == 'expires' }
+        assert_equal(expires, cookie.expires)
+      else
+        assert_nil(cookie.expires)
+      end
+    end
+  end
+
+  # If no domain was given, we must use the one from the URL
+  def test_cookie_with_url_domain
+    url = URI.parse('http://login.rubyforge.org/')
+    cookie_params = {}
+    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
+    cookie_params['path']      = 'path=/'
+    cookie_params['domain']    = 'domain=.rubyforge.org'
+    cookie_params['httponly']  = 'HttpOnly'
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    expires = DateTime.strptime('Sun, 27-Sep-2037 00:00:00 GMT',
+              '%a, %d-%b-%Y %T %Z')
+    
+    cookie_params.keys.combine.each do |c|
+      next if c.find { |k| k == 'domain' }
+      cookie_text = "#{cookie_value}; "
+      c.each_with_index do |key, idx|
+        if idx == (c.length - 1)
+          cookie_text << "#{cookie_params[key]}"
+        else
+          cookie_text << "#{cookie_params[key]}; "
+        end
+      end
+      cookie = nil
+      WWW::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
+      assert_not_nil(cookie)
+      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
+      assert_equal('/', cookie.path)
+
+      assert_equal('login.rubyforge.org', cookie.domain)
+
+      # if expires was set, make sure we parsed it
+      if c.find { |k| k == 'expires' }
+        assert_equal(expires, cookie.expires)
+      else
+        assert_nil(cookie.expires)
+      end
+    end
+  end
+
+  def test_parse_cookie_no_spaces
+    url = URI.parse('http://rubyforge.org/')
+    cookie_params = {}
+    cookie_params['expires']   = 'expires=Sun, 27-Sep-2037 00:00:00 GMT'
+    cookie_params['path']      = 'path=/'
+    cookie_params['domain']    = 'domain=.rubyforge.org'
+    cookie_params['httponly']  = 'HttpOnly'
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    expires = DateTime.strptime('Sun, 27-Sep-2037 00:00:00 GMT',
+              '%a, %d-%b-%Y %T %Z')
+    
+    cookie_params.keys.combine.each do |c|
+      cookie_text = "#{cookie_value};"
+      c.each_with_index do |key, idx|
+        if idx == (c.length - 1)
+          cookie_text << "#{cookie_params[key]}"
+        else
+          cookie_text << "#{cookie_params[key]};"
+        end
+      end
+      cookie = nil
+      WWW::Cookie.parse(url, cookie_text) { |p_cookie| cookie = p_cookie }
+      assert_not_nil(cookie)
+      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
+      assert_equal('/', cookie.path)
+      assert_equal('rubyforge.org', cookie.domain)
+
+      # if expires was set, make sure we parsed it
+      if c.find { |k| k == 'expires' }
+        assert_equal(expires, cookie.expires)
+      else
+        assert_nil(cookie.expires)
+      end
+    end
+  end
+end
+

data/test/tc_cookie_jar.rb

@@ -0,0 +1,167 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'mechanize/cookie'
+require 'uri'
+require 'test_includes'
+
+class CookieJarTest < Test::Unit::TestCase
+  def test_add_future_cookies
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => DateTime.now + 10,
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = WWW::Cookie.new(values)
+    jar.add(cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    # Add the same cookie, and we should still only have one
+    jar.add(WWW::Cookie.new(values))
+    assert_equal(1, jar.cookies(url).length)
+
+    # Make sure we can get the cookie from different paths
+    assert_equal(1, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
+
+    # Make sure we can't get the cookie from different domains
+    assert_equal(0, jar.cookies(URI.parse('http://google.com/')).length)
+  end
+
+  def test_add_multiple_cookies
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => DateTime.now + 10,
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = WWW::Cookie.new(values)
+    jar.add(cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    # Add the same cookie, and we should still only have one
+    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz' )))
+    assert_equal(2, jar.cookies(url).length)
+
+    # Make sure we can get the cookie from different paths
+    assert_equal(2, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
+
+    # Make sure we can't get the cookie from different domains
+    assert_equal(0, jar.cookies(URI.parse('http://google.com/')).length)
+  end
+
+  def test_expire_cookies
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => DateTime.now + 10,
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = WWW::Cookie.new(values)
+    jar.add(cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    # Add a second cookie
+    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz' )))
+    assert_equal(2, jar.cookies(url).length)
+
+    # Make sure we can get the cookie from different paths
+    assert_equal(2, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
+
+    # Expire the first cookie
+    jar.add(WWW::Cookie.new(values.merge( :expires => DateTime.now - 10)))
+    assert_equal(1, jar.cookies(url).length)
+
+    # Expire the second cookie
+    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz',
+                                          :expires => DateTime.now - 10)))
+    assert_equal(0, jar.cookies(url).length)
+  end
+
+  def test_session_cookies
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/',
+                :expires  => nil,
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/')
+
+    jar = WWW::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = WWW::Cookie.new(values)
+    jar.add(cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    # Add a second cookie
+    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz' )))
+    assert_equal(2, jar.cookies(url).length)
+
+    # Make sure we can get the cookie from different paths
+    assert_equal(2, jar.cookies(URI.parse('http://rubyforge.org/login')).length)
+
+    # Expire the first cookie
+    jar.add(WWW::Cookie.new(values.merge( :expires => DateTime.now - 10)))
+    assert_equal(1, jar.cookies(url).length)
+
+    # Expire the second cookie
+    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz',
+                                          :expires => DateTime.now - 10)))
+    assert_equal(0, jar.cookies(url).length)
+  end
+
+  def test_paths
+    values = {  :name     => 'Foo',
+                :value    => 'Bar',
+                :path     => '/login',
+                :expires  => nil,
+                :domain   => 'rubyforge.org'
+             }
+    url = URI.parse('http://rubyforge.org/login')
+
+    jar = WWW::CookieJar.new
+    assert_equal(0, jar.cookies(url).length)
+
+    # Add one cookie with an expiration date in the future
+    cookie = WWW::Cookie.new(values)
+    jar.add(cookie)
+    assert_equal(1, jar.cookies(url).length)
+
+    # Add a second cookie
+    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz' )))
+    assert_equal(2, jar.cookies(url).length)
+
+    # Make sure we don't get the cookie in a different path
+    assert_equal(0, jar.cookies(URI.parse('http://rubyforge.org/hello')).length)
+    assert_equal(0, jar.cookies(URI.parse('http://rubyforge.org/')).length)
+
+    # Expire the first cookie
+    jar.add(WWW::Cookie.new(values.merge( :expires => DateTime.now - 10)))
+    assert_equal(1, jar.cookies(url).length)
+
+    # Expire the second cookie
+    jar.add(WWW::Cookie.new(values.merge( :name => 'Baz',
+                                          :expires => DateTime.now - 10)))
+    assert_equal(0, jar.cookies(url).length)
+  end
+end

data/test/tc_cookies.rb

@@ -19,6 +19,17 @@ class CookiesMechTest < Test::Unit::TestCase
     assert_not_nil(page.links.find { |l| l.text == "no_expires:nope" })
   end
 
+  def test_no_space_cookies
+    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+    page = agent.get("http://localhost:#{@port}/one_cookie_no_space")
+    assert_equal(1, agent.cookies.length)
+    foo_cookie = agent.cookies.find { |k| k.name == 'foo' }
+    assert_not_nil(foo_cookie, 'Foo cookie was nil')
+    assert_equal('bar', foo_cookie.value)
+    assert_equal('/', foo_cookie.path)
+    assert_equal(true, DateTime.now < foo_cookie.expires)
+  end
+
   def test_many_cookies_as_string
     agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
     page = agent.get("http://localhost:#{@port}/many_cookies_as_string")

data/test/tc_filter.rb

@@ -0,0 +1,34 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'test/unit'
+require 'rubygems'
+require 'mechanize'
+require 'test_includes'
+
+class FilterTest < Test::Unit::TestCase
+  include TestMethods
+
+  def test_local_filter
+    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+    page = agent.get("http://localhost:#{@port}/find_link.html")
+    page.body_filter = lambda { |body| body.gsub(/<body>/, '<body><a href="http://daapclient.rubyforge.org">Net::DAAP::Client</a>') }
+    assert_equal(16, page.links.length)
+    assert_not_nil(page.links.text('Net::DAAP::Client').first)
+    assert_equal(1, page.links.text('Net::DAAP::Client').length)
+  end
+
+  def test_global_filter
+    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+    agent.body_filter = lambda { |body| body.gsub(/<body>/, '<body><a href="http://daapclient.rubyforge.org">Net::DAAP::Client</a>') }
+    page = agent.get("http://localhost:#{@port}/find_link.html")
+    assert_equal(16, page.links.length)
+    assert_not_nil(page.links.text('Net::DAAP::Client').first)
+    assert_equal(1, page.links.text('Net::DAAP::Client').length)
+
+    page = agent.get("http://localhost:#{@port}/find_link.html")
+    page.body_filter = lambda { |body| body.gsub(/<body>/, '<body><a href="http://daapclient.rubyforge.org">Net::DAAP::Client</a>') }
+    assert_equal(17, page.links.length)
+    assert_not_nil(page.links.text('Net::DAAP::Client').first)
+    assert_equal(2, page.links.text('Net::DAAP::Client').length)
+  end
+end

data/test/tc_forms.rb

@@ -9,6 +9,48 @@ require 'test_includes'
 class FormsMechTest < Test::Unit::TestCase
   include TestMethods
 
+  # Test submitting form with two fields of the same name
+  def test_post_multival
+    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+    page = agent.get("http://localhost:#{@port}/form_multival.html")
+    form = page.forms.name('post_form').first
+
+    assert_not_nil(form)
+    assert_equal(2, form.fields.name('first').length)
+
+    form.fields.name('first')[0].value = 'Aaron'
+    form.fields.name('first')[1].value = 'Patterson'
+
+    page = agent.submit(form)
+
+    assert_not_nil(page)
+
+    assert_equal(2, page.links.length)
+    assert_not_nil(page.links.text('first:Aaron').first)
+    assert_not_nil(page.links.text('first:Patterson').first)
+  end
+
+  # Test submitting form with two fields of the same name
+  def test_get_multival
+    agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
+    page = agent.get("http://localhost:#{@port}/form_multival.html")
+    form = page.forms.name('get_form').first
+
+    assert_not_nil(form)
+    assert_equal(2, form.fields.name('first').length)
+
+    form.fields.name('first')[0].value = 'Aaron'
+    form.fields.name('first')[1].value = 'Patterson'
+
+    page = agent.submit(form)
+
+    assert_not_nil(page)
+
+    assert_equal(2, page.links.length)
+    assert_not_nil(page.links.text('first:Aaron').first)
+    assert_not_nil(page.links.text('first:Patterson').first)
+  end
+
   def test_post
     agent = WWW::Mechanize.new { |a| a.log = Logger.new(nil) }
     page = agent.get("http://localhost:#{@port}/form_test.html")
@@ -17,7 +59,7 @@ class FormsMechTest < Test::Unit::TestCase
     assert_equal("post", post_form.method.downcase)
     assert_equal("/form_post", post_form.action)
 
-    assert_equal(2, post_form.fields.size)
+    assert_equal(3, post_form.fields.size)
 
     assert_equal(1, post_form.buttons.size)
     assert_equal(2, post_form.radiobuttons.size)

data/test/ts_mech.rb

@@ -16,4 +16,7 @@ require 'tc_forms'
 require 'tc_watches'
 require 'tc_parsing'
 require 'tc_authenticate'
+require 'tc_filter'
+require 'tc_cookie_class'
+require 'tc_cookie_jar'
 

metadata

@@ -3,11 +3,11 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: mechanize
 version: !ruby/object:Gem::Version 
-  version: 0.4.4
-date: 2006-05-11 00:00:00 -07:00
+  version: 0.4.5
+date: 2006-05-20 00:00:00 -07:00
 summary: Mechanize provides automated web-browsing
 require_paths: 
-- lib
+  - lib
 email: aaronp@rubyforge.org
 homepage: mechanize.rubyforge.org
 rubyforge_project: mechanize
@@ -18,89 +18,91 @@ bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
   version: 
 platform: ruby
 signing_key: 
 cert_chain: 
 authors: 
-- Aaron Patterson
+  - Aaron Patterson
 files: 
-- test/tc_watches.rb
-- test/servlets.rb
-- test/tc_upload.rb
-- test/htdocs
-- test/tc_response_code.rb
-- test/tc_links.rb
-- test/tc_forms.rb
-- test/server.rb
-- test/test_mech.rb
-- test/tc_frames.rb
-- test/test_includes.rb
-- test/tc_cookies.rb
-- test/tc_authenticate.rb
-- test/tc_mech.rb
-- test/README
-- test/data
-- test/tc_parsing.rb
-- test/ts_mech.rb
-- test/htdocs/find_link.html
-- test/htdocs/frame_test.html
-- test/htdocs/iframe_test.html
-- test/htdocs/google.html
-- test/htdocs/form_test.html
-- test/htdocs/index.html
-- test/htdocs/button.jpg
-- test/htdocs/file_upload.html
-- test/data/htpasswd
-- lib/mechanize
-- lib/mechanize.rb
-- lib/mechanize/cookie.rb
-- lib/mechanize/page.rb
-- lib/mechanize/form.rb
-- lib/mechanize/parsing.rb
-- lib/mechanize/net-overrides
-- lib/mechanize/page_elements.rb
-- lib/mechanize/form_elements.rb
-- lib/mechanize/mech_version.rb
-- lib/mechanize/module.rb
-- lib/mechanize/net-overrides/net
-- lib/mechanize/net-overrides/net/http.rb
-- lib/mechanize/net-overrides/net/protocol.rb
-- lib/mechanize/net-overrides/net/https.rb
-- README
-- EXAMPLES
-- CHANGELOG
-- LICENSE
-- NOTES
+  - test/data
+  - test/htdocs
+  - test/README
+  - test/server.rb
+  - test/servlets.rb
+  - test/tc_authenticate.rb
+  - test/tc_cookie_class.rb
+  - test/tc_cookie_jar.rb
+  - test/tc_cookies.rb
+  - test/tc_filter.rb
+  - test/tc_forms.rb
+  - test/tc_frames.rb
+  - test/tc_links.rb
+  - test/tc_mech.rb
+  - test/tc_parsing.rb
+  - test/tc_response_code.rb
+  - test/tc_upload.rb
+  - test/tc_watches.rb
+  - test/test_includes.rb
+  - test/test_mech.rb
+  - test/ts_mech.rb
+  - test/data/htpasswd
+  - test/htdocs/button.jpg
+  - test/htdocs/file_upload.html
+  - test/htdocs/find_link.html
+  - test/htdocs/form_multival.html
+  - test/htdocs/form_test.html
+  - test/htdocs/frame_test.html
+  - test/htdocs/google.html
+  - test/htdocs/iframe_test.html
+  - test/htdocs/index.html
+  - lib/mechanize
+  - lib/mechanize.rb
+  - lib/mechanize/cookie.rb
+  - lib/mechanize/form.rb
+  - lib/mechanize/form_elements.rb
+  - lib/mechanize/mech_version.rb
+  - lib/mechanize/module.rb
+  - lib/mechanize/net-overrides
+  - lib/mechanize/page.rb
+  - lib/mechanize/page_elements.rb
+  - lib/mechanize/parsing.rb
+  - lib/mechanize/net-overrides/net
+  - lib/mechanize/net-overrides/net/http.rb
+  - lib/mechanize/net-overrides/net/https.rb
+  - lib/mechanize/net-overrides/net/protocol.rb
+  - README
+  - EXAMPLES
+  - CHANGELOG
+  - LICENSE
+  - NOTES
 test_files: []
-
 rdoc_options: 
-- --main
-- README
-- --title
-- "'WWW::Mechanize RDoc'"
+  - "--main"
+  - README
+  - "--title"
+  - "'WWW::Mechanize RDoc'"
 extra_rdoc_files: 
-- README
-- EXAMPLES
-- CHANGELOG
-- LICENSE
-- NOTES
+  - README
+  - EXAMPLES
+  - CHANGELOG
+  - LICENSE
+  - NOTES
 executables: []
-
 extensions: []
-
 requirements: []
-
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: ruby-web
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.1.0
-    version: 
+  - !ruby/object:Gem::Dependency 
+    name: ruby-web
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: 1.1.0
+      version: