http 5.3.1 → 6.0.0

data/lib/http/form_data/part.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+require "http/form_data/readable"
+
+module HTTP
+  module FormData
+    # Represents a body part of multipart/form-data request.
+    #
+    # @example Usage with String
+    #
+    #  body = "Message"
+    #  FormData::Part.new body, content_type: 'foobar.txt; charset="UTF-8"'
+    class Part
+      include Readable
+
+      # Returns the content type of this part
+      #
+      # @example
+      #   part.content_type # => "application/json"
+      #
+      # @api public
+      # @return [String, nil]
+      attr_reader :content_type
+
+      # Returns the filename of this part
+      #
+      # @example
+      #   part.filename # => "avatar.png"
+      #
+      # @api public
+      # @return [String, nil]
+      attr_reader :filename
+
+      # Creates a new Part with the given body and options
+      #
+      # @example
+      #   Part.new("hello", content_type: "text/plain")
+      #
+      # @api public
+      # @param [#to_s] body
+      # @param [String] content_type Value of Content-Type header
+      # @param [String] filename     Value of filename parameter
+      def initialize(body, content_type: nil, filename: nil)
+        @io = StringIO.new(body.to_s)
+        @content_type = content_type
+        @filename = filename
+      end
+    end
+  end
+end

data/lib/http/form_data/readable.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module HTTP
+  module FormData
+    # Common behaviour for objects defined by an IO object.
+    module Readable
+      # Returns IO content as a String
+      #
+      # @example
+      #   readable.to_s # => "content"
+      #
+      # @api public
+      # @return [String]
+      def to_s
+        rewind
+        content = read #: String
+        rewind
+        content
+      end
+
+      # Reads and returns part of IO content
+      #
+      # @example
+      #   readable.read      # => "full content"
+      #   readable.read(5)   # => "full "
+      #
+      # @api public
+      # @param [Integer] length Number of bytes to retrieve
+      # @param [String] outbuf String to be replaced with retrieved data
+      # @return [String, nil]
+      def read(length = nil, outbuf = nil)
+        @io.read(length, outbuf)
+      end
+
+      # Returns IO size in bytes
+      #
+      # @example
+      #   readable.size # => 42
+      #
+      # @api public
+      # @return [Integer]
+      def size
+        @io.size
+      end
+
+      # Rewinds the IO to the beginning
+      #
+      # @example
+      #   readable.rewind
+      #
+      # @api public
+      # @return [void]
+      def rewind
+        @io.rewind
+      end
+    end
+  end
+end

data/lib/http/form_data/urlencoded.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "http/form_data/readable"
+
+require "uri"
+require "stringio"
+
+module HTTP
+  module FormData
+    # `application/x-www-form-urlencoded` form data.
+    class Urlencoded
+      include Readable
+
+      class << self
+        # Sets custom form data encoder implementation
+        #
+        # @example
+        #
+        #     module CustomFormDataEncoder
+        #       UNESCAPED_CHARS = /[^a-z0-9\-\.\_\~]/i
+        #
+        #       def self.escape(s)
+        #         ::URI::DEFAULT_PARSER.escape(s.to_s, UNESCAPED_CHARS)
+        #       end
+        #
+        #       def self.call(data)
+        #         parts = []
+        #
+        #         data.each do |k, v|
+        #           k = escape(k)
+        #
+        #           if v.nil?
+        #             parts << k
+        #           elsif v.respond_to?(:to_ary)
+        #             v.to_ary.each { |vv| parts << "#{k}=#{escape vv}" }
+        #           else
+        #             parts << "#{k}=#{escape v}"
+        #           end
+        #         end
+        #
+        #         parts.join("&")
+        #       end
+        #     end
+        #
+        #     HTTP::FormData::Urlencoded.encoder = CustomFormDataEncoder
+        #
+        # @api public
+        # @raise [ArgumentError] if implementation does not respond to `#call`
+        # @param implementation [#call]
+        # @return [void]
+        def encoder=(implementation)
+          raise ArgumentError unless implementation.respond_to? :call
+
+          @encoder = implementation
+        end
+
+        # Returns form data encoder implementation
+        #
+        # @example
+        #   Urlencoded.encoder # => #<Method: DefaultEncoder.encode>
+        #
+        # @api public
+        # @see .encoder=
+        # @return [#call]
+        def encoder
+          @encoder || DefaultEncoder
+        end
+
+        # Default encoder for urlencoded form data
+        module DefaultEncoder
+          class << self
+            # Recursively encodes form data value
+            #
+            # @example
+            #   DefaultEncoder.encode({ foo: "bar" }) # => "foo=bar"
+            #
+            # @api public
+            # @param [Hash, Array, String, nil] value
+            # @param [String, nil] prefix
+            # @return [String]
+            def encode(value, prefix = nil)
+              case value
+              when Hash  then encode_hash(value, prefix)
+              when Array then encode_array(value, prefix)
+              when nil   then prefix.to_s
+              else
+                raise ArgumentError, "value must be a Hash" if prefix.nil?
+
+                "#{prefix}=#{escape(value)}"
+              end
+            end
+
+            alias call encode
+
+            private
+
+            # Encodes an Array value
+            #
+            # @api private
+            # @return [String]
+            def encode_array(value, prefix)
+              if prefix
+                value.map { |v| encode(v, "#{prefix}[]") }.join("&")
+              else
+                encode_pairs(value)
+              end
+            end
+
+            # Encodes an Array of key-value pairs
+            #
+            # @api private
+            # @return [String]
+            def encode_pairs(pairs)
+              pairs.map { |k, v| encode(v, escape(k)) }.reject(&:empty?).join("&")
+            end
+
+            # Encodes a Hash value
+            #
+            # @api private
+            # @return [String]
+            def encode_hash(hash, prefix)
+              hash.map do |k, v|
+                encode(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+              end.reject(&:empty?).join("&")
+            end
+
+            # URL-encodes a value
+            #
+            # @api private
+            # @return [String]
+            def escape(value)
+              ::URI.encode_www_form_component(value)
+            end
+          end
+        end
+
+        private_constant :DefaultEncoder
+      end
+
+      # Creates a new Urlencoded form data instance
+      #
+      # @example
+      #   Urlencoded.new({ "foo" => "bar" })
+      #
+      # @api public
+      # @param [Enumerable, Hash, #to_h] data form data key-value pairs
+      # @param [#call] encoder custom encoder implementation
+      def initialize(data, encoder: nil)
+        encoder ||= self.class.encoder
+        @io = StringIO.new(encoder.call(FormData.ensure_data(data)))
+      end
+
+      # Returns MIME type for the Content-Type header
+      #
+      # @example
+      #   urlencoded.content_type
+      #   # => "application/x-www-form-urlencoded"
+      #
+      # @api public
+      # @return [String]
+      def content_type
+        "application/x-www-form-urlencoded"
+      end
+
+      # Returns form data content size for Content-Length
+      #
+      # @example
+      #   urlencoded.content_length # => 17
+      #
+      # @api public
+      # @return [Integer]
+      alias content_length size
+    end
+  end
+end

data/lib/http/form_data/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module HTTP
+  module FormData
+    # Gem version.
+    VERSION = "3.0.0"
+  end
+end

data/lib/http/form_data.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "http/form_data/part"
+require "http/form_data/file"
+require "http/form_data/multipart"
+require "http/form_data/urlencoded"
+require "http/form_data/version"
+
+# http gem namespace.
+# @see https://github.com/httprb/http
+module HTTP
+  # Utility-belt to build form data request bodies.
+  # Provides support for `application/x-www-form-urlencoded` and
+  # `multipart/form-data` types.
+  #
+  # @example Usage
+  #
+  #   form = FormData.create({
+  #     username:    "ixti",
+  #     avatar_file: FormData::File.new("/home/ixti/avatar.png")
+  #   })
+  #
+  #   # Assuming socket is an open socket to some HTTP server
+  #   socket << "POST /some-url HTTP/1.1\r\n"
+  #   socket << "Host: example.com\r\n"
+  #   socket << "Content-Type: #{form.content_type}\r\n"
+  #   socket << "Content-Length: #{form.content_length}\r\n"
+  #   socket << "\r\n"
+  #   socket << form.to_s
+  module FormData
+    # CRLF
+    CRLF = "\r\n"
+
+    # Generic FormData error.
+    class Error < StandardError; end
+
+    class << self
+      # Selects encoder type based on given data
+      #
+      # @example
+      #   FormData.create({ username: "ixti" })
+      #
+      # @api public
+      # @param [Enumerable, Hash, #to_h] data
+      # @return [Multipart] if any of values is a {FormData::File}
+      # @return [Urlencoded] otherwise
+      def create(data, encoder: nil)
+        data = ensure_data data
+
+        if multipart?(data)
+          Multipart.new(data)
+        else
+          Urlencoded.new(data, encoder: encoder)
+        end
+      end
+
+      # Coerces obj to Hash
+      #
+      # @example
+      #   FormData.ensure_hash({ foo: :bar }) # => { foo: :bar }
+      #
+      # @api public
+      # @raise [Error] `obj` can't be coerced
+      # @return [Hash]
+      def ensure_hash(obj)
+        if    obj.is_a?(Hash)        then obj
+        elsif obj.respond_to?(:to_h) then obj.to_h
+        else raise Error, "#{obj.inspect} is neither Hash nor responds to :to_h"
+        end
+      end
+
+      # Coerces obj to an Enumerable of key-value pairs
+      #
+      # @example
+      #   FormData.ensure_data([[:foo, :bar]]) # => [[:foo, :bar]]
+      #
+      # @api public
+      # @raise [Error] `obj` can't be coerced
+      # @return [Enumerable]
+      def ensure_data(obj)
+        if    obj.nil?                  then []
+        elsif obj.is_a?(Enumerable)     then obj
+        elsif obj.respond_to?(:to_h)    then obj.to_h
+        else raise Error, "#{obj.inspect} is neither Enumerable nor responds to :to_h"
+        end
+      end
+
+      private
+
+      # Checks if data contains multipart data
+      #
+      # @api private
+      # @param [Enumerable] data
+      # @return [Boolean]
+      def multipart?(data)
+        data.any? do |_, v|
+          v.is_a?(Part) || (v.respond_to?(:to_ary) && v.to_ary.any?(Part))
+        end
+      end
+    end
+  end
+end

data/lib/http/headers/known.rb

@@ -72,6 +72,9 @@ module HTTP
     # Currently defined methods are: chunked, compress, deflate, gzip, identity.
     TRANSFER_ENCODING = "Transfer-Encoding"
 
+    # Chunked transfer coding value for Transfer-Encoding
+    CHUNKED = "chunked"
+
     # Indicates what additional content codings have been applied to the
     # entity-body.
     CONTENT_ENCODING = "Content-Encoding"

data/lib/http/headers/normalizer.rb

@@ -2,62 +2,43 @@
 
 module HTTP
   class Headers
+    # Normalizes HTTP header names to canonical form
     class Normalizer
-      # Matches HTTP header names when in "Canonical-Http-Format"
-      CANONICAL_NAME_RE = /\A[A-Z][a-z]*(?:-[A-Z][a-z]*)*\z/
-
       # Matches valid header field name according to RFC.
       # @see http://tools.ietf.org/html/rfc7230#section-3.2
       COMPLIANT_NAME_RE = /\A[A-Za-z0-9!#$%&'*+\-.^_`|~]+\z/
 
-      NAME_PARTS_SEPARATOR_RE = /[\-_]/
-
-      # @private
-      # Normalized header names cache
-      class Cache
-        MAX_SIZE = 200
-
-        def initialize
-          @store = {}
-        end
+      # Pattern matching header name part separators (hyphens and underscores)
+      NAME_PARTS_SEPARATOR_RE = /[-_]/
 
-        def get(key)
-          @store[key]
-        end
-        alias [] get
-
-        def set(key, value)
-          # Maintain cache size
-          @store.delete(@store.each_key.first) while MAX_SIZE <= @store.size
-
-          @store[key] = value
-        end
-        alias []= set
-      end
+      # Thread-local cache key for normalized header names
+      CACHE_KEY = :http_headers_normalizer_cache
 
-      def initialize
-        @cache = Cache.new
-      end
-
-      # Transforms `name` to canonical HTTP header capitalization
+      # Normalizes a header name to canonical form
+      #
+      # @example
+      #   normalizer.call("content-type")
+      #
+      # @return [String]
+      # @api public
       def call(name)
-        name  = -name.to_s
-        value = (@cache[name] ||= -normalize_header(name))
+        name  = name.to_s
+        cache = (Thread.current[CACHE_KEY] ||= {})
+        value = (cache[name] ||= normalize_header(name))
 
         value.dup
       end
 
       private
 
-      # Transforms `name` to canonical HTTP header capitalization
+      # Transforms name to canonical HTTP header capitalization
       #
       # @param [String] name
       # @raise [HeaderError] if normalized name does not
       #   match {COMPLIANT_NAME_RE}
       # @return [String] canonical HTTP header name
+      # @api private
       def normalize_header(name)
-        return name if CANONICAL_NAME_RE.match?(name)
-
         normalized = name.split(NAME_PARTS_SEPARATOR_RE).each(&:capitalize!).join("-")
 
         return normalized if COMPLIANT_NAME_RE.match?(normalized)