aai10-mechanize 2.0.1.0

data/lib/mechanize/content_type_error.rb

@@ -0,0 +1,14 @@
+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 Mechanize::Page were to try to parse a PDF, a ContentTypeError
+  # would be thrown.
+  class ContentTypeError < Mechanize::Error
+    attr_reader :content_type
+
+    def initialize(content_type)
+      @content_type = content_type
+    end
+  end
+end

data/lib/mechanize/cookie.rb

@@ -0,0 +1,116 @@
+require 'time'
+require 'webrick/cookie'
+
+# This class is used to represent an HTTP Cookie.
+class Mechanize::Cookie < WEBrick::Cookie
+
+  attr_accessor :session
+
+  class << self
+    def parse(uri, str, log = Mechanize.log)
+      return str.split(/,(?=[^;,]*=)|,$/).map { |c|
+        cookie_elem = c.split(/;+/)
+        first_elem = cookie_elem.shift
+        first_elem.strip!
+        key, value = first_elem.split(/\=/, 2)
+
+        cookie = nil
+        begin
+          cookie = new(key, value.dup)
+        rescue
+          log.warn("Couldn't parse key/value: #{first_elem}") if log
+        end
+
+        next unless cookie
+
+        cookie_elem.each do |pair|
+          pair.strip!
+          key, value = pair.split(/\=/, 2)
+          next unless key
+          value = WEBrick::HTTPUtils.dequote(value.strip) if value
+
+          case key.downcase
+          when "domain" then
+            cookie.domain = value
+          when "path" then
+            cookie.path = value
+          when 'expires'
+            if value.empty? then
+              cookie.session = true
+              next
+            end
+
+            begin
+              cookie.expires = Time::parse(value)
+            rescue
+              log.warn("Couldn't parse expires: #{value}") if log
+            end
+          when "max-age" then
+            begin
+              cookie.max_age = Integer(value)
+            rescue
+              log.warn("Couldn't parse max age '#{value}'") if log
+              cookie.max_age = nil
+            end
+          when "comment" then cookie.comment = value
+          when "version" then
+            begin
+              cookie.version = Integer(value)
+            rescue
+              log.warn("Couldn't parse version '#{value}'") if log
+              cookie.version = nil
+            end
+          when "secure"  then cookie.secure = true
+          end
+        end
+
+        cookie.path    ||= (uri + './').path
+        cookie.secure  ||= false
+        cookie.domain  ||= uri.host
+        # Move this in to the cookie jar
+        yield cookie if block_given?
+
+        cookie
+      }
+    end
+
+    def normalize_domain(domain)
+      # RFC 6265 #4.1.2.3
+      return nil if domain.end_with?('.')
+      domain.downcase.tap { |dom|
+        dom.sub!(/:[0-9]+$/,'')
+        dom.sub!(/^\./,'')
+      }
+    end
+  end
+
+  alias set_domain domain=
+  def domain=(domain)
+    set_domain(self.class.normalize_domain(domain))
+  end
+
+  def expired?
+    return false unless expires
+    Time.now > expires
+  end
+
+  alias secure? secure
+
+  def acceptable_from_uri?(uri)
+    dom = domain or return false
+    host = self.class.normalize_domain(uri.host)
+
+    return true if host == dom
+    return false if dom.match(/^(?!local)[^.]+$/)
+    return host.end_with?('.' << dom)
+  end
+
+  def valid_for_uri?(uri)
+    return false if secure? && uri.scheme != 'https'
+    acceptable_from_uri?(uri) && uri.path.start_with?(path)
+  end
+
+  def to_s
+    "#{@name}=#{@value}"
+  end
+end

data/lib/mechanize/cookie_jar.rb

@@ -0,0 +1,202 @@
+##
+# This class is used to manage the Cookies that have been returned from
+# any particular website.
+
+class Mechanize::CookieJar
+
+  # add_cookie wants something resembling a URI.
+
+  FakeURI = Struct.new(:host) # :nodoc:
+
+  attr_reader :jar
+
+  def initialize
+    @jar = {}
+  end
+
+  def initialize_copy other # :nodoc:
+    @jar = Marshal.load Marshal.dump other.jar
+  end
+
+  # Add a cookie to the Jar.
+  def add(uri, cookie)
+    return unless cookie.acceptable_from_uri?(uri)
+
+    normal_domain = cookie.domain.downcase
+
+    @jar[normal_domain] ||= {} unless @jar.has_key?(normal_domain)
+
+    @jar[normal_domain][cookie.path] ||= {}
+    @jar[normal_domain][cookie.path][cookie.name] = cookie
+
+    cookie
+  end
+
+  # Fetch the cookies that should be used for the URI object passed in.
+  def cookies(url)
+    cleanup
+    url.path = '/' if url.path.empty?
+
+    [].tap { |cookies|
+      @jar.each { |domain, paths|
+        paths.each { |path, hash|
+          hash.each_value { |cookie|
+            next if cookie.expired? || !cookie.valid_for_uri?(url)
+            cookies << cookie
+          }
+        }
+      }
+    }
+  end
+
+  def empty?(url)
+    cookies(url).length > 0 ? false : true
+  end
+
+  def to_a
+    cleanup
+
+    @jar.map do |domain, paths|
+      paths.map do |path, names|
+        names.values
+      end
+    end.flatten
+  end
+
+  # Save the cookie jar to a file in the format specified.
+  #
+  # Available formats:
+  # :yaml  <- YAML structure
+  # :cookiestxt  <- Mozilla's cookies.txt format
+  def save_as(file, format = :yaml)
+    jar = dup
+    jar.cleanup true
+
+    open(file, 'w') { |f|
+      case format
+      when :yaml then
+        load_yaml
+
+        YAML.dump(jar.jar, f)
+      when :cookiestxt then
+        jar.dump_cookiestxt(f)
+      else
+        raise ArgumentError, "Unknown cookie jar file format"
+      end
+    }
+
+    self
+  end
+
+  # Load cookie jar from a file in the format specified.
+  #
+  # Available formats:
+  # :yaml  <- YAML structure.
+  # :cookiestxt  <- Mozilla's cookies.txt format
+  def load(file, format = :yaml)
+    @jar = open(file) { |f|
+      case format
+      when :yaml then
+        load_yaml
+
+        YAML.load(f)
+      when :cookiestxt then
+        load_cookiestxt(f)
+      else
+        raise ArgumentError, "Unknown cookie jar file format"
+      end
+    }
+
+    cleanup
+
+    self
+  end
+
+  def load_yaml # :nodoc:
+    begin
+      require 'psych'
+    rescue LoadError
+    end
+
+    require 'yaml'
+  end
+
+  # Clear the cookie jar
+  def clear!
+    @jar = {}
+  end
+
+  # Read cookies from Mozilla cookies.txt-style IO stream
+  def load_cookiestxt(io)
+    now = Time.now
+
+    io.each_line do |line|
+      line.chomp!
+      line.gsub!(/#.+/, '')
+      fields = line.split("\t")
+
+      next if fields.length != 7
+
+      expires_seconds = fields[4].to_i
+      expires = (expires_seconds == 0) ? nil : Time.at(expires_seconds)
+      next if expires and (expires < now)
+
+      c = Mechanize::Cookie.new(fields[5], fields[6])
+      c.domain = fields[0]
+      # Field 1 indicates whether the cookie can be read by other machines at
+      # the same domain.  This is computed by the cookie implementation, based
+      # on the domain value.
+      c.path = fields[2]               # Path for which the cookie is relevant
+      c.secure = (fields[3] == "TRUE") # Requires a secure connection
+      c.expires = expires             # Time the cookie expires.
+      c.version = 0                   # Conforms to Netscape cookie spec.
+
+      add(FakeURI.new(c.domain), c)
+    end
+
+    @jar
+  end
+
+  # Write cookies to Mozilla cookies.txt-style IO stream
+  def dump_cookiestxt(io)
+    to_a.each do |cookie|
+      fields = []
+      fields[0] = cookie.domain
+
+      if cookie.domain =~ /^\./
+        fields[1] = "TRUE"
+      else
+        fields[1] = "FALSE"
+      end
+
+      fields[2] = cookie.path
+
+      if cookie.secure == true
+        fields[3] = "TRUE"
+      else
+        fields[3] = "FALSE"
+      end
+
+      fields[4] = cookie.expires.to_i.to_s
+
+      fields[5] = cookie.name
+      fields[6] = cookie.value
+      io.puts(fields.join("\t"))
+    end
+  end
+
+  protected
+
+  # Remove expired cookies
+  def cleanup session = false
+    @jar.each do |domain, paths|
+      paths.each do |path, names|
+        names.each do |cookie_name, cookie|
+          paths[path].delete(cookie_name) if
+            cookie.expired? or (session and cookie.session)
+        end
+      end
+    end
+  end
+end
+

data/lib/mechanize/element_matcher.rb

@@ -0,0 +1,35 @@
+module Mechanize::ElementMatcher
+
+  def elements_with singular, plural = "#{singular}s"
+    class_eval <<-CODE
+      def #{plural}_with criteria = {}
+        criteria = if String === criteria then
+                     {:name => criteria}
+                   else
+                     criteria.map do |k, v|
+                       k = :dom_id if k.to_sym == :id
+                       [k, v]
+                     end
+                   end
+
+        f = #{plural}.find_all do |thing|
+          criteria.all? do |k,v|
+            v === thing.send(k)
+          end
+        end
+        yield f if block_given?
+        f
+      end
+
+      def #{singular}_with criteria = {}
+        f = #{plural}_with(criteria).first
+        yield f if block_given?
+        f
+      end
+
+      alias :#{singular} :#{singular}_with
+    CODE
+  end
+
+end
+

data/lib/mechanize/file.rb

@@ -0,0 +1,80 @@
+class Mechanize
+  # = Synopsis
+  # This is the default (and base) class for the Pluggable Parsers.  If
+  # Mechanize cannot find an appropriate class to use for the content type,
+  # this class will be used.  For example, if you download a JPG, Mechanize
+  # will not know how to parse it, so this class will be instantiated.
+  #
+  # This is a good class to use as the base class for building your own
+  # pluggable parsers.
+  #
+  # == Example
+  #  require 'rubygems'
+  #  require 'mechanize'
+  #
+  #  agent = Mechanize.new
+  #  agent.get('http://example.com/foo.jpg').class  #=> Mechanize::File
+  #
+  class File
+    extend Forwardable
+
+    attr_accessor :uri, :response, :body, :code, :filename
+    alias :header :response
+    def_delegator :header, :[], :[]
+    def_delegator :header, :[]=, :[]=
+    def_delegator :header, :key?, :key?
+    def_delegator :header, :each, :each
+    def_delegator :header, :canonical_each, :canonical_each
+
+    alias :content :body
+
+    def initialize(uri=nil, response=nil, body=nil, code=nil)
+      @uri = uri
+      @body = body
+      @code = code
+      @response = Headers.new
+
+      # Copy the headers in to a hash to prevent memory leaks
+      if response
+        response.each { |k,v|
+          @response[k] = v
+        }
+      end
+
+      @filename = 'index.html'
+
+      # Set the filename
+      if disposition = @response['content-disposition']
+        disposition.split(/;\s*/).each do |pair|
+          k,v = pair.split(/=/, 2)
+          @filename = v if k && k.downcase == 'filename'
+        end
+      else
+        if @uri
+          @filename = @uri.path.split(/\//).last || 'index.html'
+          @filename << ".html" unless @filename =~ /\./
+        end
+      end
+
+      yield self if block_given?
+    end
+
+    # Use this method to save the content of this object to filename
+    def save_as(filename = nil)
+      if filename.nil?
+        filename = @filename
+        number = 1
+        while(::File.exists?(filename))
+          filename = "#{@filename}.#{number}"
+          number += 1
+        end
+      end
+
+      ::File::open(filename, "wb") { |f|
+        f.write body
+      }
+    end
+
+    alias :save :save_as
+  end
+end