mechanize 2.0.pre.2 → 2.0

data/lib/mechanize/page/meta.rb

@@ -1,48 +0,0 @@
-class Mechanize
-  class Page < Mechanize::File
-    # This class encapsulates a Meta tag.  Mechanize treats meta tags just
-    # like 'a' tags.  Meta objects will contain links, but most likely will
-    # have no text.
-    class Meta < Link
-
-      # Matches the content attribute of a meta tag.  After the match:
-      #
-      #   $1:: delay
-      #   $3:: url
-      #
-      CONTENT_REGEXP = /^\s*(\d+\.?\d*)(;|;\s*url=\s*['"]?(\S*?)['"]?)?\s*$/i
-
-      class << self
-        # Parses the delay and url from the content attribute of a meta tag.
-        # Parse requires the uri of the current page to infer a url when no
-        # url is specified.  If a block is given, the parsed delay and url
-        # will be passed to it for further processing.
-        #
-        # Returns nil if the delay and url cannot be parsed.
-        #
-        #   # <meta http-equiv="refresh" content="5;url=http://example.com/" />
-        #   uri = URI.parse('http://current.com/')
-        #
-        #   Meta.parse("5;url=http://example.com/", uri)  # => ['5', 'http://example.com/']
-        #   Meta.parse("5;url=", uri)                     # => ['5', 'http://current.com/']
-        #   Meta.parse("5", uri)                          # => ['5', 'http://current.com/']
-        #   Meta.parse("invalid content", uri)            # => nil
-        #
-        def parse(content, uri)
-          if content && content =~ CONTENT_REGEXP
-            delay, url = $1, $3
-
-            dest = uri
-            dest += url if url
-            url = dest.to_s
-
-            block_given? ? yield(delay, url) : [delay, url]
-          else
-            nil
-          end
-        end
-      end
-    end
-  end
-end
-

data/test/test_form_no_inputname.rb

@@ -1,15 +0,0 @@
-require "helper"
-
-class FormNoInputNameTest < Test::Unit::TestCase
-  def setup
-    @agent = Mechanize.new
-    @page = @agent.get('http://localhost/form_no_input_name.html')
-  end
-
-  def test_no_input_name
-    form = @page.forms.first
-    assert_equal(0, form.fields.length)
-    assert_equal(0, form.radiobuttons.length)
-    assert_equal(0, form.checkboxes.length)
-  end
-end

data/test/test_links.rb

@@ -1,146 +0,0 @@
-require "helper"
-
-class LinksMechTest < Test::Unit::TestCase
-  def setup
-    @agent = Mechanize.new
-  end
-
-  def test_weird_uri
-    doc = Nokogiri::HTML::Document.new
-    node = Nokogiri::XML::Node.new('foo', doc)
-    node['href'] = 'http://foo.bar/ baz'
-    link = Mechanize::Page::Link.new(node, nil, nil)
-    assert_equal 'http://foo.bar/%20baz', link.uri.to_s
-  end
-
-  def test_unsupported_link_types
-    page = @agent.get("http://google.com/tc_links.html")
-    link = page.link_with(:text => 'javascript link')
-    assert_raise(Mechanize::UnsupportedSchemeError) {
-      link.click
-    }
-
-    @agent.scheme_handlers['javascript'] = lambda { |my_link, my_page|
-      URI.parse('http://localhost/tc_links.html')
-    }
-    assert_nothing_raised {
-      link.click
-    }
-  end
-
-  def test_link_with_no_path
-    page = @agent.get("http://localhost/relative/tc_relative_links.html")
-    page = page.link_with(:text => 'just the query string').click
-    assert_equal('http://localhost/relative/tc_relative_links.html?a=b', page.uri.to_s)
-  end
-
-  def test_base
-    page = @agent.get("http://google.com/tc_base_link.html")
-    page = page.links.first.click
-    assert @agent.visited?("http://localhost/index.html")
-  end
-
-  def test_find_meta
-    page = @agent.get("http://localhost/find_link.html")
-    assert_equal(3, page.meta.length)
-    assert_equal(%w{
-      http://www.drphil.com/
-      http://www.upcase.com/
-      http://tenderlovemaking.com/ }.sort,
-      page.meta.map { |x| x.href.downcase }.sort)
-  end
-
-  def test_find_link
-    page = @agent.get("http://localhost/find_link.html")
-    assert_equal(18, page.links.length)
-  end
-
-  def test_alt_text
-    page = @agent.get("http://localhost/alt_text.html")
-    assert_equal(5, page.links.length)
-    assert_equal(1, page.meta.length)
-
-    assert_equal('', page.meta.first.text)
-    assert_equal('alt text', page.link_with(:href => 'alt_text.html').text)
-    assert_equal('', page.link_with(:href => 'no_alt_text.html').text)
-    assert_equal('no image', page.link_with(:href => 'no_image.html').text)
-    assert_equal('', page.link_with(:href => 'no_text.html').text)
-    assert_equal('', page.link_with(:href => 'nil_alt_text.html').text)
-  end
-
-  def test_click_link
-    @agent.user_agent_alias = 'Mac Safari'
-    page = @agent.get("http://localhost/frame_test.html")
-    link = page.link_with(:text => "Form Test")
-    assert_not_nil(link)
-    assert_equal('Form Test', link.text)
-    page = @agent.click(link)
-    assert_equal("http://localhost/form_test.html",
-      @agent.history.last.uri.to_s)
-  end
-
-  def test_click_method
-    page = @agent.get("http://localhost/frame_test.html")
-    link = page.link_with(:text => "Form Test")
-    assert_not_nil(link)
-    assert_equal('Form Test', link.text)
-    page = link.click
-    assert_equal("http://localhost/form_test.html",
-      @agent.history.last.uri.to_s)
-  end
-
-  def test_find_bold_link
-    page = @agent.get("http://localhost/tc_links.html")
-    link = page.links_with(:text => /Bold Dude/)
-    assert_equal(1, link.length)
-    assert_equal('Bold Dude', link.first.text)
-    assert_equal [], link.first.rel
-    assert !link.first.rel?('me')
-    assert !link.first.rel?('nofollow')
-
-    link = page.links_with(:text => 'Aaron James Patterson')
-    assert_equal(1, link.length)
-    assert_equal('Aaron James Patterson', link.first.text)
-    assert_equal ['me'], link.first.rel
-    assert link.first.rel?('me')
-    assert !link.first.rel?('nofollow')
-
-    link = page.links_with(:text => 'Aaron Patterson')
-    assert_equal(1, link.length)
-    assert_equal('Aaron Patterson', link.first.text)
-    assert_equal ['me', 'nofollow'], link.first.rel
-    assert link.first.rel?('me')
-    assert link.first.rel?('nofollow')
-
-    link = page.links_with(:text => 'Ruby Rocks!')
-    assert_equal(1, link.length)
-    assert_equal('Ruby Rocks!', link.first.text)
-  end
-
-  def test_link_with_encoded_space
-    page = @agent.get("http://localhost/tc_links.html")
-    link = page.link_with(:text => 'encoded space')
-    page = @agent.click link
-  end
-
-  def test_link_with_space
-    page = @agent.get("http://localhost/tc_links.html")
-    link = page.link_with(:text => 'not encoded space')
-    page = @agent.click link
-  end
-
-  def test_link_with_unusual_characters
-    page = @agent.get("http://localhost/tc_links.html")
-    link = page.link_with(:text => 'unusual characters')
-    assert_nothing_raised { @agent.click link }
-  end
-  
-  def test_links_dom_id
-    page = @agent.get("http://localhost/tc_links.html")
-    link = page.links_with(:dom_id => 'bold_aaron_link')
-    link_by_id = page.links_with(:id => 'bold_aaron_link')
-    assert_equal(1, link.length)
-    assert_equal('Aaron Patterson', link.first.text)
-    assert_equal(link, link_by_id)
-  end
-end

data/test/test_mechanize_page.rb

@@ -1,224 +0,0 @@
-# coding: utf-8
-
-require 'helper'
-require 'cgi'
-
-class TestMechanizePage < Test::Unit::TestCase
-
-  WINDOWS_1255 = <<-HTML
-<meta http-equiv="content-type" content="text/html; charset=windows-1255">
-<title>hi</title>
-  HTML
-
-  BAD = <<-HTML
-<meta http-equiv="content-type" content="text/html; charset=windows-1255">
-<title>Bia\xB3ystok</title>
-  HTML
-  BAD.force_encoding Encoding::BINARY if defined? Encoding
-
-  SJIS_TITLE = "\x83\x65\x83\x58\x83\x67"
-
-  SJIS_AFTER_TITLE = <<-HTML
-<title>#{SJIS_TITLE}</title>
-<meta http-equiv="Content-Type" content="text/html; charset=Shift_JIS">
-  HTML
-
-  SJIS_AFTER_TITLE.force_encoding Encoding::BINARY if defined? Encoding
-
-  SJIS_BAD_AFTER_TITLE = <<-HTML
-<title>#{SJIS_TITLE}</title>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-  HTML
-
-  SJIS_BAD_AFTER_TITLE.force_encoding Encoding::BINARY if defined? Encoding
-
-  UTF8_TITLE = 'テスト'
-  UTF8 = <<-HTML
-<title>#{UTF8_TITLE}</title>
-<meta http-equiv="Content-Type" content="text/html; charset=Shift_JIS">
-  HTML
-
-  def setup
-    @agent = Mechanize.new
-    @uri = URI('http://example')
-    @res = { 'content-type' => 'text/html' }
-    @body = '<title>hi</title>'
-  end
-
-  def util_page body = @body, res = @res
-    body.force_encoding Encoding::BINARY if body.respond_to? :force_encoding
-    Mechanize::Page.new @uri, res, body, 200, @agent
-  end
-
-  def test_initialize_content_type
-    assert Mechanize::Page.new nil, 'content-type' => 'application/xhtml+xml'
-    assert Mechanize::Page.new nil, 'content-type' => 'text/html'
-
-    e = assert_raises Mechanize::ContentTypeError do
-      Mechanize::Page.new nil, 'content-type' => 'text/plain'
-    end
-
-    assert_equal 'text/plain', e.content_type
-  end
-
-  def test_canonical_uri
-    page = @agent.get("http://localhost/canonical_uri.html")
-    assert_equal(URI("http://localhost/canonical_uri"), page.canonical_uri)
-
-    page = @agent.get("http://localhost/file_upload.html")
-    assert_equal(nil, page.canonical_uri)
-  end
-
-  def test_canonical_uri_unescaped
-    page = util_page <<-BODY
-<head>
-  <link rel="canonical" href="http://example/white space"/>
-</head>
-    BODY
-
-    assert_equal @uri + '/white%20space', page.canonical_uri
-  end
-
-  def test_charset
-    charset = util_page.charset 'text/html;charset=UTF-8'
-
-    assert_equal 'UTF-8', charset
-  end
-
-  def test_encoding
-    page = util_page WINDOWS_1255
-
-    assert_equal 'windows-1255', page.encoding
-  end
-
-  def test_encoding_charset_after_title
-    page = util_page SJIS_AFTER_TITLE
-
-    assert_equal [], page.parser.errors
-
-    assert_equal 'Shift_JIS', page.encoding
-  end
-
-  def test_encoding_charset_after_title_bad
-    page = util_page UTF8
-
-    assert_equal [], page.parser.errors
-
-    assert_equal 'UTF-8', page.encoding
-  end
-
-  def test_encoding_charset_after_title_double_bad
-    page = util_page SJIS_BAD_AFTER_TITLE
-
-    assert_equal [], page.parser.errors
-
-    assert_equal 'SHIFT_JIS', page.encoding
-  end
-
-  def test_encoding_charset_bad
-    page = util_page "<title>#{UTF8_TITLE}</title>"
-    page.encodings.replace %w[
-      UTF-8
-      Shift_JIS
-    ]
-
-    assert_equal [], page.parser.errors
-
-    assert_equal 'UTF-8', page.encoding
-  end
-
-  def test_encoding_equals
-    page = util_page
-    page.meta
-    assert page.instance_variable_get(:@meta)
-
-    page.encoding = 'UTF-8'
-
-    assert_nil page.instance_variable_get(:@meta)
-
-    assert_equal 'UTF-8', page.encoding
-    assert_equal 'UTF-8', page.parser.encoding
-  end
-
-  def test_encoding_equals_before_parser
-    # document has a bad encoding information - windows-1255
-    page = util_page BAD
-
-    # encoding is wrong, so user wants to force ISO-8859-2
-    page.encoding = 'ISO-8859-2'
-
-    assert_equal [], page.parser.errors
-    assert_equal 'ISO-8859-2', page.encoding
-    assert_equal 'ISO-8859-2', page.parser.encoding
-  end
-
-  def test_encoding_equals_after_parser
-    # document has a bad encoding information - windows-1255
-    page = util_page BAD
-    page.parser
-
-    # autodetection sets encoding to windows-1255
-    assert_equal 'windows-1255', page.encoding
-
-    # encoding is wrong, so user wants to force ISO-8859-2
-    page.encoding = 'ISO-8859-2'
-
-    assert_equal [], page.parser.errors
-    assert_equal 'ISO-8859-2', page.encoding
-    assert_equal 'ISO-8859-2', page.parser.encoding
-  end
-
-  def test_frames_with
-    page = @agent.get("http://localhost/frame_test.html")
-    assert_equal(3, page.frames.size)
-
-    find_orig = page.frames.find_all { |f| f.name == 'frame1' }
-
-    find1 = page.frames_with(:name => 'frame1')
-
-    find_orig.zip(find1).each { |a,b|
-      assert_equal(a, b)
-    }
-  end
-
-  def test_title
-    page = util_page
-
-    assert_equal('hi', page.title)
-  end
-
-  def test_title_none
-    page = util_page '' # invalid HTML
-
-    assert_equal(nil, page.title)
-  end
-
-  def test_page_decoded_with_charset
-    page = util_page @body, 'content-type' => 'text/html; charset=EUC-JP'
-
-    assert_equal 'EUC-JP', page.encoding
-    assert_equal 'EUC-JP', page.parser.encoding
-  end
-
-  def test_form
-    page  = @agent.get("http://localhost/tc_form_action.html")
-
-    form = page.form(:name => 'post_form1')
-    assert form
-    yielded = false
-
-    form = page.form(:name => 'post_form1') { |f|
-      yielded = true
-      assert f
-      assert_equal(form, f)
-    }
-
-    assert yielded
-
-    form_by_action = page.form(:action => '/form_post?a=b&b=c')
-    assert form_by_action
-    assert_equal(form, form_by_action)
-  end
-
-end
-

data/test/test_meta.rb

@@ -1,67 +0,0 @@
-require "helper"
-
-class MetaTest < Test::Unit::TestCase
-  Meta = Mechanize::Page::Meta
-
-  #
-  # CONTENT_REGEXP test
-  #
-
-  def test_content_regexp
-    r = Meta::CONTENT_REGEXP
-
-    assert r =~ "0; url=http://localhost:8080/path"
-    assert_equal "0", $1
-    assert_equal "http://localhost:8080/path", $3
-
-    assert r =~ "100.001; url=http://localhost:8080/path"
-    assert_equal "100.001", $1
-    assert_equal "http://localhost:8080/path", $3
-
-    assert r =~ "0; url='http://localhost:8080/path'"
-    assert_equal "0", $1
-    assert_equal "http://localhost:8080/path", $3
-
-    assert r =~ "0; url=\"http://localhost:8080/path\""
-    assert_equal "0", $1
-    assert_equal "http://localhost:8080/path", $3
-
-    assert r =~ "0; url="
-    assert_equal "0", $1
-    assert_equal "", $3
-
-    assert r =~ "0"
-    assert_equal "0", $1
-    assert_equal nil, $3
-
-    assert r =~ "   0;   "
-    assert_equal "0", $1
-    assert_equal nil, $3
-
-    assert r =~ "0; UrL=http://localhost:8080/path"
-    assert_equal "0", $1
-    assert_equal "http://localhost:8080/path", $3
-  end
-
-  #
-  # parse test
-  #
-
-  def test_parse_documentation
-    uri = URI.parse('http://current.com/here/')
-
-    assert_equal ['5', 'http://example.com/'], Meta.parse("5;url=http://example.com/", uri)
-    assert_equal ['5', 'http://current.com/here/test'], Meta.parse("5;url=test", uri)
-    assert_equal ['5', 'http://current.com/test'], Meta.parse("5;url=/test", uri)
-    assert_equal ['5', 'http://current.com/here/'], Meta.parse("5;url=", uri) 
-    assert_equal ['5', 'http://current.com/here/'], Meta.parse("5", uri) 
-    assert_equal nil, Meta.parse("invalid content", uri)
-  end
-
-  def test_parse_returns_nil_if_no_delay_and_url_can_be_parsed
-    uri = URI.parse('http://current.com/')
-
-    assert_equal nil, Meta.parse("invalid content", uri)
-    assert_equal nil, Meta.parse("invalid content", uri) {|delay, url| 'not nil' }
-  end
-end