husc 0.1.0

data/vendor/bundle/gems/http-cookie-1.0.3/lib/http/cookie/ruby_compat.rb

@@ -0,0 +1,63 @@
+class Array
+  def select! # :yield: x
+    i = 0
+    each_with_index { |x, j|
+      yield x or next
+      self[i] = x if i != j
+      i += 1
+    }
+    return nil if i == size
+    self[i..-1] = []
+    self
+  end unless method_defined?(:select!)
+
+  def sort_by!(&block) # :yield: x
+    replace(sort_by(&block))
+  end unless method_defined?(:sort_by!)
+end
+
+class Hash
+  class << self
+    def try_convert(object)
+      if object.is_a?(Hash) ||
+          (object.respond_to?(:to_hash) && (object = object.to_hash).is_a?(Hash))
+        object
+      else
+        nil
+      end
+    end unless method_defined?(:try_convert)
+  end
+end
+
+class String
+  class << self
+    def try_convert(object)
+      if object.is_a?(String) ||
+          (object.respond_to?(:to_str) && (object = object.to_str).is_a?(String))
+        object
+      else
+        nil
+      end
+    end unless method_defined?(:try_convert)
+  end
+end
+
+# In Ruby < 1.9.3 URI() does not accept a URI object.
+if RUBY_VERSION < "1.9.3"
+  require 'uri'
+
+  begin
+    URI(URI(''))
+  rescue
+    def URI(url) # :nodoc:
+      case url
+      when URI
+        url
+      when String
+        URI.parse(url)
+      else
+        raise ArgumentError, 'bad argument (expected URI object or URI string)'
+      end
+    end
+  end
+end

data/vendor/bundle/gems/http-cookie-1.0.3/lib/http/cookie/scanner.rb

@@ -0,0 +1,231 @@
+require 'http/cookie'
+require 'strscan'
+require 'time'
+
+class HTTP::Cookie::Scanner < StringScanner
+  # Whitespace.
+  RE_WSP = /[ \t]+/
+
+  # A pattern that matches a cookie name or attribute name which may
+  # be empty, capturing trailing whitespace.
+  RE_NAME = /(?!#{RE_WSP})[^,;\\"=]*/
+
+  RE_BAD_CHAR = /([\x00-\x20\x7F",;\\])/
+
+  # A pattern that matches the comma in a (typically date) value.
+  RE_COOKIE_COMMA = /,(?=#{RE_WSP}?#{RE_NAME}=)/
+
+  def initialize(string, logger = nil)
+    @logger = logger
+    super(string)
+  end
+
+  class << self
+    def quote(s)
+      return s unless s.match(RE_BAD_CHAR)
+      '"' << s.gsub(/([\\"])/, "\\\\\\1") << '"'
+    end
+  end
+
+  def skip_wsp
+    skip(RE_WSP)
+  end
+
+  def scan_dquoted
+    ''.tap { |s|
+      case
+      when skip(/"/)
+        break
+      when skip(/\\/)
+        s << getch
+      when scan(/[^"\\]+/)
+        s << matched
+      end until eos?
+    }
+  end
+
+  def scan_name
+    scan(RE_NAME).tap { |s|
+      s.rstrip! if s
+    }
+  end
+
+  def scan_value(comma_as_separator = false)
+    ''.tap { |s|
+      case
+      when scan(/[^,;"]+/)
+        s << matched
+      when skip(/"/)
+        # RFC 6265 2.2
+        # A cookie-value may be DQUOTE'd.
+        s << scan_dquoted
+      when check(/;/)
+        break
+      when comma_as_separator && check(RE_COOKIE_COMMA)
+        break
+      else
+        s << getch
+      end until eos?
+      s.rstrip!
+    }
+  end
+
+  def scan_name_value(comma_as_separator = false)
+    name = scan_name
+    if skip(/\=/)
+      value = scan_value(comma_as_separator)
+    else
+      scan_value(comma_as_separator)
+      value = nil
+    end
+    [name, value]
+  end
+
+  if Time.respond_to?(:strptime)
+    def tuple_to_time(day_of_month, month, year, time)
+      Time.strptime(
+        '%02d %s %04d %02d:%02d:%02d UTC' % [day_of_month, month, year, *time],
+        '%d %b %Y %T %Z'
+      ).tap { |date|
+        date.day == day_of_month or return nil
+      }
+    end
+  else
+    def tuple_to_time(day_of_month, month, year, time)
+      Time.parse(
+        '%02d %s %04d %02d:%02d:%02d UTC' % [day_of_month, month, year, *time]
+      ).tap { |date|
+        date.day == day_of_month or return nil
+      }
+    end
+  end
+  private :tuple_to_time
+
+  def parse_cookie_date(s)
+    # RFC 6265 5.1.1
+    time = day_of_month = month = year = nil
+
+    s.split(/[\x09\x20-\x2F\x3B-\x40\x5B-\x60\x7B-\x7E]+/).each { |token|
+      case
+      when time.nil? && token.match(/\A(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?(?=\D|\z)/)
+        sec =
+          if $3
+            $3.to_i
+          else
+            # violation of the RFC
+            @logger.warn("Time lacks the second part: #{token}") if @logger
+            0
+          end
+        time = [$1.to_i, $2.to_i, sec]
+      when day_of_month.nil? && token.match(/\A(\d{1,2})(?=\D|\z)/)
+        day_of_month = $1.to_i
+      when month.nil? && token.match(/\A(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i)
+        month = $1.capitalize
+      when year.nil? && token.match(/\A(\d{2,4})(?=\D|\z)/)
+        year = $1.to_i
+      end
+    }
+
+    if day_of_month.nil? || month.nil? || year.nil? || time.nil?
+      return nil
+    end
+
+    case day_of_month
+    when 1..31
+    else
+      return nil
+    end
+
+    case year
+    when 100..1600
+      return nil
+    when 70..99
+      year += 1900
+    when 0..69
+      year += 2000
+    end
+
+    hh, mm, ss = time
+    if hh > 23 || mm > 59 || ss > 59
+      return nil
+    end
+
+    tuple_to_time(day_of_month, month, year, time)
+  end
+
+  def scan_set_cookie
+    # RFC 6265 4.1.1 & 5.2
+    until eos?
+      start = pos
+      len = nil
+
+      skip_wsp
+
+      name, value = scan_name_value(true)
+      if value.nil?
+        @logger.warn("Cookie definition lacks a name-value pair.") if @logger
+      elsif name.empty?
+        @logger.warn("Cookie definition has an empty name.") if @logger
+        value = nil
+      end
+      attrs = {}
+
+      case
+      when skip(/,/)
+        # The comma is used as separator for concatenating multiple
+        # values of a header.
+        len = (pos - 1) - start
+        break
+      when skip(/;/)
+        skip_wsp
+        aname, avalue = scan_name_value(true)
+        next if aname.empty? || value.nil?
+        aname.downcase!
+        case aname
+        when 'expires'
+          # RFC 6265 5.2.1
+          avalue &&= parse_cookie_date(avalue) or next
+        when 'max-age'
+          # RFC 6265 5.2.2
+          next unless /\A-?\d+\z/.match(avalue)
+        when 'domain'
+          # RFC 6265 5.2.3
+          # An empty value SHOULD be ignored.
+          next if avalue.nil? || avalue.empty?
+        when 'path'
+          # RFC 6265 5.2.4
+          # A relative path must be ignored rather than normalizing it
+          # to "/".
+          next unless /\A\//.match(avalue)
+        when 'secure', 'httponly'
+          # RFC 6265 5.2.5, 5.2.6
+          avalue = true
+        end
+        attrs[aname] = avalue
+      end until eos?
+
+      len ||= pos - start
+
+      if len > HTTP::Cookie::MAX_LENGTH
+        @logger.warn("Cookie definition too long: #{name}") if @logger
+        next
+      end
+
+      yield name, value, attrs if value
+    end
+  end
+
+  def scan_cookie
+    # RFC 6265 4.1.1 & 5.4
+    until eos?
+      skip_wsp
+
+      # Do not treat comma in a Cookie header value as separator; see CVE-2016-7401
+      name, value = scan_name_value(false)
+
+      yield name, value if value
+
+      skip(/;/)
+    end
+  end
+end

data/vendor/bundle/gems/http-cookie-1.0.3/lib/http/cookie/version.rb

@@ -0,0 +1,5 @@
+module HTTP
+  class Cookie
+    VERSION = "1.0.3"
+  end
+end

data/vendor/bundle/gems/http-cookie-1.0.3/lib/http/cookie_jar.rb

@@ -0,0 +1,344 @@
+# :markup: markdown
+require 'http/cookie'
+
+##
+# This class is used to manage the Cookies that have been returned from
+# any particular website.
+
+class HTTP::CookieJar
+  class << self
+    def const_missing(name)
+      case name.to_s
+      when /\A([A-Za-z]+)Store\z/
+        file = 'http/cookie_jar/%s_store' % $1.downcase
+      when /\A([A-Za-z]+)Saver\z/
+        file = 'http/cookie_jar/%s_saver' % $1.downcase
+      end
+      begin
+        require file
+      rescue LoadError
+        raise NameError, 'can\'t resolve constant %s; failed to load %s' % [name, file]
+      end
+      if const_defined?(name)
+        const_get(name)
+      else
+        raise NameError, 'can\'t resolve constant %s after loading %s' % [name, file]
+      end
+    end
+  end
+
+  attr_reader :store
+
+  def get_impl(base, value, *args)
+    case value
+    when base
+      value
+    when Symbol
+      begin
+        base.implementation(value).new(*args)
+      rescue IndexError => e
+        raise ArgumentError, e.message
+      end
+    when Class
+      if base >= value
+        value.new(*args)
+      else
+        raise TypeError, 'not a subclass of %s: %s' % [base, value]
+      end
+    else
+      raise TypeError, 'invalid object: %s' % value.inspect
+    end
+  end
+  private :get_impl
+
+  # Generates a new cookie jar.
+  #
+  # Available option keywords are as below:
+  #
+  # :store
+  # : The store class that backs this jar. (default: `:hash`)
+  # A symbol addressing a store class, a store class, or an instance
+  # of a store class is accepted.  Symbols are mapped to store
+  # classes, like `:hash` to HTTP::CookieJar::HashStore and `:mozilla`
+  # to HTTP::CookieJar::MozillaStore.
+  #
+  # Any options given are passed through to the initializer of the
+  # specified store class.  For example, the `:mozilla`
+  # (HTTP::CookieJar::MozillaStore) store class requires a `:filename`
+  # option.  See individual store classes for details.
+  def initialize(options = nil)
+    opthash = {
+      :store => :hash,
+    }
+    opthash.update(options) if options
+    @store = get_impl(AbstractStore, opthash[:store], opthash)
+  end
+
+  # The copy constructor.  Not all backend store classes support cloning.
+  def initialize_copy(other)
+    @store = other.instance_eval { @store.dup }
+  end
+
+  # Adds a cookie to the jar if it is acceptable, and returns self in
+  # any case.  A given cookie must have domain and path attributes
+  # set, or ArgumentError is raised.
+  #
+  # Whether a cookie with the `for_domain` flag on overwrites another
+  # with the flag off or vice versa depends on the store used.  See
+  # individual store classes for that matter.
+  #
+  # ### Compatibility Note for Mechanize::Cookie users
+  #
+  # In HTTP::Cookie, each cookie object can store its origin URI
+  # (cf. #origin).  While the origin URI of a cookie can be set
+  # manually by #origin=, one is typically given in its generation.
+  # To be more specific, HTTP::Cookie.new takes an `:origin` option
+  # and HTTP::Cookie.parse takes one via the second argument.
+  #
+  #       # Mechanize::Cookie
+  #       jar.add(origin, cookie)
+  #       jar.add!(cookie)    # no acceptance check is performed
+  #
+  #       # HTTP::Cookie
+  #       jar.origin = origin
+  #       jar.add(cookie)     # acceptance check is performed
+  def add(cookie)
+    @store.add(cookie) if
+      begin
+        cookie.acceptable?
+      rescue RuntimeError => e
+        raise ArgumentError, e.message
+      end
+    self
+  end
+  alias << add
+
+  # Deletes a cookie that has the same name, domain and path as a
+  # given cookie from the jar and returns self.
+  #
+  # How the `for_domain` flag value affects the set of deleted cookies
+  # depends on the store used.  See individual store classes for that
+  # matter.
+  def delete(cookie)
+    @store.delete(cookie)
+    self
+  end
+
+  # Gets an array of cookies sorted by the path and creation time.  If
+  # `url` is given, only ones that should be sent to the URL/URI are
+  # selected, with the access time of each of them updated.
+  def cookies(url = nil)
+    each(url).sort
+  end
+
+  # Tests if the jar is empty.  If `url` is given, tests if there is
+  # no cookie for the URL.
+  def empty?(url = nil)
+    if url
+      each(url) { return false }
+      return true
+    else
+      @store.empty?
+    end
+  end
+
+  # Iterates over all cookies that are not expired in no particular
+  # order.
+  #
+  # An optional argument `uri` specifies a URI/URL indicating the
+  # destination of the cookies being selected.  Every cookie yielded
+  # should be good to send to the given URI,
+  # i.e. cookie.valid_for_uri?(uri) evaluates to true.
+  #
+  # If (and only if) the `uri` option is given, last access time of
+  # each cookie is updated to the current time.
+  def each(uri = nil, &block) # :yield: cookie
+    block_given? or return enum_for(__method__, uri)
+
+    if uri
+      uri = URI(uri)
+      return self unless URI::HTTP === uri && uri.host
+    end
+
+    @store.each(uri, &block)
+    self
+  end
+  include Enumerable
+
+  # Parses a Set-Cookie field value `set_cookie` assuming that it is
+  # sent from a source URL/URI `origin`, and adds the cookies parsed
+  # as valid and considered acceptable to the jar.  Returns an array
+  # of cookies that have been added.
+  #
+  # If a block is given, it is called for each cookie and the cookie
+  # is added only if the block returns a true value.
+  #
+  # `jar.parse(set_cookie, origin)` is a shorthand for this:
+  #
+  #         HTTP::Cookie.parse(set_cookie, origin) { |cookie|
+  #           jar.add(cookie)
+  #         }
+  #
+  # See HTTP::Cookie.parse for available options.
+  def parse(set_cookie, origin, options = nil) # :yield: cookie
+    if block_given?
+      HTTP::Cookie.parse(set_cookie, origin, options).tap { |cookies|
+        cookies.select! { |cookie|
+          yield(cookie) && add(cookie)
+        }
+      }
+    else
+      HTTP::Cookie.parse(set_cookie, origin, options) { |cookie|
+        add(cookie)
+      }
+    end
+  end
+
+  # call-seq:
+  #   jar.save(filename_or_io, **options)
+  #   jar.save(filename_or_io, format = :yaml, **options)
+  #
+  # Saves the cookie jar into a file or an IO in the format specified
+  # and returns self.  If a given object responds to #write it is
+  # taken as an IO, or taken as a filename otherwise.
+  #
+  # Available option keywords are below:
+  #
+  # * `:format`
+  #
+  #     Specifies the format for saving.  A saver class, a symbol
+  #     addressing a saver class, or a pre-generated instance of a
+  #     saver class is accepted.
+  #
+  #     <dl class="rdoc-list note-list">
+  #       <dt>:yaml</dt>
+  #       <dd>YAML structure (default)</dd>
+  #       <dt>:cookiestxt</dt>
+  #       <dd>Mozilla's cookies.txt format</dd>
+  #     </dl>
+  #
+  # * `:session`
+  #
+  #     <dl class="rdoc-list note-list">
+  #       <dt>true</dt>
+  #       <dd>Save session cookies as well.</dd>
+  #       <dt>false</dt>
+  #       <dd>Do not save session cookies. (default)</dd>
+  #     </dl>
+  #
+  # All options given are passed through to the underlying cookie
+  # saver module's constructor.
+  def save(writable, *options)
+    opthash = {
+      :format => :yaml,
+      :session => false,
+    }
+    case options.size
+    when 0
+    when 1
+      case options = options.first
+      when Symbol
+        opthash[:format] = options
+      else
+        if hash = Hash.try_convert(options)
+          opthash.update(hash)
+        end
+      end
+    when 2
+      opthash[:format], options = options
+      if hash = Hash.try_convert(options)
+        opthash.update(hash)
+      end
+    else
+      raise ArgumentError, 'wrong number of arguments (%d for 1-3)' % (1 + options.size)
+    end
+
+    saver = get_impl(AbstractSaver, opthash[:format], opthash)
+
+    if writable.respond_to?(:write)
+      saver.save(writable, self)
+    else
+      File.open(writable, 'w') { |io|
+        saver.save(io, self)
+      }
+    end
+
+    self
+  end
+
+  # call-seq:
+  #   jar.load(filename_or_io, **options)
+  #   jar.load(filename_or_io, format = :yaml, **options)
+  #
+  # Loads cookies recorded in a file or an IO in the format specified
+  # into the jar and returns self.  If a given object responds to
+  # \#read it is taken as an IO, or taken as a filename otherwise.
+  #
+  # Available option keywords are below:
+  #
+  # * `:format`
+  #
+  #     Specifies the format for loading.  A saver class, a symbol
+  #     addressing a saver class, or a pre-generated instance of a
+  #     saver class is accepted.
+  #
+  #     <dl class="rdoc-list note-list">
+  #       <dt>:yaml</dt>
+  #       <dd>YAML structure (default)</dd>
+  #       <dt>:cookiestxt</dt>
+  #       <dd>Mozilla's cookies.txt format</dd>
+  #     </dl>
+  #
+  # All options given are passed through to the underlying cookie
+  # saver module's constructor.
+  def load(readable, *options)
+    opthash = {
+      :format => :yaml,
+      :session => false,
+    }
+    case options.size
+    when 0
+    when 1
+      case options = options.first
+      when Symbol
+        opthash[:format] = options
+      else
+        if hash = Hash.try_convert(options)
+          opthash.update(hash)
+        end
+      end
+    when 2
+      opthash[:format], options = options
+      if hash = Hash.try_convert(options)
+        opthash.update(hash)
+      end
+    else
+      raise ArgumentError, 'wrong number of arguments (%d for 1-3)' % (1 + options.size)
+    end
+
+    saver = get_impl(AbstractSaver, opthash[:format], opthash)
+
+    if readable.respond_to?(:write)
+      saver.load(readable, self)
+    else
+      File.open(readable, 'r') { |io|
+        saver.load(io, self)
+      }
+    end
+
+    self
+  end
+
+  # Clears the cookie jar and returns self.
+  def clear
+    @store.clear
+    self
+  end
+
+  # Removes expired cookies and returns self.  If `session` is true,
+  # all session cookies are removed as well.
+  def cleanup(session = false)
+    @store.cleanup session
+    self
+  end
+end