rack 2.2.4 → 3.0.8

data/lib/rack/head.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'constants'
+require_relative 'body_proxy'
+
 module Rack
   # Rack::Head returns an empty body for all HEAD requests. It leaves
   # all other requests unchanged.
@@ -9,17 +12,15 @@ module Rack
     end
 
     def call(env)
-      status, headers, body = @app.call(env)
+      _, _, body = response = @app.call(env)
 
       if env[REQUEST_METHOD] == HEAD
-        [
-          status, headers, Rack::BodyProxy.new([]) do
-            body.close if body.respond_to? :close
-          end
-        ]
-      else
-        [status, headers, body]
+        response[2] = Rack::BodyProxy.new([]) do
+          body.close if body.respond_to? :close
+        end
       end
+
+      response
     end
   end
 end

data/lib/rack/headers.rb

@@ -0,0 +1,154 @@
+module Rack
+  # Rack::Headers is a Hash subclass that downcases all keys.  It's designed
+  # to be used by rack applications that don't implement the Rack 3 SPEC
+  # (by using non-lowercase response header keys), automatically handling
+  # the downcasing of keys.
+  class Headers < Hash
+    def self.[](*items)
+      if items.length % 2 != 0
+        if items.length == 1 && items.first.is_a?(Hash)
+          new.merge!(items.first)
+        else
+          raise ArgumentError, "odd number of arguments for Rack::Headers"
+        end
+      else
+        hash = new
+        loop do
+          break if items.length == 0
+          key = items.shift
+          value = items.shift
+          hash[key] = value
+        end
+        hash
+      end
+    end
+
+    def [](key)
+      super(downcase_key(key))
+    end
+
+    def []=(key, value)
+      super(key.downcase.freeze, value)
+    end
+    alias store []=
+
+    def assoc(key)
+      super(downcase_key(key))
+    end
+
+    def compare_by_identity
+      raise TypeError, "Rack::Headers cannot compare by identity, use regular Hash"
+    end
+
+    def delete(key)
+      super(downcase_key(key))
+    end
+
+    def dig(key, *a)
+      super(downcase_key(key), *a)
+    end
+
+    def fetch(key, *default, &block)
+      key = downcase_key(key)
+      super
+    end
+
+    def fetch_values(*a)
+      super(*a.map!{|key| downcase_key(key)})
+    end
+
+    def has_key?(key)
+      super(downcase_key(key))
+    end
+    alias include? has_key?
+    alias key? has_key?
+    alias member? has_key?
+
+    def invert
+      hash = self.class.new
+      each{|key, value| hash[value] = key}
+      hash
+    end
+
+    def merge(hash, &block)
+      dup.merge!(hash, &block)
+    end
+
+    def reject(&block)
+      hash = dup
+      hash.reject!(&block)
+      hash
+    end
+
+    def replace(hash)
+      clear
+      update(hash)
+    end
+
+    def select(&block)
+      hash = dup
+      hash.select!(&block)
+      hash
+    end
+
+    def to_proc
+      lambda{|x| self[x]}
+    end
+
+    def transform_values(&block)
+      dup.transform_values!(&block)
+    end
+
+    def update(hash, &block)
+      hash.each do |key, value|
+        self[key] = if block_given? && include?(key)
+          block.call(key, self[key], value)
+        else
+          value
+        end
+      end
+      self
+    end
+    alias merge! update
+
+    def values_at(*keys)
+      keys.map{|key| self[key]}
+    end
+
+    # :nocov:
+    if RUBY_VERSION >= '2.5'
+    # :nocov:
+      def slice(*a)
+        h = self.class.new
+        a.each{|k| h[k] = self[k] if has_key?(k)}
+        h
+      end
+
+      def transform_keys(&block)
+        dup.transform_keys!(&block)
+      end
+
+      def transform_keys!
+        hash = self.class.new
+        each do |k, v|
+          hash[yield k] = v
+        end
+        replace(hash)
+      end
+    end
+
+    # :nocov:
+    if RUBY_VERSION >= '3.0'
+    # :nocov:
+      def except(*a)
+        super(*a.map!{|key| downcase_key(key)})
+      end
+    end
+
+    private
+
+    def downcase_key(key)
+      key.is_a?(String) ? key.downcase : key
+    end
+  end
+end