diamond-mechanize 2.1 → 2.2

data/lib/mechanize/content_type_error.rb

@@ -1,13 +0,0 @@
-##
-# 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

@@ -1,232 +0,0 @@
-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

@@ -1,194 +0,0 @@
-##
-# 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

@@ -1,59 +0,0 @@
-##
-# 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
-