homura-runtime 0.3.3 → 0.3.4

data/vendor/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/vendor/rack/media_type.rb

@@ -0,0 +1,42 @@
+# 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
+      # homura patch: Opal Strings are immutable, so #rstrip!/#downcase!/
+      # #strip! all raise. Rewritten to use non-mutating String forms.
+      def type(content_type)
+        return nil unless content_type && !content_type.empty?
+        type = content_type.split(SPLIT_PATTERN, 2).first
+        type.rstrip.downcase
+      end
+
+      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 = s.strip
+          k, v = s.split('=', 2)
+          k = 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/vendor/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