serrano-vk 0.1.0

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'body_proxy'
+
+module Rack
+  # Rack::Lock locks every request inside a mutex, so that every request
+  # will effectively be executed synchronously.
+  class Lock
+    def initialize(app, mutex = Mutex.new)
+      @app, @mutex = app, mutex
+    end
+
+    def call(env)
+      @mutex.lock
+      begin
+        response = @app.call(env)
+        returned = response << BodyProxy.new(response.pop) { unlock }
+      ensure
+        unlock unless returned
+      end
+    end
+
+    private
+
+    def unlock
+      @mutex.unlock
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Rack
+  # Rack::MediaType parse media type and parameters out of content_type string
+
+  class MediaType
+    SPLIT_PATTERN = /[;,]/
+
+    class << self
+      # The media type (type/subtype) portion of the CONTENT_TYPE header
+      # without any media type parameters. e.g., when CONTENT_TYPE is
+      # "text/plain;charset=utf-8", the media-type is "text/plain".
+      #
+      # For more information on the use of media types in HTTP, see:
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
+      def type(content_type)
+        return nil unless content_type && !content_type.empty?
+        type = content_type.split(SPLIT_PATTERN, 2).first
+        type.rstrip!
+        type.downcase!
+        type
+      end
+
+      # The media type parameters provided in CONTENT_TYPE as a Hash, or
+      # an empty Hash if no CONTENT_TYPE or media-type parameters were
+      # provided.  e.g., when the CONTENT_TYPE is "text/plain;charset=utf-8",
+      # this method responds with the following Hash:
+      #   { 'charset' => 'utf-8' }
+      #
+      # This will pass back parameters with empty strings in the hash if they
+      # lack a value (e.g., "text/plain;charset=" will return { 'charset' => '' },
+      # and "text/plain;charset" will return { 'charset' => '' }, similarly to 
+      # the query params parser (barring the latter case, which returns nil instead)).
+      def params(content_type)
+        return {} if content_type.nil? || content_type.empty?
+
+        content_type.split(SPLIT_PATTERN)[1..-1].each_with_object({}) do |s, hsh|
+          s.strip!
+          k, v = s.split('=', 2)
+          k.downcase!
+          hsh[k] = strip_doublequotes(v)
+        end
+      end
+
+      private
+
+      def strip_doublequotes(str)
+        (str && str.start_with?('"') && str.end_with?('"')) ? str[1..-2] : str || ''
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require_relative 'request'
+require_relative 'utils'
+
+module Rack
+  class MethodOverride
+    HTTP_METHODS = %w[GET HEAD PUT POST DELETE OPTIONS PATCH LINK UNLINK]
+
+    METHOD_OVERRIDE_PARAM_KEY = "_method"
+    HTTP_METHOD_OVERRIDE_HEADER = "HTTP_X_HTTP_METHOD_OVERRIDE"
+    ALLOWED_METHODS = %w[POST]
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if allowed_methods.include?(env[REQUEST_METHOD])
+        method = method_override(env)
+        if HTTP_METHODS.include?(method)
+          env[RACK_METHODOVERRIDE_ORIGINAL_METHOD] = env[REQUEST_METHOD]
+          env[REQUEST_METHOD] = method
+        end
+      end
+
+      @app.call(env)
+    end
+
+    def method_override(env)
+      req = Request.new(env)
+      method = method_override_param(req) ||
+        env[HTTP_METHOD_OVERRIDE_HEADER]
+      begin
+        method.to_s.upcase
+      rescue ArgumentError
+        env[RACK_ERRORS].puts "Invalid string for method"
+      end
+    end
+
+    private
+
+    def allowed_methods
+      ALLOWED_METHODS
+    end
+
+    def method_override_param(req)
+      req.POST[METHOD_OVERRIDE_PARAM_KEY] if req.form_data? || req.parseable_data?
+    rescue Utils::InvalidParameterError, Utils::ParameterTypeError, QueryParser::ParamsTooDeepError
+      req.get_header(RACK_ERRORS).puts "Invalid or incomplete POST params"
+    rescue EOFError
+      req.get_header(RACK_ERRORS).puts "Bad request content body"
+    end
+  end
+end