diamond-mechanize 2.2 → 2.3

data/lib/mechanize/http/auth_challenge.rb

@@ -0,0 +1,59 @@
+class Mechanize::HTTP
+
+  AuthChallenge = Struct.new :scheme, :params
+
+  ##
+  # A parsed WWW-Authenticate header
+
+  class AuthChallenge
+
+    ##
+    # :attr_accessor: scheme
+    #
+    # The authentication scheme
+
+    ##
+    # :attr_accessor: params
+    #
+    # The authentication parameters
+
+    ##
+    # :method: initialize(scheme = nil, params = nil)
+    #
+    # Creates a new AuthChallenge header with the given scheme and parameters
+
+    ##
+    # Retrieves +param+ from the params list
+
+    def [] param
+      params[param]
+    end
+
+    ##
+    # Constructs an AuthRealm for this challenge
+
+    def realm uri
+      case scheme
+      when 'Basic' then
+        raise ArgumentError, "provide uri for Basic authentication" unless uri
+        Mechanize::HTTP::AuthRealm.new scheme, uri + '/', self['realm']
+      when 'Digest' then
+        Mechanize::HTTP::AuthRealm.new scheme, uri + '/', self['realm']
+      else
+        raise Mechanize::Error, "unknown HTTP authentication scheme #{scheme}"
+      end
+    end
+
+    ##
+    # The reconstructed, normalized challenge
+
+    def to_s
+      auth_params = params.map { |name, value| "#{name}=\"#{value}\"" }
+
+      "#{scheme} #{auth_params.join ', '}"
+    end
+
+  end
+
+end
+

data/lib/mechanize/http/auth_realm.rb

@@ -0,0 +1,31 @@
+class Mechanize::HTTP::AuthRealm
+
+  attr_reader :scheme
+  attr_reader :uri
+  attr_reader :realm
+
+  def initialize scheme, uri, realm
+    @scheme = scheme
+    @uri    = uri
+    @realm  = realm.downcase if realm
+  end
+
+  def == other
+    self.class === other and
+      @scheme == other.scheme and
+      @uri    == other.uri    and
+      @realm  == other.realm
+  end
+
+  alias eql? ==
+
+  def hash # :nodoc:
+    [@scheme, @uri, @realm].hash
+  end
+
+  def inspect # :nodoc:
+    "#<AuthRealm %s %p \"%s\">" % [@scheme, @uri, @realm]
+  end
+
+end
+

data/lib/mechanize/http/content_disposition_parser.rb

@@ -0,0 +1,188 @@
+# coding: BINARY
+
+require 'strscan'
+require 'time'
+
+class Mechanize::HTTP
+  ContentDisposition = Struct.new :type, :filename, :creation_date,
+    :modification_date, :read_date, :size, :parameters
+end
+
+##
+# Parser Content-Disposition headers that loosely follows RFC 2183.
+#
+# Beyond RFC 2183, this parser allows:
+#
+# * Missing disposition-type
+# * Multiple semicolons
+# * Whitespace around semicolons
+
+class Mechanize::HTTP::ContentDispositionParser
+
+  attr_accessor :scanner # :nodoc:
+
+  @parser = nil
+
+  ##
+  # Parses the disposition type and params in the +content_disposition+
+  # string.  The "Content-Disposition:" must be removed.
+
+  def self.parse content_disposition
+    @parser ||= self.new
+    @parser.parse content_disposition
+  end
+
+  ##
+  # Creates a new parser Content-Disposition headers
+
+  def initialize
+    @scanner = nil
+  end
+
+  ##
+  # Parses the +content_disposition+ header.  If +header+ is set to true the
+  # "Content-Disposition:" portion will be parsed
+
+  def parse content_disposition, header = false
+    return nil if content_disposition.empty?
+
+    @scanner = StringScanner.new content_disposition
+
+    if header then
+      return nil unless @scanner.scan(/Content-Disposition/i)
+      return nil unless @scanner.scan(/:/)
+      spaces
+    end
+
+    type = rfc_2045_token
+    @scanner.scan(/;+/)
+
+    if @scanner.peek(1) == '=' then
+      @scanner.pos = 0
+      type = nil
+    end
+
+    disposition = Mechanize::HTTP::ContentDisposition.new type
+
+    spaces
+
+    return nil unless parameters = parse_parameters
+
+    disposition.filename          = parameters.delete 'filename'
+    disposition.creation_date     = parameters.delete 'creation-date'
+    disposition.modification_date = parameters.delete 'modification-date'
+    disposition.read_date         = parameters.delete 'read-date'
+    disposition.size              = parameters.delete 'size'
+    disposition.parameters        = parameters
+
+    disposition
+  end
+
+  ##
+  # Extracts disposition-parm and returns a Hash.
+
+  def parse_parameters
+    parameters = {}
+
+    while true do
+      return nil unless param = rfc_2045_token
+      param.downcase
+      return nil unless @scanner.scan(/=/)
+
+      value = case param
+              when /^filename$/ then
+                rfc_2045_value
+              when /^(creation|modification|read)-date$/ then
+                Time.rfc822 rfc_2045_quoted_string
+              when /^size$/ then
+                @scanner.scan(/\d+/).to_i(10)
+              else
+                rfc_2045_value
+              end
+
+      return nil unless value
+
+      parameters[param] = value
+
+      spaces
+
+      break if @scanner.eos? or not @scanner.scan(/;+/)
+
+      spaces
+    end
+
+    parameters
+  end
+
+  ##
+  #   quoted-string = <"> *(qtext/quoted-pair) <">
+  #   qtext         = <any CHAR excepting <">, "\" & CR,
+  #                    and including linear-white-space
+  #   quoted-pair   = "\" CHAR
+  #
+  # Parses an RFC 2045 quoted-string
+
+  def rfc_2045_quoted_string
+    return nil unless @scanner.scan(/"/)
+
+    text = ''
+
+    while true do
+      chunk = @scanner.scan(/[\000-\014\016-\041\043-\133\135-\177]+/) # not \r "
+
+      if chunk then
+        text << chunk
+
+        if @scanner.peek(1) == '\\' then
+          @scanner.get_byte
+          return nil if @scanner.eos?
+          text << @scanner.get_byte
+        elsif @scanner.scan(/\r\n[\t ]+/) then
+          text << " "
+        end
+      else
+        if '"' == @scanner.peek(1) then
+          @scanner.get_byte
+          break
+        else
+          return nil
+        end
+      end
+    end
+
+    text
+  end
+
+  ##
+  #   token := 1*<any (US-ASCII) CHAR except SPACE, CTLs, or tspecials>
+  #
+  # Parses an RFC 2045 token
+
+  def rfc_2045_token
+    @scanner.scan(/[^\000-\037\177()<>@,;:\\"\/\[\]?= ]+/)
+  end
+
+  ##
+  #   value := token / quoted-string
+  #
+  # Parses an RFC 2045 value
+
+  def rfc_2045_value
+    if @scanner.peek(1) == '"' then
+      rfc_2045_quoted_string
+    else
+      rfc_2045_token
+    end
+  end
+
+  ##
+  #   1*SP
+  #
+  # Parses spaces
+
+  def spaces
+    @scanner.scan(/ +/)
+  end
+
+end
+

data/lib/mechanize/http/www_authenticate_parser.rb

@@ -0,0 +1,155 @@
+# coding: BINARY
+
+require 'strscan'
+
+##
+# Parses the WWW-Authenticate HTTP header into separate challenges.
+
+class Mechanize::HTTP::WWWAuthenticateParser
+
+  attr_accessor :scanner # :nodoc:
+
+  ##
+  # Creates a new header parser for WWW-Authenticate headers
+
+  def initialize
+    @scanner = nil
+  end
+
+  ##
+  # Parsers the header.  Returns an Array of challenges as strings
+
+  def parse www_authenticate
+    challenges = []
+    @scanner = StringScanner.new www_authenticate
+
+    while true do
+      break if @scanner.eos?
+      challenge = Mechanize::HTTP::AuthChallenge.new
+
+      scheme = auth_scheme
+      next unless scheme
+      challenge.scheme = scheme
+
+      space = spaces
+
+      if scheme == 'NTLM' then
+        if space then
+          challenge.params = @scanner.scan(/.*/)
+        end
+
+        challenges << challenge
+        next
+      end
+
+      next unless space
+
+      params = {}
+
+      while true do
+        pos = @scanner.pos
+        name, value = auth_param
+
+        unless name then
+          challenge.params = params
+          challenges << challenge
+          break if @scanner.eos?
+
+          @scanner.pos = pos # rewind
+          challenge = '' # a token should be next, new challenge
+          break
+        else
+          params[name] = value
+        end
+
+        spaces
+
+        return nil unless ',' == @scanner.peek(1) or @scanner.eos?
+
+        @scanner.scan(/(, *)+/)
+      end
+    end
+
+    challenges
+  end
+
+  ##
+  #   1*SP
+  #
+  # Parses spaces
+
+  def spaces
+    @scanner.scan(/ +/)
+  end
+
+  ##
+  #   token = 1*<any CHAR except CTLs or separators>
+  #
+  # Parses a token
+
+  def token
+    @scanner.scan(/[^\000-\037\177()<>@,;:\\"\/\[\]?={} ]+/)
+  end
+
+  ##
+  #   auth-scheme = token
+  #
+  # Parses an auth scheme (a token)
+
+  alias auth_scheme token
+
+  ##
+  #   auth-param = token "=" ( token | quoted-string )
+  #
+  # Parses an auth parameter
+
+  def auth_param
+    return nil unless name = token
+    return nil unless @scanner.scan(/=/)
+
+    value = if @scanner.peek(1) == '"' then
+              quoted_string
+            else
+              token
+            end
+
+    return nil unless value
+
+    return name, value
+  end
+
+  ##
+  #   quoted-string = ( <"> *(qdtext | quoted-pair ) <"> )
+  #   qdtext        = <any TEXT except <">>
+  #   quoted-pair   = "\" CHAR
+  #
+  # For TEXT, the rules of RFC 2047 are ignored.
+
+  def quoted_string
+    return nil unless @scanner.scan(/"/)
+
+    text = ''
+
+    while true do
+      chunk = @scanner.scan(/[\r\n \t\041\043-\176\200-\377]+/) # not "
+
+      if chunk then
+        text << chunk
+
+        text << @scanner.get_byte if
+          chunk.end_with? '\\' and '"' == @scanner.peek(1)
+      else
+        if '"' == @scanner.peek(1) then
+          @scanner.get_byte
+          break
+        else
+          return nil
+        end
+      end
+    end
+
+    text
+  end
+
+end
+

data/lib/mechanize/monkey_patch.rb

@@ -0,0 +1,16 @@
+# :stopdoc:
+
+class Net::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 if RUBY_VERSION < '1.9'
+