kitamomonga-mechanize 0.9.3.20090724215219

data/lib/mechanize/monkey_patch.rb

@@ -0,0 +1,35 @@
+module Net
+  class HTTP
+    alias :old_keep_alive? :keep_alive?
+    def keep_alive?(req, res)
+      return false if /close/i =~ req['connection'].to_s
+      return false if @seems_1_0_server
+      return false if /close/i      =~ res['connection'].to_s
+      return true  if /keep-alive/i =~ res['connection'].to_s
+      return false if /close/i      =~ res['proxy-connection'].to_s
+      return true  if /keep-alive/i =~ res['proxy-connection'].to_s
+      (@curr_http_version == '1.1')
+    end
+  end
+end
+
+# Monkey patch for ruby 1.8.4
+unless RUBY_VERSION > "1.8.4"
+  module Net # :nodoc:
+    class HTTPResponse # :nodoc:
+      CODE_TO_OBJ['500'] = HTTPInternalServerError
+    end
+  end
+else
+  class Mechanize
+    class Form
+      alias :inspect  :pretty_inspect
+    end
+    class Page
+      alias :inspect  :pretty_inspect
+      class Link
+        alias :inspect  :pretty_inspect
+      end
+    end
+  end
+end

data/lib/mechanize/page.rb

@@ -0,0 +1,279 @@
+require 'mechanize/page/link'
+require 'mechanize/page/meta'
+require 'mechanize/page/base'
+require 'mechanize/page/frame'
+require 'mechanize/headers'
+require 'mechanize/page/encoding'
+
+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 = Mechanize.new
+  #  agent.get('http://google.com/').class  #=> Mechanize::Page
+  #
+  class Page < Mechanize::File
+    extend Forwardable
+    include PageEncoding
+
+    attr_accessor :mech
+
+    def initialize(uri=nil, response=nil, body=nil, code=nil, mech=nil)
+
+      # Force the encoding to be 8BIT so we can perform regular expressions.
+      # We'll set it to the detected encoding later
+      body.force_encoding('ASCII-8BIT') if defined?(Encoding) && body
+
+      super(uri, response, body, code, mech)
+      @mech ||= mech
+
+      raise Mechanize::ContentTypeError.new(response['content-type']) unless
+        response['content-type'] =~ /^(text\/html)|(application\/xhtml\+xml)/i
+
+      reset_parser
+      after_page_chain.handle(self)
+    end
+
+    def after_page_chain
+      chain = [page_encoding_hook]
+      chain << @mech.post_page_hook if @mech
+      Chain.new(chain)
+    end
+
+    def reset_parser
+      @parser = nil
+      @links = @forms = @meta = @bases = @frames = @iframes = nil
+      @title = nil
+      @http_encoding = @meta_encoding = nil
+    end
+
+    def title
+      @title ||= if parser && search('title').inner_text.length > 0
+                   search('title').inner_text
+                 end
+    end
+
+    def parser
+      return @parser if @parser
+
+      if body && response
+        if mech.html_parser == Nokogiri::HTML
+          mech.log.debug("parser: using external encoding #{@encoding}") if mech.log && @encoding
+          @parser = mech.html_parser.parse(html_body, nil, @encoding)
+        else
+          @parser = mech.html_parser.parse(html_body)
+        end
+      end
+
+      @parser
+    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
+
+    #     # types_with generator. run me on irb
+    #
+    #     [:form, :link, :base, :frame, :iframe].each do |type|
+    #       puts(<<-eomethod)
+    #           def #{type}s_with(criteria)
+    #             criteria = {:name => criteria} if String === criteria
+    #             f = #{type}s.find_all do |thing|
+    #               criteria.all? { |k,v|
+    #               case k
+    #               when :class then v === thing.attribute_class
+    #               when :id    then v === thing.attribute_id
+    #               else             v === thing.__send__(k)
+    #               end }
+    #             end
+    #             yield f if block_given?
+    #             f
+    #           end
+    #
+    #           def #{type}_with(criteria)
+    #             f = #{type}s_with(criteria).first
+    #             yield f if block_given?
+    #             f
+    #           end
+    #           alias :#{type} :#{type}_with
+    #
+    #           eomethod
+    #         end
+
+    # don't modify by hand start >>>
+
+    def forms_with(criteria)
+      criteria = {:name => criteria} if String === criteria
+      f = forms.find_all do |thing|
+        criteria.all? { |k,v|
+          case k
+          when :class then v === thing.attribute_class
+          when :id    then v === thing.attribute_id
+          else             v === thing.__send__(k)
+          end }
+      end
+      yield f if block_given?
+      f
+    end
+
+    def form_with(criteria)
+      f = forms_with(criteria).first
+      yield f if block_given?
+      f
+    end
+    alias :form :form_with
+
+    def links_with(criteria)
+      criteria = {:name => criteria} if String === criteria
+      f = links.find_all do |thing|
+        criteria.all? { |k,v|
+          case k
+          when :class then v === thing.attribute_class
+          when :id    then v === thing.attribute_id
+          else             v === thing.__send__(k)
+          end }
+      end
+      yield f if block_given?
+      f
+    end
+
+    def link_with(criteria)
+      f = links_with(criteria).first
+      yield f if block_given?
+      f
+    end
+    alias :link :link_with
+
+    def bases_with(criteria)
+      criteria = {:name => criteria} if String === criteria
+      f = bases.find_all do |thing|
+        criteria.all? { |k,v|
+          case k
+          when :class then v === thing.attribute_class
+          when :id    then v === thing.attribute_id
+          else             v === thing.__send__(k)
+          end }
+      end
+      yield f if block_given?
+      f
+    end
+
+    def base_with(criteria)
+      f = bases_with(criteria).first
+      yield f if block_given?
+      f
+    end
+    alias :base :base_with
+
+    def frames_with(criteria)
+      criteria = {:name => criteria} if String === criteria
+      f = frames.find_all do |thing|
+        criteria.all? { |k,v|
+          case k
+          when :class then v === thing.attribute_class
+          when :id    then v === thing.attribute_id
+          else             v === thing.__send__(k)
+          end }
+      end
+      yield f if block_given?
+      f
+    end
+
+    def frame_with(criteria)
+      f = frames_with(criteria).first
+      yield f if block_given?
+      f
+    end
+    alias :frame :frame_with
+
+    def iframes_with(criteria)
+      criteria = {:name => criteria} if String === criteria
+      f = iframes.find_all do |thing|
+        criteria.all? { |k,v|
+          case k
+          when :class then v === thing.attribute_class
+          when :id    then v === thing.attribute_id
+          else             v === thing.__send__(k)
+          end }
+      end
+      yield f if block_given?
+      f
+    end
+
+    def iframe_with(criteria)
+      f = iframes_with(criteria).first
+      yield f if block_given?
+      f
+    end
+    alias :iframe :iframe_with
+
+    # don't modify by hand end <<<
+
+    def links
+      @links ||= %w{ a area }.map do |tag|
+        search(tag).map do |node|
+          Link.new(node, @mech, self)
+        end
+      end.flatten
+    end
+
+    def forms
+      @forms ||= search('form').map do |html_form|
+        form = Form.new(html_form, @mech, self)
+        form.action ||= @uri.to_s
+        form
+      end
+    end
+
+    def meta
+      @meta ||= search('meta').map do |node|
+        next unless node['http-equiv'] && node['content']
+        (equiv, content) = node['http-equiv'], node['content']
+        if equiv && equiv.downcase == 'refresh'
+          Meta.parse(content, uri) do |delay, href|
+            node['delay'] = delay
+            node['href'] = href
+            Meta.new(node, @mech, self)
+          end
+        end
+      end.compact
+    end
+
+    def bases
+      @bases ||=
+        search('base').map { |node| Base.new(node, @mech, self) }
+    end
+
+    def frames
+      @frames ||=
+        search('frame').map { |node| Frame.new(node, @mech, self) }
+    end
+
+    def iframes
+      @iframes ||=
+        search('iframe').map { |node| Frame.new(node, @mech, self) }
+    end
+
+    private
+
+    def html_body
+      if body
+        body.length > 0 ? body : '<html></html>'
+      else
+        ''
+      end
+    end
+  end
+end

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/encoding.rb

@@ -0,0 +1,61 @@
+class Mechanize
+  module PageEncoding
+
+    def encoding=(encoding)
+      @encoding = encoding
+
+      if @parser
+        parser_encoding = @parser.encoding
+        if (parser_encoding && parser_encoding.downcase) != (encoding && encoding.downcase)
+          # lazy reinitialize the parser with the new encoding
+        reset_parser
+        end
+      end
+
+      encoding
+    end
+
+    def encoding
+      parser.respond_to?(:encoding) ? parser.encoding : nil
+    end
+
+    def http_charset
+      unless @http_encoding
+        method = response.respond_to?(:each_header) ? :each_header : :each
+        response.send(method) do |header,v|
+          next unless v =~ /charset/i
+          encoding = v.split('=').last.strip
+          @http_encoding = encoding unless encoding == 'none'
+        end
+      end
+      @http_encoding
+    end
+    alias :http_encoding :http_charset
+
+    def meta_charset
+      @meta_encoding ||= parser.meta_encoding rescue nil
+    end
+    alias :meta_encoding :meta_charset
+
+    def body_charset
+      @body_encoding ||= Util.detect_charset(html_body)
+    end
+    alias :body_encoding :body_charset
+
+    def default_encoding
+      # If body has <meta> charset, we lely on Nokogiri's auto detection of encoding for the moment
+      # If no <meta>, Nokogiri would need encoding argument for the correct parsing
+      body_has_meta_charset? ? nil : http_encoding || body_encoding
+    end
+
+    def body_has_meta_charset?
+      html_body =~ /<meta[^>]*charset[^>]*>/i
+    end
+
+    def page_encoding_hook
+      # "@encoding" means "encoding for Nokogiri parsing"
+      Chain::PostPageHook.new([lambda{|page| @encoding = default_encoding}])
+    end
+
+  end
+end

data/lib/mechanize/page/frame.rb

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

data/lib/mechanize/page/link.rb

@@ -0,0 +1,53 @@
+class Mechanize
+  class Page < 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.search('img').length > 0
+          @text = ''
+          node.search('img').each do |e|
+            @text << ( e['alt'] || '')
+          end
+        end
+
+      end
+
+      # Returns class attribute (<a class="***"> of ***). If no class, returns nil.
+      def attribute_class; node['class']; end
+      # Returns id attribute (<a id="***"> of ***). If no id, returns nil.
+      def attribute_id; node['id']; end
+
+      def uri
+        @href && URI.parse(@href)
+      end
+
+      # Click on this link
+      def click
+        @mech.click self
+      end
+    end
+  end
+end