Merge form_data into http

Author: sferik

.mutant.yml

@@ -111,5 +111,3 @@ matcher:
     # Cookie/CookieJar delegate to http-cookie gem
     - HTTP::Cookie*
     - HTTP::CookieJar*
-    # External gem (http-form_data)
-    - HTTP::FormData*

http.gemspec

@@ -29,16 +29,15 @@ Gem::Specification.new do |spec|
     extras = %w[CHANGELOG.md CONTRIBUTING.md LICENSE.txt README.md SECURITY.md UPGRADING.md] << File.basename(__FILE__)
 
     ls.readlines("\x0", chomp: true).select do |f|
-      f.start_with?("lib/", "test/") || extras.include?(f) || f.eql?("sig/http.rbs")
+      f.start_with?("lib/", "test/", "sig/") || extras.include?(f)
     end
   end
 
   spec.require_paths = ["lib"]
 
   spec.required_ruby_version = ">= 3.2"
 
-  spec.add_dependency "http-cookie",    "~> 1.0"
-  spec.add_dependency "http-form_data", "~> 2.2"
+  spec.add_dependency "http-cookie", "~> 1.0"
 
   if RUBY_ENGINE == "jruby"
     spec.platform = "java" if ENV["HTTP_PLATFORM"] == "java"

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

lib/http/form_data/composite_io.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module HTTP
+  module FormData
+    # Provides IO interface across multiple IO objects.
+    class CompositeIO
+      # Creates a new CompositeIO from an array of IOs
+      #
+      # @example
+      #   CompositeIO.new([StringIO.new("hello"), StringIO.new(" world")])
+      #
+      # @api public
+      # @param [Array<IO>] ios Array of IO objects
+      def initialize(ios)
+        @index = 0
+        @ios   = ios.map do |io|
+          if io.is_a?(String)
+            StringIO.new(io)
+          elsif io.respond_to?(:read)
+            io
+          else
+            raise ArgumentError,
+                  "#{io.inspect} is neither a String nor an IO object"
+          end
+        end
+      end
+
+      # Reads and returns content across multiple IO objects
+      #
+      # @example
+      #   composite_io.read     # => "hello world"
+      #   composite_io.read(5)  # => "hello"
+      #
+      # @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)
+        data   = outbuf.clear.force_encoding(Encoding::BINARY) if outbuf
+        data ||= "".b
+
+        read_chunks(length) { |chunk| data << chunk }
+
+        data unless length && data.empty?
+      end
+
+      # Returns sum of all IO sizes
+      #
+      # @example
+      #   composite_io.size # => 11
+      #
+      # @api public
+      # @return [Integer]
+      def size
+        @size ||= @ios.sum(&:size)
+      end
+
+      # Rewinds all IO objects and resets cursor
+      #
+      # @example
+      #   composite_io.rewind
+      #
+      # @api public
+      # @return [void]
+      def rewind
+        @ios.each(&:rewind)
+        @index = 0
+      end
+
+      private
+
+      # Yields chunks with total length up to `length`
+      #
+      # @api private
+      # @return [void]
+      def read_chunks(length)
+        while (chunk = readpartial(length))
+          yield chunk.force_encoding(Encoding::BINARY)
+
+          next if length.nil?
+
+          remaining = length - chunk.bytesize
+          break if remaining.zero?
+
+          length = remaining
+        end
+      end
+
+      # Reads chunk from current IO with length up to `max_length`
+      #
+      # @api private
+      # @return [String, nil]
+      def readpartial(max_length)
+        while (io = @ios.at(@index))
+          chunk = io.read(max_length)
+
+          return chunk if chunk && !chunk.empty?
+
+          @index += 1
+        end
+      end
+    end
+  end
+end

lib/http/form_data/file.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module HTTP
+  module FormData
+    # Represents file form param.
+    #
+    # @example Usage with StringIO
+    #
+    #  io = StringIO.new "foo bar baz"
+    #  FormData::File.new io, filename: "foobar.txt"
+    #
+    # @example Usage with IO
+    #
+    #  File.open "/home/ixti/avatar.png" do |io|
+    #    FormData::File.new io
+    #  end
+    #
+    # @example Usage with pathname
+    #
+    #  FormData::File.new "/home/ixti/avatar.png"
+    class File < Part
+      # Default MIME type
+      DEFAULT_MIME = "application/octet-stream"
+
+      # Creates a new File from a path or IO object
+      #
+      # @example
+      #   File.new("/path/to/file.txt")
+      #
+      # @api public
+      # @see DEFAULT_MIME
+      # @param [String, Pathname, IO] path_or_io Filename or IO instance
+      # @param [#to_h] opts
+      # @option opts [#to_s] :content_type (DEFAULT_MIME)
+      #   Value of Content-Type header
+      # @option opts [#to_s] :filename
+      #   When `path_or_io` is a String, Pathname or File, defaults to basename.
+      #   When `path_or_io` is a IO, defaults to `"stream-{object_id}"`
+      def initialize(path_or_io, opts = nil) # rubocop:disable Lint/MissingSuper
+        opts = FormData.ensure_hash(opts)
+
+        @io           = make_io(path_or_io)
+        @autoclose    = path_or_io.is_a?(String) || path_or_io.is_a?(Pathname)
+        @content_type = opts.fetch(:content_type, DEFAULT_MIME).to_s
+        @filename     = opts.fetch(:filename, filename_for(@io))
+      end
+
+      # Closes the underlying IO if it was opened by this instance
+      #
+      # When the File was created from a String path or Pathname, the
+      # underlying file handle is closed. When created from an existing
+      # IO object, this is a no-op (the caller is responsible for
+      # closing it).
+      #
+      # @example
+      #   file = FormData::File.new("/path/to/file.txt")
+      #   file.to_s
+      #   file.close
+      #
+      # @api public
+      # @return [void]
+      def close
+        @io.close if @autoclose
+      end
+
+      private
+
+      # Wraps path_or_io into an IO object
+      #
+      # @api private
+      # @param [String, Pathname, IO] path_or_io
+      # @return [IO]
+      def make_io(path_or_io)
+        case path_or_io
+        when String   then ::File.new(path_or_io, binmode: true)
+        when Pathname then path_or_io.open(binmode: true)
+        else path_or_io
+        end
+      end
+
+      # Determines filename for the given IO
+      #
+      # @api private
+      # @param [IO] io
+      # @return [String]
+      def filename_for(io)
+        if io.respond_to?(:path)
+          ::File.basename(io.path)
+        else
+          "stream-#{io.object_id}"
+        end
+      end
+    end
+  end
+end