@pact-foundation/pact-core 13.13.6 → 13.13.8

package/standalone/win32-1.91.0/pact/lib/vendor/ruby/2.4.0/gems/webrick-1.3.1/lib/webrick/httputils.rb

@@ -1,394 +0,0 @@
-#
-# httputils.rb -- HTTPUtils Module
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: httputils.rb,v 1.34 2003/06/05 21:34:08 gotoyuzo Exp $
-
-require 'socket'
-require 'tempfile'
-
-module WEBrick
-  CR   = "\x0d"
-  LF   = "\x0a"
-  CRLF = "\x0d\x0a"
-
-  module HTTPUtils
-
-    def normalize_path(path)
-      raise "abnormal path `#{path}'" if path[0] != ?/
-      ret = path.dup
-
-      ret.gsub!(%r{/+}o, '/')                    # //      => /
-      while ret.sub!(%r'/\.(?:/|\Z)', '/'); end  # /.      => /
-      while ret.sub!(%r'/(?!\.\./)[^/]+/\.\.(?:/|\Z)', '/'); end # /foo/.. => /foo
-
-      raise "abnormal path `#{path}'" if %r{/\.\.(/|\Z)} =~ ret
-      ret
-    end
-    module_function :normalize_path
-
-    #####
-
-    DefaultMimeTypes = {
-      "ai"    => "application/postscript",
-      "asc"   => "text/plain",
-      "avi"   => "video/x-msvideo",
-      "bin"   => "application/octet-stream",
-      "bmp"   => "image/bmp",
-      "class" => "application/octet-stream",
-      "cer"   => "application/pkix-cert",
-      "crl"   => "application/pkix-crl",
-      "crt"   => "application/x-x509-ca-cert",
-     #"crl"   => "application/x-pkcs7-crl",
-      "css"   => "text/css",
-      "dms"   => "application/octet-stream",
-      "doc"   => "application/msword",
-      "dvi"   => "application/x-dvi",
-      "eps"   => "application/postscript",
-      "etx"   => "text/x-setext",
-      "exe"   => "application/octet-stream",
-      "gif"   => "image/gif",
-      "htm"   => "text/html",
-      "html"  => "text/html",
-      "jpe"   => "image/jpeg",
-      "jpeg"  => "image/jpeg",
-      "jpg"   => "image/jpeg",
-      "js"    => "application/javascript",
-      "lha"   => "application/octet-stream",
-      "lzh"   => "application/octet-stream",
-      "mov"   => "video/quicktime",
-      "mpe"   => "video/mpeg",
-      "mpeg"  => "video/mpeg",
-      "mpg"   => "video/mpeg",
-      "pbm"   => "image/x-portable-bitmap",
-      "pdf"   => "application/pdf",
-      "pgm"   => "image/x-portable-graymap",
-      "png"   => "image/png",
-      "pnm"   => "image/x-portable-anymap",
-      "ppm"   => "image/x-portable-pixmap",
-      "ppt"   => "application/vnd.ms-powerpoint",
-      "ps"    => "application/postscript",
-      "qt"    => "video/quicktime",
-      "ras"   => "image/x-cmu-raster",
-      "rb"    => "text/plain",
-      "rd"    => "text/plain",
-      "rtf"   => "application/rtf",
-      "sgm"   => "text/sgml",
-      "sgml"  => "text/sgml",
-      "svg"   => "image/svg+xml",
-      "tif"   => "image/tiff",
-      "tiff"  => "image/tiff",
-      "txt"   => "text/plain",
-      "xbm"   => "image/x-xbitmap",
-      "xhtml" => "text/html",
-      "xls"   => "application/vnd.ms-excel",
-      "xml"   => "text/xml",
-      "xpm"   => "image/x-xpixmap",
-      "xwd"   => "image/x-xwindowdump",
-      "zip"   => "application/zip",
-    }
-
-    # Load Apache compatible mime.types file.
-    def load_mime_types(file)
-      open(file){ |io|
-        hash = Hash.new
-        io.each{ |line|
-          next if /^#/ =~ line
-          line.chomp!
-          mimetype, ext0 = line.split(/\s+/, 2)
-          next unless ext0
-          next if ext0.empty?
-          ext0.split(/\s+/).each{ |ext| hash[ext] = mimetype }
-        }
-        hash
-      }
-    end
-    module_function :load_mime_types
-
-    def mime_type(filename, mime_tab)
-      suffix1 = (/\.(\w+)$/ =~ filename && $1.downcase)
-      suffix2 = (/\.(\w+)\.[\w\-]+$/ =~ filename && $1.downcase)
-      mime_tab[suffix1] || mime_tab[suffix2] || "application/octet-stream"
-    end
-    module_function :mime_type
-
-    #####
-
-    def parse_header(raw)
-      header = Hash.new([].freeze)
-      field = nil
-      raw.each_line{|line|
-        case line
-        when /^([A-Za-z0-9!\#$%&'*+\-.^_`|~]+):\s*(.*?)\s*\z/om
-          field, value = $1, $2
-          field.downcase!
-          header[field] = [] unless header.has_key?(field)
-          header[field] << value
-        when /^\s+(.*?)\s*\z/om
-          value = $1
-          unless field
-            raise HTTPStatus::BadRequest, "bad header '#{line}'."
-          end
-          header[field][-1] << " " << value
-        else
-          raise HTTPStatus::BadRequest, "bad header '#{line}'."
-        end
-      }
-      header.each{|key, values|
-        values.each{|value|
-          value.strip!
-          value.gsub!(/\s+/, " ")
-        }
-      }
-      header
-    end
-    module_function :parse_header
-
-    def split_header_value(str)
-      str.scan(%r'\G((?:"(?:\\.|[^"])+?"|[^",]+)+)
-                    (?:,\s*|\Z)'xn).flatten
-    end
-    module_function :split_header_value
-
-    def parse_range_header(ranges_specifier)
-      if /^bytes=(.*)/ =~ ranges_specifier
-        byte_range_set = split_header_value($1)
-        byte_range_set.collect{|range_spec|
-          case range_spec
-          when /^(\d+)-(\d+)/ then $1.to_i .. $2.to_i
-          when /^(\d+)-/      then $1.to_i .. -1
-          when /^-(\d+)/      then -($1.to_i) .. -1
-          else return nil
-          end
-        }
-      end
-    end
-    module_function :parse_range_header
-
-    def parse_qvalues(value)
-      tmp = []
-      if value
-        parts = value.split(/,\s*/)
-        parts.each {|part|
-          if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
-            val = m[1]
-            q = (m[2] or 1).to_f
-            tmp.push([val, q])
-          end
-        }
-        tmp = tmp.sort_by{|val, q| -q}
-        tmp.collect!{|val, q| val}
-      end
-      return tmp
-    end
-    module_function :parse_qvalues
-
-    #####
-
-    def dequote(str)
-      ret = (/\A"(.*)"\Z/ =~ str) ? $1 : str.dup
-      ret.gsub!(/\\(.)/, "\\1")
-      ret
-    end
-    module_function :dequote
-
-    def quote(str)
-      '"' << str.gsub(/[\\\"]/o, "\\\1") << '"'
-    end
-    module_function :quote
-
-    #####
-
-    class FormData < String
-      EmptyRawHeader = [].freeze
-      EmptyHeader = {}.freeze
-
-      attr_accessor :name, :filename, :next_data
-      protected :next_data
-
-      def initialize(*args)
-        @name = @filename = @next_data = nil
-        if args.empty?
-          @raw_header = []
-          @header = nil
-          super("")
-        else
-          @raw_header = EmptyRawHeader
-          @header = EmptyHeader
-          super(args.shift)
-          unless args.empty?
-            @next_data = self.class.new(*args)
-          end
-        end
-      end
-
-      def [](*key)
-        begin
-          @header[key[0].downcase].join(", ")
-        rescue StandardError, NameError
-          super
-        end
-      end
-
-      def <<(str)
-        if @header
-          super
-        elsif str == CRLF
-          @header = HTTPUtils::parse_header(@raw_header.join)
-          if cd = self['content-disposition']
-            if /\s+name="(.*?)"/ =~ cd then @name = $1 end
-            if /\s+filename="(.*?)"/ =~ cd then @filename = $1 end
-          end
-        else
-          @raw_header << str
-        end
-        self
-      end
-
-      def append_data(data)
-        tmp = self
-        while tmp
-          unless tmp.next_data
-            tmp.next_data = data
-            break
-          end
-          tmp = tmp.next_data
-        end
-        self
-      end
-
-      def each_data
-        tmp = self
-        while tmp
-          next_data = tmp.next_data
-          yield(tmp)
-          tmp = next_data
-        end
-      end
-
-      def list
-        ret = []
-        each_data{|data|
-          ret << data.to_s
-        }
-        ret
-      end
-
-      alias :to_ary :list
-
-      def to_s
-        String.new(self)
-      end
-    end
-
-    def parse_query(str)
-      query = Hash.new
-      if str
-        str.split(/[&;]/).each{|x|
-          next if x.empty?
-          key, val = x.split(/=/,2)
-          key = unescape_form(key)
-          val = unescape_form(val.to_s)
-          val = FormData.new(val)
-          val.name = key
-          if query.has_key?(key)
-            query[key].append_data(val)
-            next
-          end
-          query[key] = val
-        }
-      end
-      query
-    end
-    module_function :parse_query
-
-    def parse_form_data(io, boundary)
-      boundary_regexp = /\A--#{Regexp.quote(boundary)}(--)?#{CRLF}\z/
-      form_data = Hash.new
-      return form_data unless io
-      data = nil
-      io.each_line{|line|
-        if boundary_regexp =~ line
-          if data
-            data.chop!
-            key = data.name
-            if form_data.has_key?(key)
-              form_data[key].append_data(data)
-            else
-              form_data[key] = data
-            end
-          end
-          data = FormData.new
-          next
-        else
-          if data
-            data << line
-          end
-        end
-      }
-      return form_data
-    end
-    module_function :parse_form_data
-
-    #####
-
-    reserved = ';/?:@&=+$,'
-    num      = '0123456789'
-    lowalpha = 'abcdefghijklmnopqrstuvwxyz'
-    upalpha  = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-    mark     = '-_.!~*\'()'
-    unreserved = num + lowalpha + upalpha + mark
-    control  = (0x0..0x1f).collect{|c| c.chr }.join + "\x7f"
-    space    = " "
-    delims   = '<>#%"'
-    unwise   = '{}|\\^[]`'
-    nonascii = (0x80..0xff).collect{|c| c.chr }.join
-
-    module_function
-
-    def _make_regex(str) /([#{Regexp.escape(str)}])/n end
-    def _make_regex!(str) /([^#{Regexp.escape(str)}])/n end
-    def _escape(str, regex) str.gsub(regex){ "%%%02X" % $1.ord } end
-    def _unescape(str, regex) str.gsub(regex){ $1.hex.chr } end
-
-    UNESCAPED = _make_regex(control+space+delims+unwise+nonascii)
-    UNESCAPED_FORM = _make_regex(reserved+control+delims+unwise+nonascii)
-    NONASCII  = _make_regex(nonascii)
-    ESCAPED   = /%([0-9a-fA-F]{2})/
-    UNESCAPED_PCHAR = _make_regex!(unreserved+":@&=+$,")
-
-    def escape(str)
-      _escape(str, UNESCAPED)
-    end
-
-    def unescape(str)
-      _unescape(str, ESCAPED)
-    end
-
-    def escape_form(str)
-      ret = _escape(str, UNESCAPED_FORM)
-      ret.gsub!(/ /, "+")
-      ret
-    end
-
-    def unescape_form(str)
-      _unescape(str.gsub(/\+/, " "), ESCAPED)
-    end
-
-    def escape_path(str)
-      result = ""
-      str.scan(%r{/([^/]*)}).each{|i|
-        result << "/" << _escape(i[0], UNESCAPED_PCHAR)
-      }
-      return result
-    end
-
-    def escape8bit(str)
-      _escape(str, NONASCII)
-    end
-  end
-end

package/standalone/win32-1.91.0/pact/lib/vendor/ruby/2.4.0/gems/webrick-1.3.1/lib/webrick/httpversion.rb

@@ -1,49 +0,0 @@
-#--
-# HTTPVersion.rb -- presentation of HTTP version
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: httpversion.rb,v 1.5 2002/09/21 12:23:37 gotoyuzo Exp $
-
-module WEBrick
-  class HTTPVersion
-    include Comparable
-
-    attr_accessor :major, :minor
-
-    def self.convert(version)
-      version.is_a?(self) ? version : new(version)
-    end
-
-    def initialize(version)
-      case version
-      when HTTPVersion
-        @major, @minor = version.major, version.minor
-      when String
-        if /^(\d+)\.(\d+)$/ =~ version
-          @major, @minor = $1.to_i, $2.to_i
-        end
-      end
-      if @major.nil? || @minor.nil?
-        raise ArgumentError,
-          format("cannot convert %s into %s", version.class, self.class)
-      end
-    end
-
-    def <=>(other)
-      unless other.is_a?(self.class)
-        other = self.class.new(other)
-      end
-      if (ret = @major <=> other.major) == 0
-        return @minor <=> other.minor
-      end
-      return ret
-    end
-
-    def to_s
-      format("%d.%d", @major, @minor)
-    end
-  end
-end

package/standalone/win32-1.91.0/pact/lib/vendor/ruby/2.4.0/gems/webrick-1.3.1/lib/webrick/log.rb

@@ -1,136 +0,0 @@
-#--
-# log.rb -- Log Class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: log.rb,v 1.26 2002/10/06 17:06:10 gotoyuzo Exp $
-
-module WEBrick
-
-  ##
-  # A generic logging class
-
-  class BasicLog
-    # log-level constants
-    FATAL, ERROR, WARN, INFO, DEBUG = 1, 2, 3, 4, 5
-
-    # log-level, messages above this level will be logged
-    attr_accessor :level
-
-    ##
-    # Initializes a new logger for +log_file+ that outputs messages at +level+
-    # or higher.  +log_file+ can be a filename, an IO-like object that
-    # responds to #<< or nil which outputs to $stderr.
-    #
-    # If no level is given INFO is chosen by default
-
-    def initialize(log_file=nil, level=nil)
-      @level = level || INFO
-      case log_file
-      when String
-        @log = open(log_file, "a+")
-        @log.sync = true
-        @opened = true
-      when NilClass
-        @log = $stderr
-      else
-        @log = log_file  # requires "<<". (see BasicLog#log)
-      end
-    end
-
-    ##
-    # Closes the logger (also closes the log device associated to the logger)
-    def close
-      @log.close if @opened
-      @log = nil
-    end
-
-    ##
-    # Logs +data+ at +level+ if the given level is above the current log
-    # level.
-
-    def log(level, data)
-      if @log && level <= @level
-        data += "\n" if /\n\Z/ !~ data
-        @log << data
-      end
-    end
-
-    ##
-    # Synonym for log(INFO, obj.to_s)
-    def <<(obj)
-      log(INFO, obj.to_s)
-    end
-
-    # Shortcut for logging a FATAL message
-    def fatal(msg) log(FATAL, "FATAL " << format(msg)); end
-    # Shortcut for logging an ERROR message
-    def error(msg) log(ERROR, "ERROR " << format(msg)); end
-    # Shortcut for logging a WARN message
-    def warn(msg)  log(WARN,  "WARN  " << format(msg)); end
-    # Shortcut for logging an INFO message
-    def info(msg)  log(INFO,  "INFO  " << format(msg)); end
-    # Shortcut for logging a DEBUG message
-    def debug(msg) log(DEBUG, "DEBUG " << format(msg)); end
-
-    # Will the logger output FATAL messages?
-    def fatal?; @level >= FATAL; end
-    # Will the logger output ERROR messages?
-    def error?; @level >= ERROR; end
-    # Will the logger output WARN messages?
-    def warn?;  @level >= WARN; end
-    # Will the logger output INFO messages?
-    def info?;  @level >= INFO; end
-    # Will the logger output DEBUG messages?
-    def debug?; @level >= DEBUG; end
-
-    private
-
-    ##
-    # Formats +arg+ for the logger
-    #
-    # * If +arg+ is an Exception, it will format the error message and
-    #   the back trace.
-    # * If +arg+ responds to #to_str, it will return it.
-    # * Otherwise it will return +arg+.inspect.
-    def format(arg)
-      if arg.is_a?(Exception)
-        "#{arg.class}: #{arg.message}\n\t" <<
-        arg.backtrace.join("\n\t") << "\n"
-      elsif arg.respond_to?(:to_str)
-        arg.to_str
-      else
-        arg.inspect
-      end
-    end
-  end
-
-  ##
-  # A logging class that prepends a timestamp to each message.
-
-  class Log < BasicLog
-    # Format of the timestamp which is applied to each logged line.  The
-    # default is <tt>"[%Y-%m-%d %H:%M:%S]"</tt>
-    attr_accessor :time_format
-
-    ##
-    # Same as BasicLog#initialize
-    #
-    # You can set the timestamp format through #time_format
-    def initialize(log_file=nil, level=nil)
-      super(log_file, level)
-      @time_format = "[%Y-%m-%d %H:%M:%S]"
-    end
-
-    ##
-    # Same as BasicLog#log
-    def log(level, data)
-      tmp = Time.now.strftime(@time_format)
-      tmp << " " << data
-      super(level, tmp)
-    end
-  end
-end