protocol-multipart 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 404efdeaff535479636d3b9106596c80064d24dc9b7b5f9022a5cadee9cd3a0d
+  data.tar.gz: 85229551ef122a278ee1e1cf638267bef7383871093c645205da1133b5e490a6
+SHA512:
+  metadata.gz: 0d07255671ea2766adca286ffa8924310ffba1d63a5bdcb844ff8eb8623b1119cc7b00b6d3e95046ef84d8fcf5e71b59b873d83dca53a58c351ebb0ace8f5d53
+  data.tar.gz: d91be37cf9c4cf5892aa78d64848332f7321c6a9cbdbdf5713bbf4ec0d67f4d8615840e71faf13165d6511811f8efa1771657531b1c4b6447f7ed2b6bfcdcebd

data/lib/protocol/multipart/boundary.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "securerandom"
+
+module Protocol
+	module Multipart
+		# Generate a secure boundary string for multipart messages.
+		# Approximately 192 bits of entropy by default, which is sufficient for most applications.
+		def self.secure_boundary(prefix = nil, length = 24)
+			if prefix
+				"#{prefix}-#{SecureRandom.urlsafe_base64(length, false)}"
+			else
+				SecureRandom.urlsafe_base64(length, false)
+			end
+		end
+	end
+end

data/lib/protocol/multipart/escape.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Protocol
+	module Multipart
+		# Utilities for escaping and unescaping field names and values in multipart data
+		module Escape
+			# Escape field names according to RFC 7578 and RFC 2046
+			# Quotes and backslashes need to be escaped with backslashes
+			def escape_field_name(name)
+				name.to_s.gsub(/([\\"])/, '\\\\\1')
+			end
+			
+			# Unescape field names that were escaped with escape_field_name
+			def unescape_field_name(name)
+				name.to_s.gsub(/\\([\\"])/, '\1')
+			end
+		end
+	end
+end

data/lib/protocol/multipart/form_data.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "mixed"
+require_relative "string_part"
+require_relative "escape"
+
+module Protocol
+	module Multipart
+		# FormData class for handling multipart/form-data format used in HTTP forms.
+		# Extends Mixed to provide specific support for form fields with names and values.
+		class FormData < Mixed
+			include Escape
+			
+			# Returns the MIME type for form data.
+			#
+			# @returns [String] The MIME type "multipart/form-data".
+			def self.mime_type
+				"multipart/form-data"
+			end
+			
+			# Adds a form field to the multipart form data.
+			#
+			# @parameter name [String] The field name.
+			# @parameter value [String] The field value.
+			# @parameter headers [Hash] Additional headers for the field.
+			# @returns [StringPart] The created StringPart for the field.
+			def add_field(name, value, headers = {})
+				headers = headers.merge(
+					"content-disposition" => "form-data; name=\"#{escape_field_name name}\""
+				)
+				
+				StringPart.new(headers, value).tap do |part|
+					@parts << part
+				end
+			end
+		end
+	end
+end

data/lib/protocol/multipart/io_part.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "part"
+require_relative "escape"
+
+module Protocol
+	module Multipart
+		# A part that contains IO content (files, streams, etc.).
+		class IOPart < Part
+			extend Escape
+			
+			# Opens a file and creates an IOPart for it.
+			#
+			# @parameter path [String] The file path to open.
+			# @parameter mime_type [String | Nil] The MIME type of the file, or nil to use application/octet-stream.
+			# @parameter name [String | Nil] The name to use for the file, or nil to use the filename.
+			# @parameter headers [Hash] Additional headers for the part.
+			# @returns [IOPart] A new IOPart instance for the file.
+			def self.open(path, mime_type: nil, name: nil, headers: {})
+				io = File.open(path, "rb")
+				
+				name ||= File.basename(path)
+				
+				headers = headers.merge(
+					"content-disposition" => "attachment; filename=\"#{escape_field_name name}\"",
+					"content-type" => mime_type || "application/octet-stream"
+				)
+				
+				return new(headers, io)
+			end
+			
+			# Initialize a new IOPart with the given headers and IO object.
+			#
+			# @parameter headers [Hash] Headers for the part.
+			# @parameter io [IO] The IO object containing the part's data.
+			def initialize(headers, io)
+				super(headers)
+				@io = io
+			end
+			
+			# The underlying IO object.
+			# @attribute [IO] The IO object containing the part's data.
+			attr_reader :io
+			
+			# Write the part's content to the provided writable stream.
+			#
+			# @parameter writable [IO] The destination stream to write to.
+			# @parameter boundary [String] The boundary string for the multipart message.
+			def call(writable, boundary)
+				while chunk = @io.read(8192)
+					break if chunk.empty?
+					writable.write(chunk)
+				end
+			end
+		end
+	end
+end

data/lib/protocol/multipart/mixed.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "part"
+require_relative "boundary"
+
+module Protocol
+	module Multipart
+		# Represents a multipart/mixed message.
+		# A composite part that contains multiple nested parts with a boundary separator.
+		class Mixed < Part
+			# Returns the MIME type for mixed multipart data.
+			#
+			# @returns [String] The MIME type "multipart/mixed".
+			def self.mime_type
+				"multipart/mixed"
+			end
+			
+			# Initialize a new multipart/mixed container.
+			#
+			# @parameter headers [Hash] Headers for the multipart container.
+			# @parameter parts [Array] The parts to include in this multipart container.
+			# @parameter boundary [String] The boundary string to use for separating parts.
+			# @parameter mime_type [String] The MIME type to use for this container.
+			def initialize(headers = {}, parts = [], boundary: Multipart.secure_boundary, mime_type: self.class.mime_type)
+				super(headers)
+				
+				@boundary = boundary
+				@parts = parts
+				@headers["content-type"] = "#{mime_type}; boundary=#{@boundary}"
+			end
+			
+			# @attribute [String] The boundary string used to separate parts.
+			attr :boundary
+			
+			# @attribute [Array(Part)] The parts of the body.
+			attr :parts
+			
+			private def write_headers(writable, headers)
+				headers.each do |key, value|
+					writable.write("#{key}: #{value}\r\n")
+				end
+				
+				writable.write("\r\n")
+			end
+			
+			# Writes the multipart container and all its parts to the writable stream.
+			# This method serializes the multipart container, including all nested parts,
+			# with appropriate boundaries between them.
+			#
+			# @parameter writable [IO] The writable stream to write the multipart data to.
+			# @parameter boundary [String | Nil] The parent boundary string, if this is a nested multipart.
+			def call(writable, boundary = nil)
+				return if @parts.empty?
+				
+				first = true
+				initial_boundary = "--#{@boundary}\r\n".freeze
+				middle_boundary = "\r\n--#{@boundary}\r\n".freeze
+				
+				# Write each part:
+				@parts.each do |part|
+					if first
+						# Write the initial boundary:
+						writable.write(initial_boundary)
+						first = false
+					else
+						# Write the boundary before each part:
+						writable.write(middle_boundary)
+					end
+					
+					self.write_headers(writable, part.headers)
+					part.call(writable, middle_boundary)
+				end
+				
+				unless first
+					# Write the final boundary:
+					writable.write("\r\n--#{@boundary}--\r\n")
+				end
+			end
+		end
+	end
+end

data/lib/protocol/multipart/parser.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "io/stream"
+
+module Protocol
+	module Multipart
+		# A parser for multipart data based on RFC 2046 and RFC 2387.
+		# Parses multipart bodies and provides an enumerable interface to access the parts.
+		class Parser
+			# Represents a single part within a multipart message.
+			class Part
+				# Initialize a new part with a readable stream, headers, and a boundary string.
+				#
+				# @parameter readable [IO::Stream] The readable stream that contains the part's data.
+				# @parameter headers [Hash] The headers associated with this part.
+				# @parameter boundary [String] The boundary string used to separate parts.
+				def initialize(readable, headers, boundary)
+					@readable = readable
+					@boundary = boundary
+					@headers = headers
+					@ended = false
+					@is_closing = false
+				end
+				
+				# @attribute [Hash] The headers associated with this part.
+				attr_reader :headers
+				
+				# Iterate through the part content in chunks.
+				#
+				# @parameter chunk_size [Integer] The size of each chunk to read.
+				# @returns [Enumerable] An enumerable of content chunks if no block given.
+				def each(chunk_size = 8192)
+					return to_enum(:each, chunk_size) unless block_given?
+					
+					return unless @readable
+					
+					boundary_marker = "\r\n--#{@boundary}"
+					
+					# Stream data in chunks using read_until with a limit
+					while @readable
+						if chunk = @readable.read_until(boundary_marker, limit: chunk_size, chomp: true)
+							# We found the boundary, check if it's a closing boundary:
+							if suffix = @readable.read_until("\r\n", chomp: true)
+								@is_closing = (suffix == "--")
+								@ended = true
+								@readable = nil
+							else
+								@readable = nil
+								raise EOFError, "Unexpected end of stream while reading part data!"
+							end
+						else
+							chunk = @readable.read(chunk_size)
+						end
+						
+						if chunk
+							yield chunk unless chunk.empty?
+						else
+							# No more data to read, break the loop:
+							break
+						end
+					end
+				end
+				
+				# Checks if the next content is an empty boundary (part with no content).
+				#
+				# @returns [Boolean] True if an empty boundary was found and read, false otherwise.
+				def read_empty_boundary?
+					boundary_marker = "--#{@boundary}"
+					if @readable.peek(boundary_marker.bytesize) == boundary_marker
+						@readable.read(boundary_marker.bytesize)
+						self.read_boundary_suffix
+						
+						return true
+					end
+					
+					return false
+				end
+				
+				# Reads the suffix after a boundary to determine if it's a closing boundary.
+				def read_boundary_suffix
+					# Read the rest of the boundary line to check if it's closing:
+					boundary_suffix = @readable.read(2)
+					if boundary_suffix == "--"
+						@is_closing = true
+						@ended = true
+						@readable = nil
+					elsif boundary_suffix == "\r\n"
+						@is_closing = false
+						@ended = true
+						@readable = nil
+					else
+						@readable = nil
+						raise EOFError, "Unexpected end of stream while reading part data!"
+					end
+				end
+				
+				# Finishes reading this part's data and advances to the next boundary.
+				# 
+				# @returns [String | Nil] The remaining content of the part, or nil if already finished.
+				def finish
+					return unless @readable
+					
+					# Read all data until boundary
+					data = @readable.read_until("\r\n--#{@boundary}", chomp: true)
+					
+					self.read_boundary_suffix
+					
+					return data
+				end
+				
+				# Efficiently discards all data until the next boundary is found.
+				# This is used to skip parts without reading their content into memory.
+				#
+				# @returns [Nil]
+				def discard
+					# Efficiently discard all data until boundary
+					return unless @readable
+					
+					# Discard data until boundary
+					@readable.discard_until("\r\n--#{@boundary}")
+					
+					self.read_boundary_suffix
+					
+					return nil
+				end
+				
+				# Checks if this part has been completely read.
+				#
+				# @returns [Boolean] True if this part has been completely read.
+				def ended?
+					@ended
+				end
+				
+				# Checks if this part ends with a closing boundary.
+				# A closing boundary indicates that this is the last part in the multipart message.
+				#
+				# @returns [Boolean] True if this part ends with a closing boundary.
+				def closing_boundary?
+					@is_closing || (@readable.nil? && @is_closing)
+				end
+			end
+			
+			# Initialize a new multipart parser.
+			#
+			# @parameter readable [IO, IO::Stream] The readable stream containing multipart data.
+			# @parameter boundary [String] The boundary string that separates the parts.
+			def initialize(readable, boundary)
+				@readable = IO::Stream(readable)
+				@boundary = boundary
+				
+				@boundary_marker = "--#{@boundary}\r\n".freeze
+			end
+			
+			# Enumerate through each part in the multipart data.
+			# Yields each part for processing. If no block is given, returns an enumerator.
+			#
+			# @returns [Enumerator, Boolean] An enumerator if no block given, or true when complete.
+			def each
+				return to_enum unless block_given?
+				
+				# Read lines until we find the first boundary:
+				while true
+					if line = @readable.gets("\r\n", chomp: false)
+						if line == @boundary_marker
+							break
+						end
+					else
+						# End of stream reached without finding boundary:
+						raise EOFError, "No multipart boundary found in stream!"
+					end
+				end
+				
+				while true
+					part = read_part
+					break unless part
+					
+					if part.read_empty_boundary?
+					else
+						begin
+							yield part
+						ensure
+							# After yielding, ensure the part is finished to advance to the next boundary. This is either a no-op if user already read the part, or reads remaining data.
+							part.discard
+						end
+					end
+					
+					# Check if this was the last part:
+					break if part.closing_boundary?
+				end
+				
+				return true
+			end
+			
+			private
+			
+			def read_part
+				headers = {}
+				value = nil
+				
+				# Read headers until empty line
+				while line = @readable.gets("\r\n", chomp: true)
+					if line.empty?
+						break # End of headers
+					elsif match = line.match(/^\s+([^:]+)$/)
+						if value
+							value << " " << match[1]
+						else
+							raise RuntimeError, "Unexpected whitespace before header name: #{line.inspect}"
+						end
+					elsif match = line.match(/^([^:]+):\s*(.*)$/) 
+						# Parse header line (name: value)
+						name = match[1].strip.downcase
+						value = match[2].strip
+						
+						if current = headers[name]
+							if current.is_a?(Array)
+								current << value
+							else
+								headers[name] = [current, value]
+							end
+						else
+							headers[name] = value
+						end
+					else
+						raise RuntimeError, "Invalid header line: #{line.inspect}"
+					end
+				end
+				
+				unless line
+					raise EOFError, "Unexpected end of stream while reading headers!"
+				end
+				
+				return Part.new(@readable, headers, @boundary)
+			end
+		end
+	end
+end

data/lib/protocol/multipart/part.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Protocol
+	module Multipart
+		# Represents a part in a multipart message.
+		class Part
+			# Initialize a new part with the given headers.
+			#
+			# @parameter headers [Hash] The headers for this part.
+			# @returns [void]
+			def initialize(headers = {})
+				@headers = headers
+			end
+			
+			# The headers associated with this part.
+			# @attribute [Hash] The headers as name/value pairs.
+			attr_accessor :headers
+			
+			# Writes the part to the writable body.
+			#
+			# @parameter writable [IO] The writable stream to write the part to.
+			# @parameter boundary [String] The boundary string used to separate parts.
+			def call(writable, boundary = nil)
+			end
+		end
+	end
+end

data/lib/protocol/multipart/string_part.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "part"
+
+module Protocol
+	module Multipart
+		# A part that contains string content.
+		# Represents a multipart part with string data.
+		class StringPart < Part
+			# Initialize a new StringPart with headers and string content.
+			#
+			# @parameter headers [Hash] Headers for the part.
+			# @parameter content [String] The string content of the part.
+			def initialize(headers, content)
+				super(headers)
+				@content = content
+			end
+			
+			# @attribute [String] The content of the part.
+			attr_reader :content
+			
+			# Write the part's content to the provided writable stream.
+			#
+			# @parameter writable [IO] The destination stream to write to.
+			# @parameter boundary [String] The boundary string for the multipart message.
+			def call(writable, boundary)
+				writable.write(@content)
+			end
+		end
+	end
+end

data/lib/protocol/multipart/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Protocol
+	module Multipart
+		VERSION = "0.1.0"
+	end
+end

data/lib/protocol/multipart.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "multipart/version"
+require_relative "multipart/parser"
+require_relative "multipart/body"
+require_relative "multipart/part"
+
+# @namespace
+module Protocol
+	# @namespace
+	module Multipart
+	end
+end

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2025, by Samuel Williams.  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/readme.md

@@ -0,0 +1,27 @@
+# `Protocol::Multipart`
+
+[![Development Status](https://github.com/socketry/protocol-multipart/workflows/Test/badge.svg)](https://github.com/socketry/protocol-multipart/actions?workflow=Test)
+
+## Releases
+
+Please see the [project releases](https://socketry.github.io/protocol-multipart/releases/index) for all releases.
+
+### v0.1.0
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

data/releases.md

@@ -0,0 +1,3 @@
+# Releases
+
+## v0.1.0

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: protocol-multipart
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: io-stream
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/protocol/multipart.rb
+- lib/protocol/multipart/boundary.rb
+- lib/protocol/multipart/escape.rb
+- lib/protocol/multipart/form_data.rb
+- lib/protocol/multipart/io_part.rb
+- lib/protocol/multipart/mixed.rb
+- lib/protocol/multipart/parser.rb
+- lib/protocol/multipart/part.rb
+- lib/protocol/multipart/string_part.rb
+- lib/protocol/multipart/version.rb
+- license.md
+- readme.md
+- releases.md
+homepage: https://github.com/socketry/protocol-multipart
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/protocol-multipart/
+  source_code_uri: https://github.com/socketry/protocol-multipart.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Provides abstractions to handle the multipart format.
+test_files: []