mechanize 0.6.11 → 0.7.0

data/lib/www/mechanize/page.rb

@@ -0,0 +1,121 @@
+require 'fileutils'
+require 'hpricot'
+require 'forwardable'
+
+require 'www/mechanize/page/link'
+require 'www/mechanize/page/meta'
+require 'www/mechanize/page/base'
+require 'www/mechanize/page/frame'
+require 'www/mechanize/headers'
+
+module WWW
+  class Mechanize
+    # = Synopsis
+    # This class encapsulates an HTML page.  If Mechanize finds a content
+    # type of 'text/html', this class will be instantiated and returned.
+    #
+    # == Example
+    #  require 'rubygems'
+    #  require 'mechanize'
+    #
+    #  agent = WWW::Mechanize.new
+    #  agent.get('http://google.com/').class  #=> WWW::Mechanize::Page
+    #
+    class Page < WWW::Mechanize::File
+      extend Forwardable
+
+      attr_accessor :mech
+
+      def initialize(uri=nil, response=nil, body=nil, code=nil, mech=nil)
+        super(uri, response, body, code)
+        @mech           ||= mech
+
+        raise Mechanize::ContentTypeError.new(response['content-type']) unless
+            content_type() =~ /^text\/html/ 
+
+        @parser = @links = @forms = @meta = @bases = @frames = @iframes = nil
+      end
+
+      def title
+        @title ||= if parser && search('title').text.length > 0
+          search('title').text
+        end
+      end
+
+      def parser
+        @parser ||= body && response ? Hpricot.parse(body) : nil
+      end
+      alias :root :parser
+
+      # Get the content type
+      def content_type
+        response['content-type']
+      end
+
+      # Search through the page like HPricot
+      def_delegator :parser, :search, :search
+      def_delegator :parser, :/, :/
+      def_delegator :parser, :at, :at
+
+      # Find a form with +name+.  Form will be yielded if a block is given.
+      def form(name)
+        f = forms.name(name).first
+        yield f if block_given?
+        f
+      end
+    
+      def links
+        @links ||= WWW::Mechanize::List.new(
+          %w{ a area }.map do |tag|
+            search(tag).map do |node|
+              Link.new(node, @mech, self)
+            end
+          end.flatten
+        )
+      end
+
+      def forms
+        @forms ||= WWW::Mechanize::List.new(
+          search('form').map do |html_form|
+            form = Form.new(html_form, @mech, self)
+            form.action ||= @uri
+            form
+          end
+        )
+      end
+
+      def meta
+        @meta ||= WWW::Mechanize::List.new(
+          search('meta').map do |node|
+            next unless node['http-equiv'] && node['content']
+            (equiv, content) = node['http-equiv'], node['content']
+            if equiv && equiv.downcase == 'refresh'
+              if content && content =~ /^\d+\s*;\s*url\s*=\s*'?([^\s']+)/i
+                node['href'] = $1
+                Meta.new(node, @mech, self)
+              end
+            end
+          end.compact
+        )
+      end
+
+      def bases
+        @bases ||= WWW::Mechanize::List.new(
+          search('base').map { |node| Base.new(node, @mech, self) }
+        )
+      end
+
+      def frames
+        @frames ||= WWW::Mechanize::List.new(
+          search('frame').map { |node| Frame.new(node, @mech, self) }
+        )
+      end
+
+      def iframes
+        @iframes ||= WWW::Mechanize::List.new(
+          search('iframe').map { |node| Frame.new(node, @mech, self) }
+        )
+      end
+    end
+  end
+end

data/lib/www/mechanize/page/base.rb

@@ -0,0 +1,10 @@
+module WWW
+  class Mechanize
+    class Page < WWW::Mechanize::File
+      # This class encapsulates a Base tag.  Mechanize treats base tags just
+      # like 'a' tags.  Base objects will contain links, but most likely will
+      # have no text.
+      class Base < Link; end
+    end
+  end
+end

data/lib/www/mechanize/page/frame.rb

@@ -0,0 +1,22 @@
+module WWW
+  class Mechanize
+    class Page < WWW::Mechanize::File
+      # This class encapsulates a 'frame' tag.  Frame objects can be treated
+      # just like Link objects.  They contain src, the link they refer to,
+      # name, the name of the frame.  'src' and 'name' are aliased to 'href'
+      # and 'text' respectively so that a Frame object can be treated just
+      # like a Link.
+      class Frame < Link
+        alias :src :href
+        alias :name :text
+
+        def initialize(node, mech, referer)
+          super(node, mech, referer)
+          @node = node
+          @text = node['name']
+          @href = node['src']
+        end
+      end
+    end
+  end
+end

data/lib/www/mechanize/page/link.rb

@@ -0,0 +1,50 @@
+module WWW
+  class Mechanize
+    class Page < WWW::Mechanize::File
+      # This class encapsulates links.  It contains the text and the URI for
+      # 'a' tags parsed out of an HTML page.  If the link contains an image,
+      # the alt text will be used for that image.
+      #
+      # For example, the text for the following links with both be 'Hello World':
+      #
+      # <a href="http://rubyforge.org">Hello World</a>
+      # <a href="http://rubyforge.org"><img src="test.jpg" alt="Hello World"></a>
+      class Link
+        attr_reader :node
+        attr_reader :href
+        attr_reader :text
+        attr_reader :attributes
+        attr_reader :page
+        alias :to_s :text
+        alias :referer :page
+      
+        def initialize(node, mech, page)
+          @node = node
+          @href = node['href'] 
+          @text = node.inner_text
+          @page = page
+          @mech = mech
+          @attributes = node
+
+          # If there is no text, try to find an image and use it's alt text
+          if (@text.nil? || @text.length == 0) && (node/'img').length > 0
+            @text = ''
+            (node/'img').each do |e|
+              @text << ( e['alt'] || '')
+            end
+          end
+
+        end
+
+        def uri
+          URI.parse(@href)
+        end
+
+        # Click on this link
+        def click
+          @mech.click self
+        end
+      end
+    end
+  end
+end

data/lib/www/mechanize/page/meta.rb

@@ -0,0 +1,10 @@
+module WWW
+  class Mechanize
+    class Page < WWW::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; end
+    end
+  end
+end

data/lib/www/mechanize/pluggable_parsers.rb

@@ -0,0 +1,93 @@
+require 'www/mechanize/file'
+require 'www/mechanize/file_saver'
+require 'www/mechanize/page'
+
+module WWW
+  class Mechanize
+    # = Synopsis
+    # This class is used to register and maintain pluggable parsers for
+    # Mechanize to use.
+    #
+    # A Pluggable Parser is a parser that Mechanize uses for any particular
+    # content type.  Mechanize will ask PluggableParser for the class it
+    # should initialize given any content type.  This class allows users to
+    # register their own pluggable parsers, or modify existing pluggable
+    # parsers.
+    #
+    # PluggableParser returns a WWW::Mechanize::File object for content types
+    # that it does not know how to handle.  WWW::Mechanize::File provides
+    # basic functionality for any content type, so it is a good class to
+    # extend when building your own parsers.
+    # == Example
+    # To create your own parser, just create a class that takes four
+    # parameters in the constructor.  Here is an example of registering
+    # a pluggable parser that handles CSV files:
+    #  class CSVParser < WWW::Mechanize::File
+    #    attr_reader :csv
+    #    def initialize(uri=nil, response=nil, body=nil, code=nil)
+    #      super(uri, response, body, code)
+    #      @csv = CSV.parse(body)
+    #    end
+    #  end
+    #  agent = WWW::Mechanize.new
+    #  agent.pluggable_parser.csv = CSVParser
+    #  agent.get('http://example.com/test.csv')  # => CSVParser
+    # Now any page that returns the content type of 'text/csv' will initialize
+    # a CSVParser and return that object to the caller.
+    #
+    # To register a pluggable parser for a content type that pluggable parser
+    # does not know about, just use the hash syntax:
+    #  agent.pluggable_parser['text/something'] = SomeClass
+    # 
+    # To set the default parser, just use the 'defaut' method:
+    #  agent.pluggable_parser.default = SomeClass
+    # Now all unknown content types will be instances of SomeClass.
+    class PluggableParser
+      CONTENT_TYPES = {
+        :html => 'text/html',
+        :pdf  => 'application/pdf',
+        :csv  => 'text/csv',
+        :xml  => 'text/xml',
+      }
+
+      attr_accessor :default
+
+      def initialize
+        @parsers = { CONTENT_TYPES[:html] => Page }
+        @default = File
+      end
+
+      def parser(content_type)
+        content_type.nil? ? default : @parsers[content_type] || default
+      end
+
+      def register_parser(content_type, klass)
+        @parsers[content_type] = klass
+      end
+
+      def html=(klass)
+        register_parser(CONTENT_TYPES[:html], klass)
+      end
+
+      def pdf=(klass)
+        register_parser(CONTENT_TYPES[:pdf], klass)
+      end
+
+      def csv=(klass)
+        register_parser(CONTENT_TYPES[:csv], klass)
+      end
+
+      def xml=(klass)
+        register_parser(CONTENT_TYPES[:xml], klass)
+      end
+
+      def [](content_type)
+        @parsers[content_type]
+      end
+
+      def []=(content_type, klass)
+        @parsers[content_type] = klass
+      end
+    end
+  end
+end

data/lib/{mechanize/errors.rb → www/mechanize/response_code_error.rb}

@@ -1,18 +1,5 @@
 module WWW
   class Mechanize
-    # =Synopsis
-    # This class contains an error for when a pluggable parser tries to
-    # parse a content type that it does not know how to handle.  For example
-    # if WWW::Mechanize::Page were to try to parse a PDF, a ContentTypeError
-    # would be thrown.
-    class ContentTypeError < RuntimeError
-      attr_reader :content_type
-    
-      def initialize(content_type)
-        @content_type = content_type
-      end
-    end
-
     # =Synopsis
     # This error is thrown when Mechanize encounters a response code it does
     # not know how to handle.  Currently, this exception will be thrown
@@ -35,3 +22,4 @@ module WWW
     end
   end
 end
+

data/test/{test_includes.rb → helper.rb}

@@ -1,15 +1,12 @@
-require 'net/http'
-require 'test_servlets'
+require 'test/unit'
+require 'rubygems'
+require 'mechanize'
 require 'webrick/httputils'
+require 'servlets'
 
 BASE_DIR = File.dirname(__FILE__)
 
 class Net::HTTP
-  #def self.new(*args)
-  #  obj = allocate
-  #  return obj
-  #end
-
   alias :old_do_start :do_start
 
   def do_start
@@ -108,14 +105,3 @@ class Response
     yield body
   end
 end
-
-
-module TestMethods
-  PORT      = 2000
-  PROXYPORT = 2001
-  SSLPORT   = 2002
-
-  def html_response
-    { 'content-type' => 'text/html' }
-  end
-end

data/test/tc_authenticate.rb

@@ -1,13 +1,6 @@
-$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
-
-require 'test/unit'
-require 'rubygems'
-require 'mechanize'
-require 'test_includes'
+require File.dirname(__FILE__) + "/helper"
 
 class BasicAuthTest < Test::Unit::TestCase
-  include TestMethods
-
   def setup
     @agent = WWW::Mechanize.new
   end

data/test/tc_bad_links.rb

@@ -1,16 +1,9 @@
-$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
-
-require 'test/unit'
-require 'rubygems'
-require 'mechanize'
-require 'test_includes'
+require File.dirname(__FILE__) + "/helper"
 
 class TestBadLinks < Test::Unit::TestCase
-  include TestMethods
-
   def setup
     @agent = WWW::Mechanize.new
-    @page = @agent.get("http://localhost:#{PORT}/tc_bad_links.html")
+    @page = @agent.get("http://localhost/tc_bad_links.html")
   end
 
   def test_space_in_link
@@ -24,7 +17,7 @@ class TestBadLinks < Test::Unit::TestCase
   def test_space_in_url
     page = nil
     assert_nothing_raised do
-      page = @agent.get("http://localhost:#{PORT}/tc_bad_links.html ")
+      page = @agent.get("http://localhost/tc_bad_links.html ")
     end
     assert_match(/tc_bad_links.html$/, @agent.history.last.uri.to_s)
     assert_equal(2, @agent.history.length)

data/test/tc_blank_form.rb

@@ -1,13 +1,6 @@
-$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
-
-require 'test/unit'
-require 'rubygems'
-require 'mechanize'
-require 'test_includes'
+require File.dirname(__FILE__) + "/helper"
 
 class BlankFormTest < Test::Unit::TestCase
-  include TestMethods
-
   def setup
     @agent = WWW::Mechanize.new
   end

data/test/tc_checkboxes.rb

@@ -1,13 +1,6 @@
-$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
-
-require 'test/unit'
-require 'rubygems'
-require 'mechanize'
-require 'test_includes'
+require File.dirname(__FILE__) + "/helper"
 
 class TestCheckBoxes < Test::Unit::TestCase
-  include TestMethods
-
   def setup
     @agent = WWW::Mechanize.new
     @page = @agent.get('http://localhost/tc_checkboxes.html')