http 6.0.0-java

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module HTTP
+  class Headers
+    # Content-Types that are acceptable for the response.
+    ACCEPT = "Accept"
+
+    # Content-codings that are acceptable in the response.
+    ACCEPT_ENCODING = "Accept-Encoding"
+
+    # The age the object has been in a proxy cache in seconds.
+    AGE = "Age"
+
+    # Authentication credentials for HTTP authentication.
+    AUTHORIZATION = "Authorization"
+
+    # Used to specify directives that must be obeyed by all caching mechanisms
+    # along the request-response chain.
+    CACHE_CONTROL = "Cache-Control"
+
+    # An HTTP cookie previously sent by the server with Set-Cookie.
+    COOKIE = "Cookie"
+
+    # Control options for the current connection and list
+    # of hop-by-hop request fields.
+    CONNECTION = "Connection"
+
+    # The length of the request body in octets (8-bit bytes).
+    CONTENT_LENGTH = "Content-Length"
+
+    # The MIME type of the body of the request
+    # (used with POST and PUT requests).
+    CONTENT_TYPE = "Content-Type"
+
+    # The date and time that the message was sent (in "HTTP-date" format as
+    # defined by RFC 7231 Date/Time Formats).
+    DATE = "Date"
+
+    # An identifier for a specific version of a resource,
+    # often a message digest.
+    ETAG = "ETag"
+
+    # Gives the date/time after which the response is considered stale (in
+    # "HTTP-date" format as defined by RFC 7231).
+    EXPIRES = "Expires"
+
+    # The domain name of the server (for virtual hosting), and the TCP port
+    # number on which the server is listening. The port number may be omitted
+    # if the port is the standard port for the service requested.
+    HOST = "Host"
+
+    # Allows a 304 Not Modified to be returned if content is unchanged.
+    IF_MODIFIED_SINCE = "If-Modified-Since"
+
+    # Allows a 304 Not Modified to be returned if content is unchanged.
+    IF_NONE_MATCH = "If-None-Match"
+
+    # The last modified date for the requested object (in "HTTP-date" format as
+    # defined by RFC 7231).
+    LAST_MODIFIED = "Last-Modified"
+
+    # Used in redirection, or when a new resource has been created.
+    LOCATION = "Location"
+
+    # Authorization credentials for connecting to a proxy.
+    PROXY_AUTHORIZATION = "Proxy-Authorization"
+
+    # An HTTP cookie.
+    SET_COOKIE = "Set-Cookie"
+
+    # The form of encoding used to safely transfer the entity to the user.
+    # 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"
+
+    # The user agent string of the user agent.
+    USER_AGENT = "User-Agent"
+
+    # Tells downstream proxies how to match future request headers to decide
+    # whether the cached response can be used rather than requesting a fresh
+    # one from the origin server.
+    VARY = "Vary"
+  end
+end

data/lib/http/headers/normalizer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module HTTP
+  class Headers
+    # Normalizes HTTP header names to canonical form
+    class Normalizer
+      # 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/
+
+      # Pattern matching header name part separators (hyphens and underscores)
+      NAME_PARTS_SEPARATOR_RE = /[-_]/
+
+      # Thread-local cache key for normalized header names
+      CACHE_KEY = :http_headers_normalizer_cache
+
+      # Normalizes a header name to canonical form
+      #
+      # @example
+      #   normalizer.call("content-type")
+      #
+      # @return [String]
+      # @api public
+      def call(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
+      #
+      # @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)
+        normalized = name.split(NAME_PARTS_SEPARATOR_RE).each(&:capitalize!).join("-")
+
+        return normalized if COMPLIANT_NAME_RE.match?(normalized)
+
+        raise HeaderError, "Invalid HTTP header field name: #{name.inspect}"
+      end
+    end
+  end
+end