domo 0.0.3 → 0.0.4

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/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/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/lib/mechanize/page.rb

@@ -0,0 +1,300 @@
+require 'mechanize/page/link'
+require 'mechanize/page/meta'
+require 'mechanize/page/base'
+require 'mechanize/page/frame'
+require 'mechanize/page/image'
+require 'mechanize/page/label'
+require 'mechanize/headers'
+
+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
+
+    attr_accessor :mech
+
+    def initialize(uri=nil, response=nil, body=nil, code=nil, mech=nil)
+      @encoding = nil
+
+      method = response.respond_to?(:each_header) ? :each_header : :each
+      response.send(method) do |header,v|
+        next unless v =~ /charset/i
+        encoding = v[/charset=([^; ]+)/, 1]
+        @encoding = encoding unless encoding == 'none'
+      end
+
+      # 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 body && body.respond_to?(:force_encoding)
+
+      @encoding ||= Util.detect_charset(body)
+
+      super(uri, response, body, code)
+      @mech           ||= mech
+
+      @encoding = nil if html_body =~ /<meta[^>]*charset[^>]*>/i
+
+      raise Mechanize::ContentTypeError.new(response['content-type']) unless
+        response['content-type'] =~ /^(text\/html)|(application\/xhtml\+xml)/i
+      @parser = @links = @forms = @meta = @bases = @frames = @iframes = nil
+    end
+
+    def title
+      @title ||= if parser && search('title').inner_text.length > 0
+                   search('title').inner_text
+                 end
+    end
+
+    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
+          @parser = nil
+        end
+      end
+
+      encoding
+    end
+
+    def encoding
+      parser.respond_to?(:encoding) ? parser.encoding : nil
+    end
+
+    def parser
+      return @parser if @parser
+
+      if body && response
+        if mech.html_parser == Nokogiri::HTML
+          @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
+
+    ##
+    # :method: form_with(criteria)
+    #
+    # Find a single form matching +criteria+.
+    # Example:
+    #   page.form_with(:action => '/post/login.php') do |f|
+    #     ...
+    #   end
+
+    ##
+    # :method: forms_with(criteria)
+    #
+    # Find all forms form matching +criteria+.
+    # Example:
+    #   page.forms_with(:action => '/post/login.php').each do |f|
+    #     ...
+    #   end
+
+    ##
+    # :method: link_with(criteria)
+    #
+    # Find a single link matching +criteria+.
+    # Example:
+    #   page.link_with(:href => /foo/).click
+
+    ##
+    # :method: links_with(criteria)
+    #
+    # Find all links matching +criteria+.
+    # Example:
+    #   page.links_with(:href => /foo/).each do |link|
+    #     puts link.href
+    #   end
+
+    ##
+    # :method: base_with(criteria)
+    #
+    # Find a single base tag matching +criteria+.
+    # Example:
+    #   page.base_with(:href => /foo/).click
+
+    ##
+    # :method: bases_with(criteria)
+    #
+    # Find all base tags matching +criteria+.
+    # Example:
+    #   page.bases_with(:href => /foo/).each do |base|
+    #     puts base.href
+    #   end
+
+    ##
+    # :method: frame_with(criteria)
+    #
+    # Find a single frame tag matching +criteria+.
+    # Example:
+    #   page.frame_with(:src => /foo/).click
+
+    ##
+    # :method: frames_with(criteria)
+    #
+    # Find all frame tags matching +criteria+.
+    # Example:
+    #   page.frames_with(:src => /foo/).each do |frame|
+    #     p frame.src
+    #   end
+
+    ##
+    # :method: iframe_with(criteria)
+    #
+    # Find a single iframe tag matching +criteria+.
+    # Example:
+    #   page.iframe_with(:src => /foo/).click
+
+    ##
+    # :method: iframes_with(criteria)
+    #
+    # Find all iframe tags matching +criteria+.
+    # Example:
+    #   page.iframes_with(:src => /foo/).each do |iframe|
+    #     p iframe.src
+    #   end
+
+    # let's meta program!
+    [:form, :link, :base, :frame, :iframe].each do |type|
+      eval(<<-eomethod)
+          def #{type}s_with(criteria)
+            criteria = {:name => criteria} if String === criteria
+            f = #{type}s.find_all do |thing|
+              criteria.all? { |k,v| v === thing.send(k) }
+            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
+
+    ##
+    # Return a list of all link and area tags
+    def links
+      @links ||= %w{ a area }.map do |tag|
+        search(tag).map do |node|
+          Link.new(node, @mech, self)
+        end
+      end.flatten
+    end
+
+    ##
+    # Return a list of all form tags
+    def forms
+      @forms ||= search('form').map do |html_form|
+        form = Form.new(html_form, @mech, self)
+        form.action ||= @uri.to_s
+        form
+      end
+    end
+
+    ##
+    # Return a list of all meta tags
+    def meta
+      @meta ||= search('head > 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
+
+    ##
+    # Return a list of all base tags
+    def bases
+      @bases ||=
+        search('base').map { |node| Base.new(node, @mech, self) }
+    end
+
+    ##
+    # Return a list of all frame tags
+    def frames
+      @frames ||=
+        search('frame').map { |node| Frame.new(node, @mech, self) }
+    end
+
+    ##
+    # Return a list of all iframe tags
+    def iframes
+      @iframes ||=
+        search('iframe').map { |node| Frame.new(node, @mech, self) }
+    end
+
+    ##
+    # Return a list of all img tags
+    def images
+      @images ||=
+        search('img').map { |node| Image.new(node, self) }
+    end
+
+    def image_urls
+      @image_urls ||= images.map(&:url).uniq
+    end
+
+    ##
+    # Return a list of all label tags
+    def labels
+      @labels ||=
+        search('label').map { |node| Label.new(node, self) }
+    end
+
+    def labels_hash
+      unless @labels_hash
+        hash = {}
+        labels.each do |label|
+          hash[label.node['for']] = label if label.for
+        end
+        @labels_hash = hash
+      end
+      return @labels_hash
+    end
+
+    private
+
+    def html_body
+      if body
+        body.length > 0 ? body : '<html></html>'
+      else
+        ''
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/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/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/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/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/lib/mechanize/page/image.rb

@@ -0,0 +1,26 @@
+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
+          (page.uri + src).to_s
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/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/vendor/bundle/ruby/1.9.1/gems/mechanize-1.0.0/lib/mechanize/page/link.rb

@@ -0,0 +1,48 @@
+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
+
+      def uri
+        @href && URI.parse(URI.encode(@href))
+      end
+
+      # Click on this link
+      def click
+        @mech.click self
+      end
+    end
+  end
+end