aai10-mechanize 2.0.1.0

data/lib/mechanize/page/base.rb

@@ -0,0 +1,8 @@
+class Mechanize
+  class Page < 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

data/lib/mechanize/page/frame.rb

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

data/lib/mechanize/page/image.rb

@@ -0,0 +1,30 @@
+class Mechanize
+  class Page < Mechanize::File
+    class Image
+      attr_reader :node
+      attr_reader :page
+
+      def initialize(node, page)
+        @node = node
+        @page = page
+      end
+
+      def src
+        @node['src']
+      end
+
+      def url
+        case src
+        when %r{^https?://}
+          src
+        else 
+          if page.bases[0]
+            (page.bases[0].href + src).to_s
+          else
+            (page.uri + src).to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mechanize/page/label.rb

@@ -0,0 +1,20 @@
+class Mechanize
+  class Page < Mechanize::File
+    class Label
+      attr_reader :node
+      attr_reader :text
+      attr_reader :page
+      alias :to_s :text
+
+      def initialize(node, page)
+        @node = node
+        @text = node.inner_text
+        @page = page
+      end
+
+      def for
+        (id = @node['for']) && page.search("##{id}") || nil
+      end
+    end
+  end
+end

data/lib/mechanize/page/link.rb

@@ -0,0 +1,82 @@
+##
+# 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://example">Hello World</a>
+#   <a href="http://example"><img src="test.jpg" alt="Hello World"></a>
+
+class Mechanize::Page::Link
+  attr_reader :node
+  attr_reader :href
+  attr_reader :attributes
+  attr_reader :page
+  alias :referer :page
+
+  def initialize(node, mech, page)
+    @node       = node
+    @attributes = node
+    @href       = node['href']
+    @mech       = mech
+    @page       = page
+    @text       = nil
+    @uri        = nil
+  end
+
+  # Click on this link
+  def click
+    @mech.click self
+  end
+
+  # This method is a shorthand to get link's DOM id.
+  # Common usage:
+  #   page.link_with(:dom_id => "links_exact_id")
+  def dom_id
+    node['id']
+  end
+
+  # A list of words in the rel attribute, all lower-cased.
+  def rel
+    @rel ||= (val = attributes['rel']) ? val.downcase.split(' ') : []
+  end
+
+  # Test if the rel attribute includes +kind+.
+  def rel? kind
+    rel.include? kind
+  end
+
+  # The text content of this link
+  def text
+    return @text if @text
+
+    @text = @node.inner_text
+
+    # If there is no text, try to find an image and use it's alt text
+    if (@text.nil? or @text.empty?) and imgs = @node.search('img') then
+      @text = imgs.map do |e|
+        e['alt']
+      end.join
+    end
+
+    @text
+  end
+
+  alias :to_s :text
+
+  # A URI for the #href for this link.  The link is first parsed as a raw
+  # link.  If that fails parsing an escaped link is attepmted.
+
+  def uri
+    @uri ||= if @href then
+               begin
+                 URI.parse @href
+               rescue URI::InvalidURIError
+                 URI.parse WEBrick::HTTPUtils.escape @href
+               end
+             end
+  end
+
+end
+

data/lib/mechanize/page/meta_refresh.rb

@@ -0,0 +1,56 @@
+##
+# This class encapsulates a meta element with a refresh http-equiv.  Mechanize
+# treats meta refresh elements just like 'a' tags.  MetaRefresh objects will
+# contain links, but most likely will have no text.
+
+class Mechanize::Page::MetaRefresh < Mechanize::Page::Link
+
+  attr_reader :delay
+
+  ##
+  # Matches the content attribute of a meta refresh element.  After the match:
+  #
+  #   $1:: delay
+  #   $3:: url
+  CONTENT_REGEXP = /^\s*(\d+\.?\d*)(;|;\s*url=\s*['"]?(\S*?)['"]?)?\s*$/i
+
+  ##
+  # Parses the delay and url from the content attribute of a meta refresh
+  # element.  Parse requires the uri of the current page to infer a url when
+  # no url is specified.
+  #
+  # Returns a MetaRefresh instance.
+  #
+  # Returns nil if the delay and url cannot be parsed.
+
+  def self.parse content, base_uri
+    return unless content =~ CONTENT_REGEXP
+
+    delay, refresh_uri = $1, $3
+
+    dest = base_uri
+    dest += refresh_uri if refresh_uri
+
+    return delay, dest
+  end
+
+  def self.from_node node, page, uri
+    http_equiv = node['http-equiv']
+    return unless http_equiv and http_equiv.downcase == 'refresh'
+
+    delay, uri = parse node['content'], uri
+
+    return unless delay
+
+    new node, page, delay, uri.to_s
+  end
+
+  def initialize node, page, delay, href
+    super node, page.mech, page
+
+    @delay = delay.to_i
+    @href  = href
+  end
+
+end
+

data/lib/mechanize/pluggable_parsers.rb

@@ -0,0 +1,101 @@
+require 'mechanize/file'
+require 'mechanize/file_saver'
+require 'mechanize/page'
+
+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 Mechanize::File object for content types
+  # that it does not know how to handle.  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 < 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 = 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',
+      :wap  => 'application/vnd.wap.xhtml+xml',
+      :xhtml => 'application/xhtml+xml',
+      :pdf  => 'application/pdf',
+      :csv  => 'text/csv',
+      :xml  => 'text/xml',
+    }
+
+    attr_accessor :default
+
+    def initialize
+      @parsers = { CONTENT_TYPES[:html]   => Page,
+        CONTENT_TYPES[:xhtml]  => Page,
+        CONTENT_TYPES[:wap]    => 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)
+      register_parser(CONTENT_TYPES[:xhtml], klass)
+    end
+
+    def xhtml=(klass)
+      register_parser(CONTENT_TYPES[:xhtml], 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

data/lib/mechanize/redirect_limit_reached_error.rb

@@ -0,0 +1,16 @@
+class Mechanize
+  # Thrown when too many redirects are sent
+  class RedirectLimitReachedError < Mechanize::Error
+    attr_reader :page, :response_code, :redirects
+    def initialize(page, redirects)
+      @page           = page
+      @redirects      = redirects
+      @response_code  = page.code
+    end
+
+    def to_s
+      "Maximum redirect limit (#{redirects}) reached"
+    end
+    alias :inspect :to_s
+  end
+end

data/lib/mechanize/redirect_not_get_or_head_error.rb

@@ -0,0 +1,19 @@
+class Mechanize
+  # Thrown when a POST, PUT, or DELETE request results in a redirect
+  # see RFC 2616 10.3.2, 10.3.3 http://www.ietf.org/rfc/rfc2616.txt
+  class RedirectNotGetOrHeadError < Mechanize::Error
+    attr_reader :page, :response_code, :verb, :uri
+    def initialize(page, verb)
+      @page           = page
+      @verb           = verb
+      @uri            = page.uri
+      @response_code  = page.code
+    end
+
+    def to_s
+      method = @verb.to_s.upcase
+      "#{@response_code} redirect received after a #{method} request"
+    end
+    alias :inspect :to_s
+  end
+end

data/lib/mechanize/response_code_error.rb

@@ -0,0 +1,22 @@
+class Mechanize
+  # =Synopsis
+  # This error is thrown when Mechanize encounters a response code it does
+  # not know how to handle.  Currently, this exception will be thrown
+  # if Mechanize encounters response codes other than 200, 301, or 302.
+  # Any other response code is up to the user to handle.
+  class ResponseCodeError < Mechanize::Error
+    attr_reader :response_code
+    attr_reader :page
+
+    def initialize(page)
+      @page          = page
+      @response_code = page.code.to_s
+    end
+
+    def to_s
+      "#{@response_code} => #{Net::HTTPResponse::CODE_TO_OBJ[@response_code]}"
+    end
+
+    def inspect; to_s; end
+  end
+end

data/lib/mechanize/response_read_error.rb

@@ -0,0 +1,27 @@
+##
+# Raised when Mechanize encounters an error while reading the response body
+# from the server.  Contains the response headers and the response body up to
+# the error along with the initial error.
+
+class Mechanize::ResponseReadError < Mechanize::Error
+
+  attr_reader :body_io
+  attr_reader :error
+  attr_reader :response
+
+  ##
+  # Creates a new ResponseReadError with the +error+ raised, the +response+
+  # and the +body_io+ for content read so far.
+
+  def initialize error, response, body_io
+    @error = error
+    @response = response
+    @body_io = body_io
+  end
+
+  def message # :nodoc:
+    "#{@error.message} (#{self.class})"
+  end
+
+end
+

data/lib/mechanize/robots_disallowed_error.rb

@@ -0,0 +1,29 @@
+class Mechanize
+  # Exception that is raised when an access to a resource is
+  # disallowed by robots.txt or by HTML document itself.
+  class RobotsDisallowedError < Mechanize::Error
+    def initialize(url)
+      if url.is_a?(URI)
+        @url = url.to_s
+        @uri = url
+      else
+        @url = url.to_s
+      end
+    end
+
+    # Returns the URL (string) of the resource that caused this error.
+    attr_reader :url
+
+    # Returns the URL (URI object) of the resource that caused this
+    # error.  URI::InvalidURIError may be raised if the URL happens to
+    # be invalid or not understood by the URI library.
+    def uri
+      @uri ||= URI.parse(url)
+    end
+
+    def to_s
+      "Robots access is disallowed for URL: #{url}"
+    end
+    alias :inspect :to_s
+  end
+end