diamond-mechanize 2.1

data/lib/mechanize/content_type_error.rb

@@ -0,0 +1,13 @@
+##
+# This error is raised 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 Mechanize::ContentTypeError < Mechanize::Error
+  attr_reader :content_type
+
+  def initialize(content_type)
+    @content_type = content_type
+  end
+end
+

data/lib/mechanize/cookie.rb

@@ -0,0 +1,232 @@
+require 'time'
+require 'webrick/cookie'
+require 'domain_name'
+
+# This class is used to represent an HTTP Cookie.
+class Mechanize::Cookie
+  attr_reader :name
+  attr_accessor :value, :version
+  attr_accessor :domain, :path, :secure
+  attr_accessor :comment, :max_age
+
+  attr_accessor :session
+
+  attr_accessor :created_at
+  attr_accessor :accessed_at
+
+  # :call-seq:
+  #     new(name, value)
+  #     new(name, value, attr_hash)
+  #     new(attr_hash)
+  #
+  # Creates a cookie object.  For each key of +attr_hash+, the setter
+  # is called if defined.  Each key can be either a symbol or a
+  # string, downcased or not.
+  #
+  # e.g.
+  #     new("uid", "a12345")
+  #     new("uid", "a12345", :domain => 'example.org',
+  #                          :for_domain => true, :expired => Time.now + 7*86400)
+  #     new("name" => "uid", "value" => "a12345", "Domain" => 'www.example.org')
+  #
+  def initialize(*args)
+    @version = 0     # Netscape Cookie
+
+    @domain = @path = @secure = @comment = @max_age =
+      @expires = @comment_url = @discard = @port = nil
+
+    @created_at = @accessed_at = Time.now
+    case args.size
+    when 2
+      @name, @value = *args
+      @for_domain = false
+      return
+    when 3
+      @name, @value, attr_hash = *args
+    when 1
+      attr_hash = args.first
+    else
+      raise ArgumentError, "wrong number of arguments (#{args.size} for 1-3)"
+    end
+    for_domain = false
+    attr_hash.each_pair { |key, val|
+      skey = key.to_s.downcase
+      skey.sub!(/[!?]\z/, '')
+      case skey
+      when 'for_domain'
+        for_domain = !!val
+      when 'name'
+        @name = val
+      when 'value'
+        @value = val
+      else
+        setter = :"#{skey}="
+        send(setter, val) if respond_to?(setter)
+      end
+    }
+    @for_domain = for_domain
+  end
+
+  # If this flag is true, this cookie will be sent to any host in the
+  # +domain+.  If it is false, this cookie will be sent only to the
+  # host indicated by the +domain+.
+  attr_accessor :for_domain
+  alias for_domain? for_domain
+
+  class << self
+    # Parses a Set-Cookie header line +str+ sent from +uri+ into an
+    # array of Cookie objects.  Note that this array may contain
+    # nil's when some of the cookie-pairs are malformed.
+    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)
+
+        begin
+          cookie = new(key, value.dup)
+        rescue
+          log.warn("Couldn't parse key/value: #{first_elem}") if log
+          next
+        end
+
+        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'
+            begin
+              cookie.domain = value
+              cookie.for_domain = true
+            rescue
+              log.warn("Couldn't parse domain: #{value}") if log
+            end
+          when 'path'
+            cookie.path = value
+          when 'expires'
+            if value.empty?
+              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'
+            begin
+              cookie.max_age = Integer(value)
+            rescue
+              log.warn("Couldn't parse max age '#{value}'") if log
+            end
+          when 'comment'
+            cookie.comment = value
+          when 'version'
+            begin
+              cookie.version = Integer(value)
+            rescue
+              log.warn("Couldn't parse version '#{value}'") if log
+              cookie.version = nil
+            end
+          when 'secure'
+            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
+  end
+
+  alias set_domain domain=
+
+  # Sets the domain attribute.  A leading dot in +domain+ implies
+  # turning the +for_domain?+ flag on.
+  def domain=(domain)
+    if DomainName === domain
+      @domain_name = domain
+    else
+      domain.is_a?(String) or
+        (domain.respond_to?(:to_str) && (domain = domain.to_str).is_a?(String)) or
+        raise TypeError, "#{domain.class} is not a String"
+      if domain.start_with?('.')
+        @for_domain = true
+        domain = domain[1..-1]
+      end
+      # Do we really need to support this?
+      if domain.match(/\A([^:]+):[0-9]+\z/)
+        domain = $1
+      end
+      @domain_name = DomainName.new(domain)
+    end
+    set_domain(@domain_name.hostname)
+  end
+
+  def expires=(t)
+    @expires = t && (t.is_a?(Time) ? t.httpdate : t.to_s)
+  end
+
+  def expires
+    @expires && Time.parse(@expires)
+  end
+
+  def expired?
+    return false unless expires
+    Time.now > expires
+  end
+
+  alias secure? secure
+
+  def acceptable_from_uri?(uri)
+    host = DomainName.new(uri.host)
+
+    # RFC 6265 5.3
+    # When the user agent "receives a cookie":
+    return host.hostname == domain unless @for_domain
+
+    if host.cookie_domain?(@domain_name)
+      true
+    elsif host.hostname == domain
+      @for_domain = false
+      true
+    else
+      false
+    end
+  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
+
+  def init_with(coder)
+    yaml_initialize(coder.tag, coder.map)
+  end
+
+  def yaml_initialize(tag, map)
+    @for_domain = true    # for forward compatibility
+    map.each { |key, value|
+      case key
+      when 'domain'
+        self.domain = value # ditto
+      else
+        instance_variable_set(:"@#{key}", value)
+      end
+    }
+  end
+end

data/lib/mechanize/cookie_jar.rb

@@ -0,0 +1,194 @@
+##
+# This class is used to manage the Cookies that have been returned from
+# any particular website.
+
+class Mechanize::CookieJar
+  include Enumerable
+
+  # add_cookie wants something resembling a URI.
+
+  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 if it is considered acceptable from
+  # +uri+.  Return nil if the cookie was not added, otherwise return
+  # the cookie added.
+  def add(uri, cookie)
+    return nil unless cookie.acceptable_from_uri?(uri)
+    add!(cookie)
+    cookie
+  end
+
+  # Add a +cookie+ to the jar and return self.
+  def add!(cookie)
+    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
+
+    self
+  end
+  alias << add!
+
+  # Fetch the cookies that should be used for the URI object passed in.
+  def cookies(url)
+    cleanup
+    url.path = '/' if url.path.empty?
+    now = Time.now
+
+    select { |cookie|
+      !cookie.expired? && cookie.valid_for_uri?(url) && (cookie.accessed_at = now)
+    }.sort_by { |cookie|
+      # RFC 6265 5.4
+      # Precedence: 1. longer path  2. older creation
+      [-cookie.path.length, cookie.created_at]
+    }
+  end
+
+  def empty?(url)
+    cookies(url).length > 0 ? false : true
+  end
+
+  def each
+    block_given? or return enum_for(__method__)
+    cleanup
+    @jar.each { |domain, paths|
+      paths.each { |path, hash|
+        hash.each_value { |cookie|
+          yield cookie
+        }
+      }
+    }
+  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]
+      c.for_domain = (fields[1] == "TRUE") # Whether this cookie is for domain
+      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!(c)
+    end
+
+    @jar
+  end
+
+  # Write cookies to Mozilla cookies.txt-style IO stream
+  def dump_cookiestxt(io)
+    to_a.each do |cookie|
+      io.puts([
+        cookie.domain,
+        cookie.for_domain? ? "TRUE" : "FALSE",
+        cookie.path,
+        cookie.secure ? "TRUE" : "FALSE",
+        cookie.expires.to_i.to_s,
+        cookie.name,
+        cookie.value
+      ].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/download.rb

@@ -0,0 +1,59 @@
+##
+# Download is a pluggable parser for downloading files without loading them
+# into memory first.  You may subclass this class to handle content types you
+# do not wish to load into memory first.
+#
+# See Mechanize::PluggableParser for instructions on using this class.
+
+class Mechanize::Download
+
+  include Mechanize::Parser
+
+  ##
+  # Accessor for the IO-like that contains the body
+
+  attr_reader :body_io
+
+  alias content body_io
+
+  ##
+  # Creates a new download retrieved from the given +uri+ and +response+
+  # object.  The +body_io+ is an IO-like containing the HTTP response body and
+  # +code+ is the HTTP status.
+
+  def initialize uri = nil, response = nil, body_io = nil, code = nil
+    @uri      = uri
+    @body_io  = body_io
+    @code     = code
+
+    @full_path = false unless defined? @full_path
+
+    fill_header response
+    extract_filename
+
+    yield self if block_given?
+  end
+
+  ##
+  # Saves a copy of the body_io to +filename+
+
+  def save filename = nil
+    filename = find_free_name filename
+
+    dirname = File.dirname filename
+    FileUtils.mkdir_p dirname
+
+    # Ruby 1.8.7 implements StringIO#path, can't use respond_to? :path
+    if StringIO === @body_io then
+      open filename, 'wb' do |io|
+        until @body_io.eof? do
+          io.write @body_io.read 16384
+        end
+      end
+    else
+      FileUtils.mv @body_io.path, filename
+    end
+  end
+
+end
+