mechanize 2.0.1 → 2.1.pre.1

data/lib/mechanize/page.rb

@@ -125,6 +125,37 @@ class Mechanize::Page < Mechanize::File
 
   alias :root :parser
 
+  def pretty_print(q) # :nodoc:
+    q.object_group(self) {
+      q.breakable
+      q.group(1, '{url', '}') {q.breakable; q.pp uri }
+      q.breakable
+      q.group(1, '{meta_refresh', '}') {
+        meta_refresh.each { |link| q.breakable; q.pp link }
+      }
+      q.breakable
+      q.group(1, '{title', '}') { q.breakable; q.pp title }
+      q.breakable
+      q.group(1, '{iframes', '}') {
+        iframes.each { |link| q.breakable; q.pp link }
+      }
+      q.breakable
+      q.group(1, '{frames', '}') {
+        frames.each { |link| q.breakable; q.pp link }
+      }
+      q.breakable
+      q.group(1, '{links', '}') {
+        links.each { |link| q.breakable; q.pp link }
+      }
+      q.breakable
+      q.group(1, '{forms', '}') {
+        forms.each { |form| q.breakable; q.pp form }
+      }
+    }
+  end
+
+  alias inspect pretty_inspect # :nodoc:
+
   def reset
     @bases = nil
     @forms = nil
@@ -342,6 +373,7 @@ class Mechanize::Page < Mechanize::File
   def self.response_header_charset response
     charsets = []
     response.each do |header, value|
+      next unless header == 'content-type'
       next unless value =~ /charset/i
       charsets << charset(value)
     end
@@ -357,9 +389,9 @@ class Mechanize::Page < Mechanize::File
       if meta =~ /charset\s*=\s*(["'])?\s*(.+)\s*\1/i then
         $2
       elsif meta =~ /http-equiv\s*=\s*(["'])?content-type\1/i then
-        meta =~ /content=(["'])?(.*?)\1/i
+        meta =~ /content\s*=\s*(["'])?(.*?)\1/i
 
-        m_charset = charset $2
+        m_charset = charset $2 if $2
 
         m_charset if m_charset
       end

data/lib/mechanize/page/base.rb

@@ -1,8 +1,7 @@
-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
+##
+# A base element on an HTML page.  Mechanize treats base tags just like 'a'
+# tags.  Base objects will contain links, but most likely will have no text.
+
+class Mechanize::Page::Base < Mechanize::Page::Link
 end
+

data/lib/mechanize/page/frame.rb

@@ -1,8 +1,8 @@
-# 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.
+# A Frame object wrapse a frame HTML element.  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
 

data/lib/mechanize/page/image.rb

@@ -1,30 +1,30 @@
-class Mechanize
-  class Page < Mechanize::File
-    class Image
-      attr_reader :node
-      attr_reader :page
+##
+# An image element on an HTML page
 
-      def initialize(node, page)
-        @node = node
-        @page = page
-      end
+class Mechanize::Page::Image
+  attr_reader :node
+  attr_reader :page
 
-      def src
-        @node['src']
-      end
+  def initialize(node, page)
+    @node = node
+    @page = page
+  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
+  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
+

data/lib/mechanize/page/label.rb

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

data/lib/mechanize/page/link.rb

@@ -37,6 +37,22 @@ class Mechanize::Page::Link
     node['id']
   end
 
+  # This method is a shorthand to get a link's DOM class
+  # Common usage:
+  #   page.link_with(:dom_class => "links_exact_class")
+  def dom_class
+    node['class']
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.object_group(self) {
+      q.breakable; q.pp text
+      q.breakable; q.pp href
+    }
+  end
+
+  alias inspect pretty_inspect # :nodoc:
+
   # A list of words in the rel attribute, all lower-cased.
   def rel
     @rel ||= (val = attributes['rel']) ? val.downcase.split(' ') : []

data/lib/mechanize/page/meta_refresh.rb

@@ -5,13 +5,23 @@
 
 class Mechanize::Page::MetaRefresh < Mechanize::Page::Link
 
+  ##
+  # Time to wait before next refresh
+
   attr_reader :delay
 
+  ##
+  # This MetaRefresh links did not contain a url= in the content attribute and
+  # links to itself.
+
+  attr_reader :link_self
+
   ##
   # 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
 
   ##
@@ -19,37 +29,39 @@ class Mechanize::Page::MetaRefresh < Mechanize::Page::Link
   # element.  Parse requires the uri of the current page to infer a url when
   # no url is specified.
   #
-  # Returns a MetaRefresh instance.
+  # Returns an array of [delay, url]. (both in string)
   #
   # Returns nil if the delay and url cannot be parsed.
 
   def self.parse content, base_uri
     return unless content =~ CONTENT_REGEXP
 
+    link_self = $3.nil? || $3.empty?
     delay, refresh_uri = $1, $3
 
     dest = base_uri
     dest += refresh_uri if refresh_uri
 
-    return delay, dest
+    return delay, dest, link_self
   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
+    delay, uri, link_self = parse node['content'], uri
 
     return unless delay
 
-    new node, page, delay, uri.to_s
+    new node, page, delay, uri.to_s, link_self
   end
 
-  def initialize node, page, delay, href
+  def initialize node, page, delay, href, link_self = false
     super node, page.mech, page
 
-    @delay = delay.to_i
-    @href  = href
+    @delay     = delay =~ /\./ ? delay.to_f : delay.to_i
+    @href      = href
+    @link_self = link_self
   end
 
 end

data/lib/mechanize/parser.rb

@@ -0,0 +1,173 @@
+##
+# The parser module provides standard methods for accessing the headers and
+# content of a response that are shared across pluggable parsers.
+
+module Mechanize::Parser
+
+  extend Forwardable
+
+  special_filenames = Regexp.union %w[
+    AUX
+    COM1
+    COM2
+    COM3
+    COM4
+    COM5
+    COM6
+    COM7
+    COM8
+    COM9
+    CON
+    LPT1
+    LPT2
+    LPT3
+    LPT4
+    LPT5
+    LPT6
+    LPT7
+    LPT8
+    LPT9
+    NUL
+    PRN
+  ]
+
+  ##
+  # Special filenames that must be escaped
+
+  SPECIAL_FILENAMES = /\A#{special_filenames}/i
+
+  ##
+  # The URI this file was retrieved from
+
+  attr_accessor :uri
+
+  ##
+  # The Mechanize::Headers for this file
+
+  attr_accessor :response
+
+  alias header response
+
+  ##
+  # The HTTP response code
+
+  attr_accessor :code
+
+  ##
+  # :method: [](header)
+  #
+  # Access HTTP +header+ by name
+
+  def_delegator :header, :[], :[]
+
+  ##
+  # :method: []=(header, value)
+  #
+  # Set HTTP +header+ to +value+
+
+  def_delegator :header, :[]=, :[]=
+
+  ##
+  # :method: key?(header)
+  #
+  # Is the named +header+ present?
+
+  def_delegator :header, :key?, :key?
+
+  ##
+  # :method: each
+  #
+  # Enumerate HTTP headers
+
+  def_delegator :header, :each, :each
+
+  ##
+  # :method: each
+  #
+  # Enumerate HTTP headers in capitalized (canonical) form
+
+  def_delegator :header, :canonical_each, :canonical_each
+
+  ##
+  # Extracts the filename from a Content-Disposition header in the #response
+  # or from the URI.  If +full_path+ is true the filename will include the
+  # host name and path to the resource, otherwise a filename in the current
+  # directory is given.
+
+  def extract_filename full_path = @full_path
+    handled = false
+
+    if @uri then
+      uri = @uri
+      uri += 'index.html' if uri.path.end_with? '/'
+
+      path     = uri.path.split(/\//)
+      filename = path.pop || 'index.html'
+    else
+      path     = []
+      filename = 'index.html'
+    end
+
+    # Set the filename
+    if disposition = @response['content-disposition'] then
+      content_disposition =
+        Mechanize::HTTP::ContentDispositionParser.parse disposition
+
+      if content_disposition then
+        filename = content_disposition.filename
+        filename = filename.split(/[\\\/]/).last
+        handled = true
+      end
+    end
+
+    if not handled and @uri then
+      filename << '.html' unless filename =~ /\./
+      filename << "?#{@uri.query}" if @uri.query
+    end
+
+    if SPECIAL_FILENAMES =~ filename then
+      filename = "_#{filename}"
+    end
+
+    filename = filename.tr "\x00-\x20<>:\"/\\|?*", '_'
+
+    @filename = if full_path then
+                  File.join @uri.host, path, filename
+                else
+                  filename
+                end
+  end
+
+  ##
+  # Creates a Mechanize::Header from the Net::HTTPResponse +response+.
+  #
+  # This allows the Net::HTTPResponse to be garbage collected sooner.
+
+  def fill_header response
+    @response = Mechanize::Headers.new
+
+    response.each { |k,v|
+      @response[k] = v
+    } if response
+
+    @response
+  end
+
+  ##
+  # Finds a free filename based on +filename+, but is not race-free
+
+  def find_free_name filename
+    filename = @filename unless filename
+
+    number = 1
+
+    while File.exist? filename do
+      filename = "#{@filename}.#{number}"
+      number += 1
+    end
+
+    filename
+  end
+
+end
+