@shopify/cli-kit 3.38.0 → 3.40.0

package/assets/cli-ruby/vendor/deps/webrick/lib/webrick/httpserver.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+#
+# httpserver.rb -- HTTPServer 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: httpserver.rb,v 1.63 2002/10/01 17:16:32 gotoyuzo Exp $
+
+require 'io/wait'
+require_relative 'server'
+require_relative 'httputils'
+require_relative 'httpstatus'
+require_relative 'httprequest'
+require_relative 'httpresponse'
+require_relative 'httpservlet'
+require_relative 'accesslog'
+
+module WEBrick
+  class HTTPServerError < ServerError; end
+
+  ##
+  # An HTTP Server
+
+  class HTTPServer < ::WEBrick::GenericServer
+    ##
+    # Creates a new HTTP server according to +config+
+    #
+    # An HTTP server uses the following attributes:
+    #
+    # :AccessLog:: An array of access logs.  See WEBrick::AccessLog
+    # :BindAddress:: Local address for the server to bind to
+    # :DocumentRoot:: Root path to serve files from
+    # :DocumentRootOptions:: Options for the default HTTPServlet::FileHandler
+    # :HTTPVersion:: The HTTP version of this server
+    # :Port:: Port to listen on
+    # :RequestCallback:: Called with a request and response before each
+    #                    request is serviced.
+    # :RequestTimeout:: Maximum time to wait between requests
+    # :ServerAlias:: Array of alternate names for this server for virtual
+    #                hosting
+    # :ServerName:: Name for this server for virtual hosting
+
+    def initialize(config={}, default=Config::HTTP)
+      super(config, default)
+      @http_version = HTTPVersion::convert(@config[:HTTPVersion])
+
+      @mount_tab = MountTable.new
+      if @config[:DocumentRoot]
+        mount("/", HTTPServlet::FileHandler, @config[:DocumentRoot],
+              @config[:DocumentRootOptions])
+      end
+
+      unless @config[:AccessLog]
+        @config[:AccessLog] = [
+          [ $stderr, AccessLog::COMMON_LOG_FORMAT ],
+          [ $stderr, AccessLog::REFERER_LOG_FORMAT ]
+        ]
+      end
+
+      @virtual_hosts = Array.new
+    end
+
+    ##
+    # Processes requests on +sock+
+
+    def run(sock)
+      while true
+        req = create_request(@config)
+        res = create_response(@config)
+        server = self
+        begin
+          timeout = @config[:RequestTimeout]
+          while timeout > 0
+            break if sock.to_io.wait_readable(0.5)
+            break if @status != :Running
+            timeout -= 0.5
+          end
+          raise HTTPStatus::EOFError if timeout <= 0 || @status != :Running
+          raise HTTPStatus::EOFError if sock.eof?
+          req.parse(sock)
+          res.request_method = req.request_method
+          res.request_uri = req.request_uri
+          res.request_http_version = req.http_version
+          res.keep_alive = req.keep_alive?
+          server = lookup_server(req) || self
+          if callback = server[:RequestCallback]
+            callback.call(req, res)
+          elsif callback = server[:RequestHandler]
+            msg = ":RequestHandler is deprecated, please use :RequestCallback"
+            @logger.warn(msg)
+            callback.call(req, res)
+          end
+          server.service(req, res)
+        rescue HTTPStatus::EOFError, HTTPStatus::RequestTimeout => ex
+          res.set_error(ex)
+        rescue HTTPStatus::Error => ex
+          @logger.error(ex.message)
+          res.set_error(ex)
+        rescue HTTPStatus::Status => ex
+          res.status = ex.code
+        rescue StandardError => ex
+          @logger.error(ex)
+          res.set_error(ex, true)
+        ensure
+          if req.request_line
+            if req.keep_alive? && res.keep_alive?
+              req.fixup()
+            end
+            res.send_response(sock)
+            server.access_log(@config, req, res)
+          end
+        end
+        break if @http_version < "1.1"
+        break unless req.keep_alive?
+        break unless res.keep_alive?
+      end
+    end
+
+    ##
+    # Services +req+ and fills in +res+
+
+    def service(req, res)
+      if req.unparsed_uri == "*"
+        if req.request_method == "OPTIONS"
+          do_OPTIONS(req, res)
+          raise HTTPStatus::OK
+        end
+        raise HTTPStatus::NotFound, "`#{req.unparsed_uri}' not found."
+      end
+
+      servlet, options, script_name, path_info = search_servlet(req.path)
+      raise HTTPStatus::NotFound, "`#{req.path}' not found." unless servlet
+      req.script_name = script_name
+      req.path_info = path_info
+      si = servlet.get_instance(self, *options)
+      @logger.debug(format("%s is invoked.", si.class.name))
+      si.service(req, res)
+    end
+
+    ##
+    # The default OPTIONS request handler says GET, HEAD, POST and OPTIONS
+    # requests are allowed.
+
+    def do_OPTIONS(req, res)
+      res["allow"] = "GET,HEAD,POST,OPTIONS"
+    end
+
+    ##
+    # Mounts +servlet+ on +dir+ passing +options+ to the servlet at creation
+    # time
+
+    def mount(dir, servlet, *options)
+      @logger.debug(sprintf("%s is mounted on %s.", servlet.inspect, dir))
+      @mount_tab[dir] = [ servlet, options ]
+    end
+
+    ##
+    # Mounts +proc+ or +block+ on +dir+ and calls it with a
+    # WEBrick::HTTPRequest and WEBrick::HTTPResponse
+
+    def mount_proc(dir, proc=nil, &block)
+      proc ||= block
+      raise HTTPServerError, "must pass a proc or block" unless proc
+      mount(dir, HTTPServlet::ProcHandler.new(proc))
+    end
+
+    ##
+    # Unmounts +dir+
+
+    def unmount(dir)
+      @logger.debug(sprintf("unmount %s.", dir))
+      @mount_tab.delete(dir)
+    end
+    alias umount unmount
+
+    ##
+    # Finds a servlet for +path+
+
+    def search_servlet(path)
+      script_name, path_info = @mount_tab.scan(path)
+      servlet, options = @mount_tab[script_name]
+      if servlet
+        [ servlet, options, script_name, path_info ]
+      end
+    end
+
+    ##
+    # Adds +server+ as a virtual host.
+
+    def virtual_host(server)
+      @virtual_hosts << server
+      @virtual_hosts = @virtual_hosts.sort_by{|s|
+        num = 0
+        num -= 4 if s[:BindAddress]
+        num -= 2 if s[:Port]
+        num -= 1 if s[:ServerName]
+        num
+      }
+    end
+
+    ##
+    # Finds the appropriate virtual host to handle +req+
+
+    def lookup_server(req)
+      @virtual_hosts.find{|s|
+        (s[:BindAddress].nil? || req.addr[3] == s[:BindAddress]) &&
+        (s[:Port].nil?        || req.port == s[:Port])           &&
+        ((s[:ServerName].nil?  || req.host == s[:ServerName]) ||
+         (!s[:ServerAlias].nil? && s[:ServerAlias].find{|h| h === req.host}))
+      }
+    end
+
+    ##
+    # Logs +req+ and +res+ in the access logs.  +config+ is used for the
+    # server name.
+
+    def access_log(config, req, res)
+      param = AccessLog::setup_params(config, req, res)
+      @config[:AccessLog].each{|logger, fmt|
+        logger << AccessLog::format(fmt+"\n", param)
+      }
+    end
+
+    ##
+    # Creates the HTTPRequest used when handling the HTTP
+    # request. Can be overridden by subclasses.
+    def create_request(with_webrick_config)
+      HTTPRequest.new(with_webrick_config)
+    end
+
+    ##
+    # Creates the HTTPResponse used when handling the HTTP
+    # request. Can be overridden by subclasses.
+    def create_response(with_webrick_config)
+      HTTPResponse.new(with_webrick_config)
+    end
+
+    ##
+    # Mount table for the path a servlet is mounted on in the directory space
+    # of the server.  Users of WEBrick can only access this indirectly via
+    # WEBrick::HTTPServer#mount, WEBrick::HTTPServer#unmount and
+    # WEBrick::HTTPServer#search_servlet
+
+    class MountTable # :nodoc:
+      def initialize
+        @tab = Hash.new
+        compile
+      end
+
+      def [](dir)
+        dir = normalize(dir)
+        @tab[dir]
+      end
+
+      def []=(dir, val)
+        dir = normalize(dir)
+        @tab[dir] = val
+        compile
+        val
+      end
+
+      def delete(dir)
+        dir = normalize(dir)
+        res = @tab.delete(dir)
+        compile
+        res
+      end
+
+      def scan(path)
+        @scanner =~ path
+        [ $&, $' ]
+      end
+
+      private
+
+      def compile
+        k = @tab.keys
+        k.sort!
+        k.reverse!
+        k.collect!{|path| Regexp.escape(path) }
+        @scanner = Regexp.new("\\A(" + k.join("|") +")(?=/|\\z)")
+      end
+
+      def normalize(dir)
+        ret = dir ? dir.dup : +""
+        ret.sub!(%r|/+\z|, "")
+        ret
+      end
+    end
+  end
+end

package/assets/cli-ruby/vendor/deps/webrick/lib/webrick/httpservlet/abstract.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+#
+# httpservlet.rb -- HTTPServlet Module
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2000 TAKAHASHI Masayoshi, GOTOU Yuuzou
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $IPR: abstract.rb,v 1.24 2003/07/11 11:16:46 gotoyuzo Exp $
+
+require_relative '../htmlutils'
+require_relative '../httputils'
+require_relative '../httpstatus'
+
+module WEBrick
+  module HTTPServlet
+    class HTTPServletError < StandardError; end
+
+    ##
+    # AbstractServlet allows HTTP server modules to be reused across multiple
+    # servers and allows encapsulation of functionality.
+    #
+    # By default a servlet will respond to GET, HEAD (through an alias to GET)
+    # and OPTIONS requests.
+    #
+    # By default a new servlet is initialized for every request.  A servlet
+    # instance can be reused by overriding ::get_instance in the
+    # AbstractServlet subclass.
+    #
+    # == A Simple Servlet
+    #
+    #  class Simple < WEBrick::HTTPServlet::AbstractServlet
+    #    def do_GET request, response
+    #      status, content_type, body = do_stuff_with request
+    #
+    #      response.status = status
+    #      response['Content-Type'] = content_type
+    #      response.body = body
+    #    end
+    #
+    #    def do_stuff_with request
+    #      return 200, 'text/plain', 'you got a page'
+    #    end
+    #  end
+    #
+    # This servlet can be mounted on a server at a given path:
+    #
+    #   server.mount '/simple', Simple
+    #
+    # == Servlet Configuration
+    #
+    # Servlets can be configured via initialize.  The first argument is the
+    # HTTP server the servlet is being initialized for.
+    #
+    #  class Configurable < Simple
+    #    def initialize server, color, size
+    #      super server
+    #      @color = color
+    #      @size = size
+    #    end
+    #
+    #    def do_stuff_with request
+    #      content = "<p " \
+    #                %q{style="color: #{@color}; font-size: #{@size}"} \
+    #                ">Hello, World!"
+    #
+    #      return 200, "text/html", content
+    #    end
+    #  end
+    #
+    # This servlet must be provided two arguments at mount time:
+    #
+    #   server.mount '/configurable', Configurable, 'red', '2em'
+
+    class AbstractServlet
+
+      ##
+      # Factory for servlet instances that will handle a request from +server+
+      # using +options+ from the mount point.  By default a new servlet
+      # instance is created for every call.
+
+      def self.get_instance(server, *options)
+        self.new(server, *options)
+      end
+
+      ##
+      # Initializes a new servlet for +server+ using +options+ which are
+      # stored as-is in +@options+.  +@logger+ is also provided.
+
+      def initialize(server, *options)
+        @server = @config = server
+        @logger = @server[:Logger]
+        @options = options
+      end
+
+      ##
+      # Dispatches to a +do_+ method based on +req+ if such a method is
+      # available.  (+do_GET+ for a GET request).  Raises a MethodNotAllowed
+      # exception if the method is not implemented.
+
+      def service(req, res)
+        method_name = "do_" + req.request_method.gsub(/-/, "_")
+        if respond_to?(method_name)
+          __send__(method_name, req, res)
+        else
+          raise HTTPStatus::MethodNotAllowed,
+                "unsupported method `#{req.request_method}'."
+        end
+      end
+
+      ##
+      # Raises a NotFound exception
+
+      def do_GET(req, res)
+        raise HTTPStatus::NotFound, "not found."
+      end
+
+      ##
+      # Dispatches to do_GET
+
+      def do_HEAD(req, res)
+        do_GET(req, res)
+      end
+
+      ##
+      # Returns the allowed HTTP request methods
+
+      def do_OPTIONS(req, res)
+        m = self.methods.grep(/\Ado_([A-Z]+)\z/) {$1}
+        m.sort!
+        res["allow"] = m.join(",")
+      end
+
+      private
+
+      ##
+      # Redirects to a path ending in /
+
+      def redirect_to_directory_uri(req, res)
+        if req.path[-1] != ?/
+          location = WEBrick::HTTPUtils.escape_path(req.path + "/")
+          if req.query_string && req.query_string.bytesize > 0
+            location << "?" << req.query_string
+          end
+          res.set_redirect(HTTPStatus::MovedPermanently, location)
+        end
+      end
+    end
+
+  end
+end

package/assets/cli-ruby/vendor/deps/webrick/lib/webrick/httpservlet/cgi_runner.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+#
+# cgi_runner.rb -- CGI launcher.
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2000 TAKAHASHI Masayoshi, GOTOU YUUZOU
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $IPR: cgi_runner.rb,v 1.9 2002/09/25 11:33:15 gotoyuzo Exp $
+
+def sysread(io, size)
+  buf = +""
+  while size > 0
+    tmp = io.sysread(size)
+    buf << tmp
+    size -= tmp.bytesize
+  end
+  return buf
+end
+
+STDIN.binmode
+
+len = sysread(STDIN, 8).to_i
+out = sysread(STDIN, len)
+STDOUT.reopen(File.open(out, "w"))
+
+len = sysread(STDIN, 8).to_i
+err = sysread(STDIN, len)
+STDERR.reopen(File.open(err, "w"))
+
+len  = sysread(STDIN, 8).to_i
+dump = sysread(STDIN, len)
+hash = Marshal.restore(dump)
+ENV.keys.each{|name| ENV.delete(name) }
+hash.each{|k, v| ENV[k] = v if v }
+
+dir = File::dirname(ENV["SCRIPT_FILENAME"])
+Dir::chdir dir
+
+if ARGV[0]
+  argv = ARGV.dup
+  argv << ENV["SCRIPT_FILENAME"]
+  exec(*argv)
+  # NOTREACHED
+end
+exec ENV["SCRIPT_FILENAME"]

package/assets/cli-ruby/vendor/deps/webrick/lib/webrick/httpservlet/cgihandler.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+#
+# cgihandler.rb -- CGIHandler Class
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $IPR: cgihandler.rb,v 1.27 2003/03/21 19:56:01 gotoyuzo Exp $
+
+require 'rbconfig'
+require 'tempfile'
+require_relative '../config'
+require_relative 'abstract'
+
+module WEBrick
+  module HTTPServlet
+
+    ##
+    # Servlet for handling CGI scripts
+    #
+    # Example:
+    #
+    #  server.mount('/cgi/my_script', WEBrick::HTTPServlet::CGIHandler,
+    #               '/path/to/my_script')
+
+    class CGIHandler < AbstractServlet
+      Ruby = RbConfig.ruby # :nodoc:
+      CGIRunner = "\"#{Ruby}\" \"#{WEBrick::Config::LIBDIR}/httpservlet/cgi_runner.rb\"" # :nodoc:
+      CGIRunnerArray = [Ruby, "#{WEBrick::Config::LIBDIR}/httpservlet/cgi_runner.rb".freeze].freeze # :nodoc:
+
+      ##
+      # Creates a new CGI script servlet for the script at +name+
+
+      def initialize(server, name)
+        super(server, name)
+        @script_filename = name
+        @tempdir = server[:TempDir]
+        interpreter = server[:CGIInterpreter]
+        if interpreter.is_a?(Array)
+          @cgicmd = CGIRunnerArray + interpreter
+        else
+          @cgicmd = "#{CGIRunner} #{interpreter}"
+        end
+      end
+
+      # :stopdoc:
+
+      def do_GET(req, res)
+        cgi_in = IO::popen(@cgicmd, "wb")
+        cgi_out = Tempfile.new("webrick.cgiout.", @tempdir, mode: IO::BINARY)
+        cgi_out.set_encoding("ASCII-8BIT")
+        cgi_err = Tempfile.new("webrick.cgierr.", @tempdir, mode: IO::BINARY)
+        cgi_err.set_encoding("ASCII-8BIT")
+        begin
+          cgi_in.sync = true
+          meta = req.meta_vars
+          meta["SCRIPT_FILENAME"] = @script_filename
+          meta["PATH"] = @config[:CGIPathEnv]
+          meta.delete("HTTP_PROXY")
+          if /mswin|bccwin|mingw/ =~ RUBY_PLATFORM
+            meta["SystemRoot"] = ENV["SystemRoot"]
+          end
+          dump = Marshal.dump(meta)
+
+          cgi_in.write("%8d" % cgi_out.path.bytesize)
+          cgi_in.write(cgi_out.path)
+          cgi_in.write("%8d" % cgi_err.path.bytesize)
+          cgi_in.write(cgi_err.path)
+          cgi_in.write("%8d" % dump.bytesize)
+          cgi_in.write(dump)
+
+          req.body { |chunk| cgi_in.write(chunk) }
+        ensure
+          cgi_in.close
+          status = $?.exitstatus
+          sleep 0.1 if /mswin|bccwin|mingw/ =~ RUBY_PLATFORM
+          data = cgi_out.read
+          cgi_out.close(true)
+          if errmsg = cgi_err.read
+            if errmsg.bytesize > 0
+              @logger.error("CGIHandler: #{@script_filename}:\n" + errmsg)
+            end
+          end
+          cgi_err.close(true)
+        end
+
+        if status != 0
+          @logger.error("CGIHandler: #{@script_filename} exit with #{status}")
+        end
+
+        data = "" unless data
+        raw_header, body = data.split(/^[\xd\xa]+/, 2)
+        raise HTTPStatus::InternalServerError,
+          "Premature end of script headers: #{@script_filename}" if body.nil?
+
+        begin
+          header = HTTPUtils::parse_header(raw_header)
+          if /^(\d+)/ =~ header['status'][0]
+            res.status = $1.to_i
+            header.delete('status')
+          end
+          if header.has_key?('location')
+            # RFC 3875 6.2.3, 6.2.4
+            res.status = 302 unless (300...400) === res.status
+          end
+          if header.has_key?('set-cookie')
+            header['set-cookie'].each{|k|
+              res.cookies << Cookie.parse_set_cookie(k)
+            }
+            header.delete('set-cookie')
+          end
+          header.each{|key, val| res[key] = val.join(", ") }
+        rescue => ex
+          raise HTTPStatus::InternalServerError, ex.message
+        end
+        res.body = body
+      end
+      alias do_POST do_GET
+
+      # :startdoc:
+    end
+
+  end
+end

package/assets/cli-ruby/vendor/deps/webrick/lib/webrick/httpservlet/erbhandler.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+#
+# erbhandler.rb -- ERBHandler Class
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $IPR: erbhandler.rb,v 1.25 2003/02/24 19:25:31 gotoyuzo Exp $
+
+require_relative 'abstract'
+
+require 'erb'
+
+module WEBrick
+  module HTTPServlet
+
+    ##
+    # ERBHandler evaluates an ERB file and returns the result.  This handler
+    # is automatically used if there are .rhtml files in a directory served by
+    # the FileHandler.
+    #
+    # ERBHandler supports GET and POST methods.
+    #
+    # The ERB file is evaluated with the local variables +servlet_request+ and
+    # +servlet_response+ which are a WEBrick::HTTPRequest and
+    # WEBrick::HTTPResponse respectively.
+    #
+    # Example .rhtml file:
+    #
+    #   Request to <%= servlet_request.request_uri %>
+    #
+    #   Query params <%= servlet_request.query.inspect %>
+
+    class ERBHandler < AbstractServlet
+
+      ##
+      # Creates a new ERBHandler on +server+ that will evaluate and serve the
+      # ERB file +name+
+
+      def initialize(server, name)
+        super(server, name)
+        @script_filename = name
+      end
+
+      ##
+      # Handles GET requests
+
+      def do_GET(req, res)
+        unless defined?(ERB)
+          @logger.warn "#{self.class}: ERB not defined."
+          raise HTTPStatus::Forbidden, "ERBHandler cannot work."
+        end
+        begin
+          data = File.open(@script_filename, &:read)
+          res.body = evaluate(ERB.new(data), req, res)
+          res['content-type'] ||=
+            HTTPUtils::mime_type(@script_filename, @config[:MimeTypes])
+        rescue StandardError
+          raise
+        rescue Exception => ex
+          @logger.error(ex)
+          raise HTTPStatus::InternalServerError, ex.message
+        end
+      end
+
+      ##
+      # Handles POST requests
+
+      alias do_POST do_GET
+
+      private
+
+      ##
+      # Evaluates +erb+ providing +servlet_request+ and +servlet_response+ as
+      # local variables.
+
+      def evaluate(erb, servlet_request, servlet_response)
+        Module.new.module_eval{
+          servlet_request.meta_vars
+          servlet_request.query
+          erb.result(binding)
+        }
+      end
+    end
+  end
+end