serrano-vk 0.1.0

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/lib/webrick.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: false
+##
+# = WEB server toolkit.
+#
+# WEBrick is an HTTP server toolkit that can be configured as an HTTPS server,
+# a proxy server, and a virtual-host server.  WEBrick features complete
+# logging of both server operations and HTTP access.  WEBrick supports both
+# basic and digest authentication in addition to algorithms not in RFC 2617.
+#
+# A WEBrick server can be composed of multiple WEBrick servers or servlets to
+# provide differing behavior on a per-host or per-path basis.  WEBrick
+# includes servlets for handling CGI scripts, ERB pages, Ruby blocks and
+# directory listings.
+#
+# WEBrick also includes tools for daemonizing a process and starting a process
+# at a higher privilege level and dropping permissions.
+#
+# == Security
+#
+# *Warning:* WEBrick is not recommended for production.  It only implements
+# basic security checks.
+#
+# == Starting an HTTP server
+#
+# To create a new WEBrick::HTTPServer that will listen to connections on port
+# 8000 and serve documents from the current user's public_html folder:
+#
+#   require 'webrick'
+#
+#   root = File.expand_path '~/public_html'
+#   server = WEBrick::HTTPServer.new :Port => 8000, :DocumentRoot => root
+#
+# To run the server you will need to provide a suitable shutdown hook as
+# starting the server blocks the current thread:
+#
+#   trap 'INT' do server.shutdown end
+#
+#   server.start
+#
+# == Custom Behavior
+#
+# The easiest way to have a server perform custom operations is through
+# WEBrick::HTTPServer#mount_proc.  The block given will be called with a
+# WEBrick::HTTPRequest with request info and a WEBrick::HTTPResponse which
+# must be filled in appropriately:
+#
+#   server.mount_proc '/' do |req, res|
+#     res.body = 'Hello, world!'
+#   end
+#
+# Remember that +server.mount_proc+ must precede +server.start+.
+#
+# == Servlets
+#
+# Advanced custom behavior can be obtained through mounting a subclass of
+# WEBrick::HTTPServlet::AbstractServlet.  Servlets provide more modularity
+# when writing an HTTP server than mount_proc allows.  Here is a simple
+# servlet:
+#
+#   class Simple < WEBrick::HTTPServlet::AbstractServlet
+#     def do_GET request, response
+#       status, content_type, body = do_stuff_with request
+#
+#       response.status = 200
+#       response['Content-Type'] = 'text/plain'
+#       response.body = 'Hello, World!'
+#     end
+#   end
+#
+# To initialize the servlet you mount it on the server:
+#
+#   server.mount '/simple', Simple
+#
+# See WEBrick::HTTPServlet::AbstractServlet for more details.
+#
+# == Virtual Hosts
+#
+# A server can act as a virtual host for multiple host names.  After creating
+# the listening host, additional hosts that do not listen can be created and
+# attached as virtual hosts:
+#
+#   server = WEBrick::HTTPServer.new # ...
+#
+#   vhost = WEBrick::HTTPServer.new :ServerName => 'vhost.example',
+#                                   :DoNotListen => true, # ...
+#   vhost.mount '/', ...
+#
+#   server.virtual_host vhost
+#
+# If no +:DocumentRoot+ is provided and no servlets or procs are mounted on the
+# main server it will return 404 for all URLs.
+#
+# == HTTPS
+#
+# To create an HTTPS server you only need to enable SSL and provide an SSL
+# certificate name:
+#
+#   require 'webrick'
+#   require 'webrick/https'
+#
+#   cert_name = [
+#     %w[CN localhost],
+#   ]
+#
+#   server = WEBrick::HTTPServer.new(:Port => 8000,
+#                                    :SSLEnable => true,
+#                                    :SSLCertName => cert_name)
+#
+# This will start the server with a self-generated self-signed certificate.
+# The certificate will be changed every time the server is restarted.
+#
+# To create a server with a pre-determined key and certificate you can provide
+# them:
+#
+#   require 'webrick'
+#   require 'webrick/https'
+#   require 'openssl'
+#
+#   cert = OpenSSL::X509::Certificate.new File.read '/path/to/cert.pem'
+#   pkey = OpenSSL::PKey::RSA.new File.read '/path/to/pkey.pem'
+#
+#   server = WEBrick::HTTPServer.new(:Port => 8000,
+#                                    :SSLEnable => true,
+#                                    :SSLCertificate => cert,
+#                                    :SSLPrivateKey => pkey)
+#
+# == Proxy Server
+#
+# WEBrick can act as a proxy server:
+#
+#   require 'webrick'
+#   require 'webrick/httpproxy'
+#
+#   proxy = WEBrick::HTTPProxyServer.new :Port => 8000
+#
+#   trap 'INT' do proxy.shutdown end
+#
+# See WEBrick::HTTPProxy for further details including modifying proxied
+# responses.
+#
+# == Basic and Digest authentication
+#
+# WEBrick provides both Basic and Digest authentication for regular and proxy
+# servers.  See WEBrick::HTTPAuth, WEBrick::HTTPAuth::BasicAuth and
+# WEBrick::HTTPAuth::DigestAuth.
+#
+# == WEBrick as a daemonized Web Server
+#
+# WEBrick can be run as a daemonized server for small loads.
+#
+# === Daemonizing
+#
+# To start a WEBrick server as a daemon simple run WEBrick::Daemon.start
+# before starting the server.
+#
+# === Dropping Permissions
+#
+# WEBrick can be started as one user to gain permission to bind to port 80 or
+# 443 for serving HTTP or HTTPS traffic then can drop these permissions for
+# regular operation.  To listen on all interfaces for HTTP traffic:
+#
+#   sockets = WEBrick::Utils.create_listeners nil, 80
+#
+# Then drop privileges:
+#
+#   WEBrick::Utils.su 'www'
+#
+# Then create a server that does not listen by default:
+#
+#   server = WEBrick::HTTPServer.new :DoNotListen => true, # ...
+#
+# Then overwrite the listening sockets with the port 80 sockets:
+#
+#   server.listeners.replace sockets
+#
+# === Logging
+#
+# WEBrick can separately log server operations and end-user access.  For
+# server operations:
+#
+#   log_file = File.open '/var/log/webrick.log', 'a+'
+#   log = WEBrick::Log.new log_file
+#
+# For user access logging:
+#
+#   access_log = [
+#     [log_file, WEBrick::AccessLog::COMBINED_LOG_FORMAT],
+#   ]
+#
+#   server = WEBrick::HTTPServer.new :Logger => log, :AccessLog => access_log
+#
+# See WEBrick::AccessLog for further log formats.
+#
+# === Log Rotation
+#
+# To rotate logs in WEBrick on a HUP signal (like syslogd can send), open the
+# log file in 'a+' mode (as above) and trap 'HUP' to reopen the log file:
+#
+#   trap 'HUP' do log_file.reopen '/path/to/webrick.log', 'a+'
+#
+# == Copyright
+#
+# 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: webrick.rb,v 1.12 2002/10/01 17:16:31 gotoyuzo Exp $
+
+module WEBrick
+end
+
+require 'webrick/compat.rb'
+
+require 'webrick/version.rb'
+require 'webrick/config.rb'
+require 'webrick/log.rb'
+require 'webrick/server.rb'
+require_relative 'webrick/utils.rb'
+require 'webrick/accesslog'
+
+require 'webrick/htmlutils.rb'
+require 'webrick/httputils.rb'
+require 'webrick/cookie.rb'
+require 'webrick/httpversion.rb'
+require 'webrick/httpstatus.rb'
+require 'webrick/httprequest.rb'
+require 'webrick/httpresponse.rb'
+require 'webrick/httpserver.rb'
+require 'webrick/httpservlet.rb'
+require 'webrick/httpauth.rb'

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/accesslog.rbs

@@ -0,0 +1,24 @@
+module WEBrick
+  module AccessLog
+    class AccessLogError < StandardError
+    end
+
+    CLF_TIME_FORMAT: String
+
+    COMMON_LOG_FORMAT: String
+
+    CLF: String
+
+    REFERER_LOG_FORMAT: String
+
+    AGENT_LOG_FORMAT: String
+
+    COMBINED_LOG_FORMAT: String
+
+    def self?.setup_params: (Hash[Symbol, untyped] config, HTTPRequest req, HTTPResponse res) -> Hash[String, untyped]
+
+    def self?.format: (String format_string, Hash[String, untyped] params) -> String
+
+    def self?.escape: (String data) -> String
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/cgi.rbs

@@ -0,0 +1,92 @@
+module WEBrick
+  class CGI
+    @options: Array[untyped]
+
+    class CGIError < StandardError
+    end
+
+    attr_reader config: Hash[Symbol, untyped]
+
+    attr_reader logger: BasicLog
+
+    def initialize: (*untyped args) -> void
+
+    def []: (Symbol key) -> untyped
+
+    interface _Env
+      def []: (String) -> String?
+    end
+
+    def start: (?_Env env, ?IO stdin, ?IO stdout) -> void
+
+    def self.setup_header: () -> untyped
+
+    def self.status_line: () -> ""
+
+    def service: (HTTPRequest req, HTTPResponse res) -> void
+
+    class Socket
+      @config: Hash[Symbol, untyped]
+
+      @env: _Env
+
+      @header_part: StringIO
+
+      @body_part: IO
+
+      @out_port: IO
+
+      @server_addr: String
+
+      @server_name: String?
+
+      @server_port: String?
+
+      @remote_addr: String?
+
+      @remote_host: String?
+
+      @remote_port: (String | 0)
+
+      include Enumerable[String]
+
+      private
+
+      def initialize: (Hash[Symbol, untyped] config, _Env env, IO stdin, IO stdout) -> void
+
+      def request_line: () -> String
+
+      def setup_header: () -> void
+
+      def add_header: (String hdrname, String value) -> void
+
+      def input: () -> (IO | StringIO)
+
+      public
+
+      def peeraddr: () -> [nil, (String | 0), String?, String?]
+
+      def addr: () -> [nil, String?, String?, String]
+
+      def gets: (?String eol, ?Integer? size) -> String?
+
+      def read: (?Integer? size) -> String?
+
+      def each: () { (String) -> void } -> void
+
+      def eof?: () -> bool
+
+      def <<: (_ToS data) -> IO
+
+      def write: (_ToS data) -> Integer
+
+      def cert: () -> OpenSSL::X509::Certificate?
+
+      def peer_cert: () -> OpenSSL::X509::Certificate?
+
+      def peer_cert_chain: () -> Array[OpenSSL::X509::Certificate]?
+
+      def cipher: () -> [String?, String?, String?, String?]?
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/compat.rbs

@@ -0,0 +1,18 @@
+#
+# System call error module used by webrick for cross platform compatibility.
+#
+# EPROTO:: protocol error
+# ECONNRESET:: remote host reset the connection request
+# ECONNABORTED:: Client sent TCP reset (RST) before server has accepted the
+#                connection requested by client.
+#
+module Errno
+  class EPROTO < SystemCallError
+  end
+
+  class ECONNRESET < SystemCallError
+  end
+
+  class ECONNABORTED < SystemCallError
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/config.rbs

@@ -0,0 +1,17 @@
+module WEBrick
+  module Config
+    LIBDIR: String
+
+    # for GenericServer
+    General: Hash[Symbol, untyped]
+
+    # for HTTPServer, HTTPRequest, HTTPResponse ...
+    HTTP: Hash[Symbol, untyped]
+
+    FileHandler: Hash[Symbol, untyped]
+
+    BasicAuth: Hash[Symbol, untyped]
+
+    DigestAuth: Hash[Symbol, untyped]
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/cookie.rbs

@@ -0,0 +1,37 @@
+module WEBrick
+  class Cookie
+    @expires: String?
+
+    attr_reader name: String?
+
+    attr_accessor value: String?
+
+    attr_accessor version: Integer
+
+    #
+    # The cookie domain
+    attr_accessor domain: String?
+
+    attr_accessor path: String?
+
+    attr_accessor secure: true?
+
+    attr_accessor comment: String?
+
+    attr_accessor max_age: Integer?
+
+    def initialize: (untyped name, untyped value) -> void
+
+    def expires=: ((Time | _ToS)? t) -> untyped
+
+    def expires: () -> Time?
+
+    def to_s: () -> String
+
+    def self.parse: (String? str) -> Array[instance]?
+
+    def self.parse_set_cookie: (String str) -> instance
+
+    def self.parse_set_cookies: (String str) -> Array[instance]
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/htmlutils.rbs

@@ -0,0 +1,5 @@
+module WEBrick
+  module HTMLUtils
+    def self?.escape: (String? string) -> String
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/httpauth/authenticator.rbs

@@ -0,0 +1,55 @@
+module WEBrick
+  module HTTPAuth
+    module Authenticator
+      @reload_db: bool?
+
+      @request_field: String
+
+      @response_field: String
+
+      @resp_info_field: String
+
+      @auth_exception: singleton(HTTPStatus::ClientError)
+
+      @auth_scheme: String
+
+      RequestField: String
+
+      ResponseField: String
+
+      ResponseInfoField: String
+
+      AuthException: singleton(HTTPStatus::ClientError)
+
+      AuthScheme: String?
+
+      attr_reader realm: String?
+
+      attr_reader userdb: UserDB
+
+      attr_reader logger: Log
+
+      private
+
+      def check_init: (Hash[Symbol, untyped] config) -> void
+
+      def check_scheme: (HTTPRequest req) -> String?
+
+      def log: (interned meth, String fmt, *untyped args) -> void
+
+      def error: (String fmt, *untyped args) -> void
+
+      def info: (String fmt, *untyped args) -> void
+    end
+
+    module ProxyAuthenticator
+      RequestField: String
+
+      ResponseField: String
+
+      ResponseInfoField: String
+
+      AuthException: singleton(HTTPStatus::ClientError)
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/httpauth/basicauth.rbs

@@ -0,0 +1,29 @@
+module WEBrick
+  module HTTPAuth
+    class BasicAuth
+      @config: Hash[Symbol, untyped]
+
+      include Authenticator
+
+      AuthScheme: String
+
+      def self.make_passwd: (String? realm, String? user, String? pass) -> String
+
+      attr_reader realm: String?
+
+      attr_reader userdb: UserDB
+
+      attr_reader logger: Log
+
+      def initialize: (Hash[Symbol, untyped] config, ?Hash[Symbol, untyped] default) -> void
+
+      def authenticate: (HTTPRequest req, HTTPResponse res) -> void
+
+      def challenge: (HTTPRequest req, HTTPResponse res) -> bot
+    end
+
+    class ProxyBasicAuth < BasicAuth
+      include ProxyAuthenticator
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/httpauth/digestauth.rbs

@@ -0,0 +1,85 @@
+module WEBrick
+  module HTTPAuth
+    class DigestAuth
+      @config: Hash[Symbol, untyped]
+
+      @domain: Array[String]?
+
+      @use_opaque: bool
+
+      @use_next_nonce: bool
+
+      @check_nc: bool
+
+      @use_auth_info_header: bool
+
+      @nonce_expire_period: Integer
+
+      @nonce_expire_delta: Integer
+
+      @internet_explorer_hack: bool
+
+      @h: singleton(Digest::Base)
+
+      @instance_key: String
+
+      @opaques: Hash[String, OpaqueInfo]
+
+      @last_nonce_expire: Time
+
+      @mutex: Thread::Mutex
+
+      include Authenticator
+
+      AuthScheme: String
+
+      class OpaqueInfo < Struct[untyped]
+        attr_accessor time(): Time
+        attr_accessor nonce(): String?
+        attr_accessor nc(): String
+      end
+
+      attr_reader algorithm: String?
+
+      attr_reader qop: Array[String]
+
+      def self.make_passwd: (String realm, String user, String pass) -> untyped
+
+      def initialize: (Hash[Symbol, untyped] config, ?Hash[Symbol, untyped] default) -> void
+
+      def authenticate: (HTTPRequest req, HTTPResponse res) -> void
+
+      def challenge: (HTTPRequest req, HTTPResponse res, ?bool stale) -> bot
+
+      private
+
+      MustParams: Array[String]
+
+      MustParamsAuth: Array[String]
+
+      def _authenticate: (HTTPRequest req, HTTPResponse res) -> (:nonce_is_stale | bool)
+
+      def split_param_value: (String string) -> Hash[String, String]
+
+      def generate_next_nonce: (HTTPRequest req) -> String
+
+      def check_nonce: (HTTPRequest req, Hash[String, String] auth_req) -> bool
+
+      def generate_opaque: (HTTPRequest req) -> String
+
+      def check_opaque: (OpaqueInfo opaque_struct, untyped req, Hash[String, String] auth_req) -> bool
+
+      def check_uri: (HTTPRequest req, Hash[String, String] auth_req) -> bool
+
+      def hexdigest: (*_ToS? args) -> String
+    end
+
+    class ProxyDigestAuth < DigestAuth
+      include ProxyAuthenticator
+
+      private
+
+      def check_uri: (HTTPRequest req, Hash[String, String] auth_req) -> true
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/httpauth/htdigest.rbs

@@ -0,0 +1,31 @@
+module WEBrick
+  module HTTPAuth
+    class Htdigest
+      @path: String
+
+      @mtime: Time
+
+      @digest: Hash[String, Hash[String, String]]
+
+      @mutex: Thread::Mutex
+
+      @auth_type: String
+
+      include UserDB
+
+      def initialize: (String path) -> void
+
+      def reload: () -> void
+
+      def flush: (?String? output) -> void
+
+      def get_passwd: (String realm, String user, bool reload_db) -> String?
+
+      def set_passwd: (String realm, String user, String pass) -> String
+
+      def delete_passwd: (String realm, String user) -> String?
+
+      def each: () { (String user, String realm, String password_hash) -> void } -> void
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/httpauth/htgroup.rbs

@@ -0,0 +1,21 @@
+module WEBrick
+  module HTTPAuth
+    class Htgroup
+      @path: String
+
+      @mtime: Time
+
+      @group: Hash[String, Array[String]]
+
+      def initialize: (String path) -> void
+
+      def reload: () -> void
+
+      def flush: (?String? output) -> void
+
+      def members: (String group) -> Array[String]
+
+      def add: (String group, Array[String] members) -> void
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/httpauth/htpasswd.rbs

@@ -0,0 +1,31 @@
+module WEBrick
+  module HTTPAuth
+    class Htpasswd
+      @path: String
+
+      @mtime: Time
+
+      @passwd: Hash[String, String]
+
+      @auth_type: String
+
+      @password_hash: (:crypt | :bcrypt)
+
+      include UserDB
+
+      def initialize: (String path, ?password_hash: (:crypt | :bcrypt)?) -> void
+
+      def reload: () -> void
+
+      def flush: (?String? output) -> void
+
+      def get_passwd: (String realm, String user, bool reload_db) -> String?
+
+      def set_passwd: (String realm, String user, String pass) -> void
+
+      def delete_passwd: (String realm, String user) -> String
+
+      def each: () { ([String, String]) -> void } -> void
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/sig/httpauth/userdb.rbs

@@ -0,0 +1,13 @@
+module WEBrick
+  module HTTPAuth
+    module UserDB
+      attr_accessor auth_type: String
+
+      def make_passwd: (String realm, String user, String pass) -> String
+
+      def set_passwd: (String realm, String user, String pass) -> void
+
+      def get_passwd: (String realm, String user, ?bool reload_db) -> String
+    end
+  end
+end