husc 0.1.0

data/vendor/bundle/gems/mechanize-2.7.6/lib/mechanize/http/auth_challenge.rb

@@ -0,0 +1,65 @@
+class Mechanize::HTTP
+
+  AuthChallenge = Struct.new :scheme, :params, :raw
+
+  ##
+  # A parsed WWW-Authenticate header
+
+  class AuthChallenge
+
+    ##
+    # :attr_accessor: scheme
+    #
+    # The authentication scheme
+
+    ##
+    # :attr_accessor: params
+    #
+    # The authentication parameters
+
+    ##
+    # :method: initialize
+    #
+    # :call-seq:
+    #   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 name of the realm for this challenge
+
+    def realm_name
+      params['realm'] if Hash === params # NTLM has a string for params
+    end
+
+    ##
+    # The raw authentication challenge
+
+    alias to_s raw
+
+  end
+
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/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 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/vendor/bundle/gems/mechanize-2.7.6/lib/mechanize/http/auth_store.rb

@@ -0,0 +1,123 @@
+##
+# A credential store for HTTP authentication.
+#
+#   uri = URI 'http://example'
+#
+#   store = Mechanize::HTTP::AuthStore.new
+#   store.add_auth uri, 'user1', 'pass'
+#   store.add_auth uri, 'user2', 'pass', 'realm'
+#
+#   user, pass = store.credentials_for uri, 'realm' #=> 'user2', 'pass'
+#   user, pass = store.credentials_for uri, 'other' #=> 'user1', 'pass'
+#
+#   store.remove_auth uri # removes all credentials
+
+class Mechanize::HTTP::AuthStore
+
+  attr_reader :auth_accounts # :nodoc:
+
+  attr_reader :default_auth # :nodoc:
+
+  ##
+  # Creates a new AuthStore
+
+  def initialize
+    @auth_accounts = Hash.new do |h, uri|
+      h[uri] = {}
+    end
+
+    @default_auth = nil
+  end
+
+  ##
+  # Adds credentials +user+, +pass+ for the server at +uri+.  If +realm+ is
+  # set the credentials are used only for that realm.  If +realm+ is not set
+  # the credentials become the default for any realm on that URI.
+  #
+  # +domain+ and +realm+ are exclusive as NTLM does not follow RFC
+  # 2617.  If +domain+ is given it is only used for NTLM authentication.
+
+  def add_auth uri, user, pass, realm = nil, domain = nil
+    uri = URI uri unless URI === uri
+
+    raise ArgumentError,
+          'NTLM domain given with realm which NTLM does not use' if
+      realm and domain
+
+    uri += '/'
+
+    auth_accounts[uri][realm] = [user, pass, domain]
+
+    self
+  end
+
+  ##
+  # USE OF add_default_auth IS NOT RECOMMENDED AS IT MAY EXPOSE PASSWORDS TO
+  # THIRD PARTIES
+  #
+  # Adds credentials +user+, +pass+ as the default authentication credentials.
+  # If no other credentials are available  these will be returned from
+  # credentials_for.
+  #
+  # If +domain+ is given it is only used for NTLM authentication.
+
+  def add_default_auth user, pass, domain = nil
+    warn <<-WARN
+You have supplied default authentication credentials that apply to ANY SERVER.
+Your username and password can be retrieved by ANY SERVER using Basic
+authentication.
+
+THIS EXPOSES YOUR USERNAME AND PASSWORD TO DISCLOSURE WITHOUT YOUR KNOWLEDGE.
+
+Use add_auth to set authentication credentials that will only be delivered
+only to a particular server you specify.
+    WARN
+
+    @default_auth = [user, pass, domain]
+  end
+
+  ##
+  # Returns true if credentials exist for the +challenges+ from the server at
+  # +uri+.
+
+  def credentials? uri, challenges
+    challenges.any? do |challenge|
+      credentials_for uri, challenge.realm_name
+    end
+  end
+
+  ##
+  # Retrieves credentials for +realm+ on the server at +uri+.
+
+  def credentials_for uri, realm
+    uri = URI uri unless URI === uri
+
+    uri += '/'
+    uri.user = nil
+    uri.password = nil
+
+    realms = @auth_accounts[uri]
+
+    realms[realm] || realms[nil] || @default_auth
+  end
+
+  ##
+  # Removes credentials for +realm+ on the server at +uri+.  If +realm+ is not
+  # set all credentials for the server at +uri+ are removed.
+
+  def remove_auth uri, realm = nil
+    uri = URI uri unless URI === uri
+
+    uri += '/'
+
+    if realm then
+      auth_accounts[uri].delete realm
+    else
+      auth_accounts.delete uri
+    end
+
+    self
+  end
+
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/lib/mechanize/http/content_disposition_parser.rb

@@ -0,0 +1,191 @@
+# 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
+                rfc_2045_value.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(2) then
+          @scanner.skip(/\\/)
+          text << @scanner.get_byte
+        elsif '"' == @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/vendor/bundle/gems/mechanize-2.7.6/lib/mechanize/http/www_authenticate_parser.rb

@@ -0,0 +1,178 @@
+# 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?
+      start = @scanner.pos
+      challenge = Mechanize::HTTP::AuthChallenge.new
+
+      scheme = auth_scheme
+
+      if scheme == 'Negotiate'
+        scan_comma_spaces
+      end
+
+      break unless scheme
+      challenge.scheme = scheme
+
+      space = spaces
+
+      if scheme == 'NTLM' then
+        if space then
+          challenge.params = @scanner.scan(/.*/)
+        end
+
+        challenge.raw = www_authenticate[start, @scanner.pos]
+        challenges << challenge
+        next
+      else
+        scheme.capitalize!
+      end
+
+      next unless space
+
+      params = {}
+
+      while true do
+        pos = @scanner.pos
+        name, value = auth_param
+
+        name.downcase! if name =~ /^realm$/i
+
+        unless name then
+          challenge.params = params
+          challenges << challenge
+
+          if @scanner.eos? then
+            challenge.raw = www_authenticate[start, @scanner.pos]
+            break
+          end
+
+          @scanner.pos = pos # rewind
+          challenge.raw = www_authenticate[start, @scanner.pos].sub(/(,+)? *$/, '')
+          challenge = nil # a token should be next, new challenge
+          break
+        else
+          params[name] = value
+        end
+
+        spaces
+
+        @scanner.scan(/(, *)+/)
+      end
+    end
+
+    challenges
+  end
+
+  ##
+  #   1*SP
+  #
+  # Parses spaces
+
+  def spaces
+    @scanner.scan(/ +/)
+  end
+
+  ##
+  # scans a comma followed by spaces
+  # needed for Negotiation, NTLM
+  #
+
+  def scan_comma_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
+