serrano-vk 0.1.0

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/rack-3.2.5/lib/rack/deflater.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "time"  # for Time.httpdate
+
+require_relative 'constants'
+require_relative 'utils'
+require_relative 'request'
+require_relative 'body_proxy'
+
+module Rack
+  # This middleware enables content encoding of http responses,
+  # usually for purposes of compression.
+  #
+  # Currently supported encodings:
+  #
+  # * gzip
+  # * identity (no transformation)
+  #
+  # This middleware automatically detects when encoding is supported
+  # and allowed. For example no encoding is made when a cache
+  # directive of 'no-transform' is present, when the response status
+  # code is one that doesn't allow an entity body, or when the body
+  # is empty.
+  #
+  # Note that despite the name, Deflater does not support the +deflate+
+  # encoding.
+  class Deflater
+    # Creates Rack::Deflater middleware. Options:
+    #
+    # :if :: a lambda enabling / disabling deflation based on returned boolean value
+    #        (e.g <tt>use Rack::Deflater, :if => lambda { |*, body| sum=0; body.each { |i| sum += i.length }; sum > 512 }</tt>).
+    #        However, be aware that calling `body.each` inside the block will break cases where `body.each` is not idempotent,
+    #        such as when it is an +IO+ instance.
+    # :include :: a list of content types that should be compressed. By default, all content types are compressed.
+    # :sync :: determines if the stream is going to be flushed after every chunk.  Flushing after every chunk reduces
+    #          latency for time-sensitive streaming applications, but hurts compression and throughput.
+    #          Defaults to +true+.
+    def initialize(app, options = {})
+      @app = app
+      @condition = options[:if]
+      @compressible_types = options[:include]
+      @sync = options.fetch(:sync, true)
+    end
+
+    def call(env)
+      status, headers, body = response = @app.call(env)
+
+      unless should_deflate?(env, status, headers, body)
+        return response
+      end
+
+      request = Request.new(env)
+
+      encoding = Utils.select_best_encoding(%w(gzip identity),
+                                            request.accept_encoding)
+
+      # Set the Vary HTTP header.
+      vary = headers["vary"].to_s.split(",").map(&:strip)
+      unless vary.include?("*") || vary.any?{|v| v.downcase == 'accept-encoding'}
+        headers["vary"] = vary.push("Accept-Encoding").join(",")
+      end
+
+      case encoding
+      when "gzip"
+        headers['content-encoding'] = "gzip"
+        headers.delete(CONTENT_LENGTH)
+        mtime = headers["last-modified"]
+        mtime = Time.httpdate(mtime).to_i if mtime
+        response[2] = GzipStream.new(body, mtime, @sync)
+        response
+      when "identity"
+        response
+      else # when nil
+        # Only possible encoding values here are 'gzip', 'identity', and nil
+        message = "An acceptable encoding for the requested resource #{request.fullpath} could not be found."
+        bp = Rack::BodyProxy.new([message]) { body.close if body.respond_to?(:close) }
+        [406, { CONTENT_TYPE => "text/plain", CONTENT_LENGTH => message.length.to_s }, bp]
+      end
+    end
+
+    # Body class used for gzip encoded responses.
+    class GzipStream
+
+      BUFFER_LENGTH = 128 * 1_024
+
+      # Initialize the gzip stream.  Arguments:
+      # body :: Response body to compress with gzip
+      # mtime :: The modification time of the body, used to set the
+      #          modification time in the gzip header.
+      # sync :: Whether to flush each gzip chunk as soon as it is ready.
+      def initialize(body, mtime, sync)
+        @body = body
+        @mtime = mtime
+        @sync = sync
+      end
+
+      # Yield gzip compressed strings to the given block.
+      def each(&block)
+        @writer = block
+        gzip = ::Zlib::GzipWriter.new(self)
+        gzip.mtime = @mtime if @mtime
+        # @body.each is equivalent to @body.gets (slow)
+        if @body.is_a? ::File # XXX: Should probably be ::IO
+          while part = @body.read(BUFFER_LENGTH)
+            gzip.write(part)
+            gzip.flush if @sync
+          end
+        else
+          @body.each { |part|
+            # Skip empty strings, as they would result in no output,
+            # and flushing empty parts would raise Zlib::BufError.
+            next if part.empty?
+            gzip.write(part)
+            gzip.flush if @sync
+          }
+        end
+      ensure
+        gzip.finish
+      end
+
+      # Call the block passed to #each with the gzipped data.
+      def write(data)
+        @writer.call(data)
+      end
+
+      # Close the original body if possible.
+      def close
+        @body.close if @body.respond_to?(:close)
+      end
+    end
+
+    private
+
+    # Whether the body should be compressed.
+    def should_deflate?(env, status, headers, body)
+      # Skip compressing empty entity body responses and responses with
+      # no-transform set.
+      if Utils::STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) ||
+          /\bno-transform\b/.match?(headers[CACHE_CONTROL].to_s) ||
+          headers['content-encoding']&.!~(/\bidentity\b/)
+        return false
+      end
+
+      # Skip if @compressible_types are given and does not include request's content type
+      return false if @compressible_types && !(headers.has_key?(CONTENT_TYPE) && @compressible_types.include?(headers[CONTENT_TYPE][/[^;]*/]))
+
+      # Skip if @condition lambda is given and evaluates to false
+      return false if @condition && !@condition.call(env, status, headers, body)
+
+      # No point in compressing empty body, also handles usage with
+      # Rack::Sendfile.
+      return false if headers[CONTENT_LENGTH] == '0'
+
+      true
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/rack-3.2.5/lib/rack/directory.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'time'
+
+require_relative 'constants'
+require_relative 'utils'
+require_relative 'head'
+require_relative 'mime'
+require_relative 'files'
+
+module Rack
+  # Rack::Directory serves entries below the +root+ given, according to the
+  # path info of the Rack request. If a directory is found, the file's contents
+  # will be presented in an html based index. If a file is found, the env will
+  # be passed to the specified +app+.
+  #
+  # If +app+ is not specified, a Rack::Files of the same +root+ will be used.
+
+  class Directory
+    DIR_FILE = "<tr><td class='name'><a href='./%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>\n"
+    DIR_PAGE_HEADER = <<-PAGE
+<html><head>
+  <title>%s</title>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <style type='text/css'>
+table { width:100%%; }
+.name { text-align:left; }
+.size, .mtime { text-align:right; }
+.type { width:11em; }
+.mtime { width:15em; }
+  </style>
+</head><body>
+<h1>%s</h1>
+<hr />
+<table>
+  <tr>
+    <th class='name'>Name</th>
+    <th class='size'>Size</th>
+    <th class='type'>Type</th>
+    <th class='mtime'>Last Modified</th>
+  </tr>
+    PAGE
+    DIR_PAGE_FOOTER = <<-PAGE
+</table>
+<hr />
+</body></html>
+    PAGE
+
+    # Body class for directory entries, showing an index page with links
+    # to each file.
+    class DirectoryBody < Struct.new(:root, :path, :files)
+      # Yield strings for each part of the directory entry
+      def each
+        show_path = Utils.escape_html(path.sub(/^#{root}/, ''))
+        yield(DIR_PAGE_HEADER % [ show_path, show_path ])
+
+        unless path.chomp('/') == root
+          yield(DIR_FILE % DIR_FILE_escape(files.call('..')))
+        end
+
+        Dir.foreach(path) do |basename|
+          next if basename.start_with?('.')
+          next unless f = files.call(basename)
+          yield(DIR_FILE % DIR_FILE_escape(f))
+        end
+
+        yield(DIR_PAGE_FOOTER)
+      end
+
+      private
+
+      # Escape each element in the array of html strings.
+      def DIR_FILE_escape(htmls)
+        htmls.map { |e| Utils.escape_html(e) }
+      end
+    end
+
+    # The root of the directory hierarchy.  Only requests for files and
+    # directories inside of the root directory are supported.
+    attr_reader :root
+
+    # Set the root directory and application for serving files.
+    def initialize(root, app = nil)
+      @root = ::File.expand_path(root)
+      @root_with_separator = @root.end_with?(::File::SEPARATOR) ? @root : "#{@root}#{::File::SEPARATOR}"
+      @app = app || Files.new(@root)
+      @head = Head.new(method(:get))
+    end
+
+    def call(env)
+      # strip body if this is a HEAD call
+      @head.call env
+    end
+
+    # Internals of request handling.  Similar to call but does
+    # not remove body for HEAD requests.
+    def get(env)
+      script_name = env[SCRIPT_NAME]
+      path_info = Utils.unescape_path(env[PATH_INFO])
+
+      if client_error_response = check_bad_request(path_info) || check_forbidden(path_info)
+        client_error_response
+      else
+        path = ::File.join(@root, path_info)
+        list_path(env, path, path_info, script_name)
+      end
+    end
+
+    # Rack response to use for requests with invalid paths, or nil if path is valid.
+    def check_bad_request(path_info)
+      return if Utils.valid_path?(path_info)
+
+      body = "Bad Request\n"
+      [400, { CONTENT_TYPE => "text/plain",
+        CONTENT_LENGTH => body.bytesize.to_s,
+        "x-cascade" => "pass" }, [body]]
+    end
+
+    # Rack response to use for requests with paths outside the root, or nil if path is inside the root.
+    def check_forbidden(path_info)
+      return unless path_info.include? ".."
+
+      expanded_path = ::File.expand_path(::File.join(@root, path_info))
+      return if expanded_path == @root || expanded_path.start_with?(@root_with_separator)
+
+      body = "Forbidden\n"
+      [403, { CONTENT_TYPE => "text/plain",
+        CONTENT_LENGTH => body.bytesize.to_s,
+        "x-cascade" => "pass" }, [body]]
+    end
+
+    # Rack response to use for directories under the root.
+    def list_directory(path_info, path, script_name)
+      url_head = (script_name.split('/') + path_info.split('/')).map do |part|
+        Utils.escape_path part
+      end
+
+      # Globbing not safe as path could contain glob metacharacters
+      body = DirectoryBody.new(@root, path, ->(basename) do
+        stat = stat(::File.join(path, basename))
+        next unless stat
+
+        url = ::File.join(*url_head + [Utils.escape_path(basename)])
+        mtime = stat.mtime.httpdate
+        if stat.directory?
+          type = 'directory'
+          size = '-'
+          url << '/'
+          if basename == '..'
+            basename = 'Parent Directory'
+          else
+            basename << '/'
+          end
+        else
+          type = Mime.mime_type(::File.extname(basename))
+          size = filesize_format(stat.size)
+        end
+
+        [ url, basename, size, type, mtime ]
+      end)
+
+      [ 200, { CONTENT_TYPE => 'text/html; charset=utf-8' }, body ]
+    end
+
+    # File::Stat for the given path, but return nil for missing/bad entries.
+    def stat(path)
+      ::File.stat(path)
+    rescue Errno::ENOENT, Errno::ELOOP
+      return nil
+    end
+
+    # Rack response to use for files and directories under the root.
+    # Unreadable and non-file, non-directory entries will get a 404 response.
+    def list_path(env, path, path_info, script_name)
+      if (stat = stat(path)) && stat.readable?
+        return @app.call(env) if stat.file?
+        return list_directory(path_info, path, script_name) if stat.directory?
+      end
+
+      entity_not_found(path_info)
+    end
+
+    # Rack response to use for unreadable and non-file, non-directory entries.
+    def entity_not_found(path_info)
+      body = "Entity not found: #{path_info}\n"
+      [404, { CONTENT_TYPE => "text/plain",
+        CONTENT_LENGTH => body.bytesize.to_s,
+        "x-cascade" => "pass" }, [body]]
+    end
+
+    # Stolen from Ramaze
+    FILESIZE_FORMAT = [
+      ['%.1fT', 1 << 40],
+      ['%.1fG', 1 << 30],
+      ['%.1fM', 1 << 20],
+      ['%.1fK', 1 << 10],
+    ]
+
+    # Provide human readable file sizes
+    def filesize_format(int)
+      FILESIZE_FORMAT.each do |format, size|
+        return format % (int.to_f / size) if int >= size
+      end
+
+      "#{int}B"
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/rack-3.2.5/lib/rack/etag.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'digest/sha2'
+
+require_relative 'constants'
+require_relative 'utils'
+
+module Rack
+  # Automatically sets the etag header on all String bodies.
+  #
+  # The etag header is skipped if etag or last-modified headers are sent or if
+  # a sendfile body (body.responds_to :to_path) is given (since such cases
+  # should be handled by apache/nginx).
+  #
+  # On initialization, you can pass two parameters: a cache-control directive
+  # used when etag is absent and a directive when it is present. The first
+  # defaults to nil, while the second defaults to "max-age=0, private, must-revalidate"
+  class ETag
+    ETAG_STRING = Rack::ETAG
+    DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate"
+
+    def initialize(app, no_cache_control = nil, cache_control = DEFAULT_CACHE_CONTROL)
+      @app = app
+      @cache_control = cache_control
+      @no_cache_control = no_cache_control
+    end
+
+    def call(env)
+      status, headers, body = response = @app.call(env)
+
+      if etag_status?(status) && body.respond_to?(:to_ary) && !skip_caching?(headers)
+        body = body.to_ary
+        digest = digest_body(body)
+        headers[ETAG_STRING] = %(W/"#{digest}") if digest
+
+        # Body was modified, so we need to re-assign it:
+        response[2] = body
+      end
+
+      unless headers[CACHE_CONTROL]
+        if digest
+          headers[CACHE_CONTROL] = @cache_control if @cache_control
+        else
+          headers[CACHE_CONTROL] = @no_cache_control if @no_cache_control
+        end
+      end
+
+      response
+    end
+
+    private
+
+      def etag_status?(status)
+        status == 200 || status == 201
+      end
+
+      def skip_caching?(headers)
+        headers.key?(ETAG_STRING) || headers.key?('last-modified')
+      end
+
+      def digest_body(body)
+        digest = nil
+
+        body.each do |part|
+          (digest ||= Digest::SHA256.new) << part unless part.empty?
+        end
+
+        digest && digest.hexdigest.byteslice(0,32)
+      end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/rack-3.2.5/lib/rack/events.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative 'body_proxy'
+require_relative 'request'
+require_relative 'response'
+
+module Rack
+  ### This middleware provides hooks to certain places in the request /
+  # response lifecycle.  This is so that middleware that don't need to filter
+  # the response data can safely leave it alone and not have to send messages
+  # down the traditional "rack stack".
+  #
+  # The events are:
+  #
+  # * on_start(request, response)
+  #
+  #   This event is sent at the start of the request, before the next
+  #   middleware in the chain is called.  This method is called with a request
+  #   object, and a response object.  Right now, the response object is always
+  #   nil, but in the future it may actually be a real response object.
+  #
+  # * on_commit(request, response)
+  #
+  #   The response has been committed.  The application has returned, but the
+  #   response has not been sent to the webserver yet.  This method is always
+  #   called with a request object and the response object.  The response
+  #   object is constructed from the rack triple that the application returned.
+  #   Changes may still be made to the response object at this point.
+  #
+  # * on_send(request, response)
+  #
+  #   The webserver has started iterating over the response body, or has called
+  #   the streaming body, and presumably has started sending data over the
+  #   wire. This method is always called with a request object and the response
+  #   object. The response object is constructed from the rack triple that the
+  #   application returned.  Changes SHOULD NOT be made to the response object
+  #   as the webserver has already started sending data.  Any mutations will
+  #   likely result in an exception.
+  #
+  # * on_finish(request, response)
+  #
+  #   The webserver has closed the response, and all data has been written to
+  #   the response socket.  The request and response object should both be
+  #   read-only at this point.  The body MAY NOT be available on the response
+  #   object as it may have been flushed to the socket.
+  #
+  # * on_error(request, response, error)
+  #
+  #   An exception has occurred in the application or an `on_commit` event.
+  #   This method will get the request, the response (if available) and the
+  #   exception that was raised.
+  #
+  # ## Order
+  #
+  # `on_start` is called on the handlers in the order that they were passed to
+  # the constructor.  `on_commit`, on_send`, `on_finish`, and `on_error` are
+  # called in the reverse order.  `on_finish` handlers are called inside an
+  # `ensure` block, so they are guaranteed to be called even if something
+  # raises an exception.  If something raises an exception in a `on_finish`
+  # method, then nothing is guaranteed.
+
+  class Events
+    module Abstract
+      def on_start(req, res)
+      end
+
+      def on_commit(req, res)
+      end
+
+      def on_send(req, res)
+      end
+
+      def on_finish(req, res)
+      end
+
+      def on_error(req, res, e)
+      end
+    end
+
+    class EventedBodyProxy < Rack::BodyProxy # :nodoc:
+      attr_reader :request, :response
+
+      def initialize(body, request, response, handlers, &block)
+        super(body, &block)
+        @request  = request
+        @response = response
+        @handlers = handlers
+      end
+
+      def each
+        @handlers.reverse_each { |handler| handler.on_send request, response }
+        super
+      end
+
+      def call(stream)
+        @handlers.reverse_each { |handler| handler.on_send request, response }
+        super
+      end
+
+      def respond_to?(method_name, include_all = false)
+        case method_name
+        when :each, :call
+          @body.respond_to?(method_name, include_all)
+        else
+          super
+        end
+      end
+    end
+
+    class BufferedResponse < Rack::Response::Raw # :nodoc:
+      attr_reader :body
+
+      def initialize(status, headers, body)
+        super(status, headers)
+        @body = body
+      end
+
+      def to_a; [status, headers, body]; end
+    end
+
+    def initialize(app, handlers)
+      @app      = app
+      @handlers = handlers
+    end
+
+    def call(env)
+      request = make_request env
+      on_start request, nil
+
+      begin
+        status, headers, body = @app.call request.env
+        response = make_response status, headers, body
+        on_commit request, response
+      rescue StandardError => e
+        on_error request, response, e
+        on_finish request, response
+        raise
+      end
+
+      body = EventedBodyProxy.new(body, request, response, @handlers) do
+        on_finish request, response
+      end
+      [response.status, response.headers, body]
+    end
+
+    private
+
+    def on_error(request, response, e)
+      @handlers.reverse_each { |handler| handler.on_error request, response, e }
+    end
+
+    def on_commit(request, response)
+      @handlers.reverse_each { |handler| handler.on_commit request, response }
+    end
+
+    def on_start(request, response)
+      @handlers.each { |handler| handler.on_start request, nil }
+    end
+
+    def on_finish(request, response)
+      @handlers.reverse_each { |handler| handler.on_finish request, response }
+    end
+
+    def make_request(env)
+      Rack::Request.new env
+    end
+
+    def make_response(status, headers, body)
+      BufferedResponse.new status, headers, body
+    end
+  end
+end