http-protocol 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84fb025f5c2cc394607d0c28b592c8fda12285a8340c0d3eb2a5ec8328aab371
-  data.tar.gz: 98a7233fe2c8e0f706d9738b0845bd86a9edd7e4fadf4335fc30763a3a468927
+  metadata.gz: 671f05047ee2dfd7365a45589f83f27a0f097c6e0cb787b61e3569863c0c5db4
+  data.tar.gz: fb4f399f497fd3480398522d2b7256800c04e99c944d0a2e00400335811c53b8
 SHA512:
-  metadata.gz: 5a436986f8203efcc943a7353acb3a8c9489f5e5576127b913482b684f4d879de6f4b88b05c9b17bd5c981826177be00b7f1f2876a6239ee0a5b7c17763afc84
-  data.tar.gz: 4453a7d3c4cab53a2ba6fdb1db9eb82988157582cd9c01b8aca9dd437d13cd6adfc4b20e1e03065cfc0150c497f67f8a05de3d1706d0ec932519e291227216a2
+  metadata.gz: 8b1c95fdac9a51fbbd9a285dd0619e7d463f668e85e5a5a4329e0eee5abd18e96cb911ff9311796d14ac36e8515f3803acd4758e73112e4f857cc60bd73b9e60
+  data.tar.gz: ac491a301fe51695e6ac1efae9fe1e73fe13d4b9ad8eac87f43753d60107fbd57e20e5589422e25a7496849d793205cab37db4e501657a7cd82b3deca26496fc

data/README.md

@@ -23,11 +23,11 @@ Or install it yourself as:
 ### HTTP2
 
 ```ruby
-framer = HTTP::Protocol::HTTP2::Framer.new(io)
+framer = HTTP::Protocol::HTTP2::Framer.new(stream)
 
 frame = framer.read_frame
 
-frame.write(io)
+frame.write(stream)
 ```
 
 ## Contributing

data/lib/http/protocol/headers.rb

@@ -20,6 +20,10 @@
 
 module HTTP
 	module Protocol
+		TRANSFER_ENCODING = 'transfer-encoding'.freeze
+		CONTENT_LENGTH = 'content-length'.freeze
+		CHUNKED = 'chunked'.freeze
+		
 		class Headers
 			class Split < Array
 				COMMA = /\s*,\s*/

data/lib/http/protocol/http10/connection.rb

@@ -0,0 +1,53 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+require_relative '../http11/connection'
+
+module HTTP
+	module Protocol
+		module HTTP10
+			class Connection < HTTP11::Connection
+				KEEP_ALIVE = 'keep-alive'.freeze
+				VERSION = "HTTP/1.0".freeze
+				
+				def version
+					VERSION
+				end
+				
+				def persistent?(headers)
+					if connection = headers[CONNECTION]
+						return connection.include?(KEEP_ALIVE)
+					else
+						return false
+					end
+				end
+				
+				def write_persistent_header
+					@stream.write("connection: keep-alive\r\n") if @persistent
+				end
+				
+				def write_body(body, chunked = false)
+					# We don't support chunked encoding by default.
+					super(body, chunked)
+				end
+			end
+		end
+	end
+end

data/lib/http/protocol/http11/connection.rb

@@ -0,0 +1,395 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+require_relative '../error'
+
+module HTTP
+	module Protocol
+		module HTTP11
+			class Connection
+				CRLF = "\r\n".freeze
+				CONNECTION = 'connection'.freeze
+				HOST = 'host'.freeze
+				CLOSE = 'close'.freeze
+				VERSION = "HTTP/1.1".freeze
+				
+				def initialize(stream, persistent = true)
+					@stream = stream
+					
+					@persistent = persistent
+					
+					@count = 0
+				end
+				
+				attr :stream
+				attr :persistent
+				attr :count
+				
+				def version
+					VERSION
+				end
+				
+				def persistent?(headers)
+					if connection = headers[CONNECTION]
+						return !connection.include?(CLOSE)
+					else
+						return true
+					end
+				end
+				
+				# Effectively close the connection and return the underlying IO.
+				# @return [IO] the underlying non-blocking IO.
+				def hijack
+					@persistent = false
+					
+					@stream.flush
+					
+					return @stream
+				end
+				
+				# Write the appropriate header for connection persistence.
+				def write_persistent_header
+					@stream.write("connection: keep-alive\r\n") if @persistent
+				end
+				
+				# Close the connection and underlying stream.
+				def close
+					@stream.close
+				end
+				
+				def write_request(authority, method, path, version, headers)
+					@stream.write("#{method} #{path} #{version}\r\n")
+					@stream.write("host: #{authority}\r\n")
+					
+					write_headers(headers)
+					
+					@stream.flush
+				end
+				
+				def write_response(version, status, headers, body = nil, head = false)
+					@stream.write("#{version} #{status}\r\n")
+					write_headers(headers)
+					
+					if head
+						write_body_head(body)
+					else
+						write_body(body)
+					end
+					
+					@stream.flush
+				end
+				
+				def write_headers(headers)
+					headers.each do |name, value|
+						@stream.write("#{name}: #{value}\r\n")
+					end
+				end
+				
+				def each_line
+					while line = read_line
+						yield line
+					end
+				end
+				
+				def read_line
+					# To support Ruby 2.3, we do the following which is pretty inefficient. Ruby 2.4+ can do the following:
+					# @stream.gets(CRLF, chomp: true) or raise EOFError
+					if line = @stream.gets(CRLF)
+						return line.chomp!(CRLF)
+					else
+						raise EOFError
+					end
+				end
+				
+				def read_request
+					method, path, version = read_line.split(/\s+/, 3)
+					headers = read_headers
+					
+					@persistent = persistent?(headers)
+					
+					body = read_request_body(headers)
+					
+					@count += 1
+					
+					return headers[HOST], method, path, version, headers, body
+				end
+				
+				def read_response(method)
+					version, status, reason = read_line.split(/\s+/, 3)
+					Async.logger.debug(self) {"#{version} #{status} #{reason}"}
+					
+					headers = read_headers
+					
+					@persistent = persistent?(headers)
+					
+					body = read_response_body(method, status, headers)
+					
+					@count += 1
+					
+					return version, Integer(status), reason, headers, body
+				end
+				
+				def read_headers
+					fields = []
+					
+					self.each_line do |line|
+						if line =~ /^([a-zA-Z\-\d]+):\s*(.+?)\s*$/
+							fields << [$1, $2]
+						else
+							break
+						end
+					end
+					
+					return Headers.new(fields)
+				end
+				
+				def read_chunk
+					length = self.read_line.to_i(16)
+					
+					if length == 0
+						self.read_line
+						
+						return nil
+					end
+					
+					# Read the data:
+					chunk = @stream.read(length)
+					
+					# Consume the trailing CRLF:
+					crlf = @stream.read(2)
+					
+					return chunk
+				end
+				
+				def write_chunk(chunk)
+					if chunk.nil?
+						@stream.write("0\r\n\r\n")
+					elsif !chunk.empty?
+						@stream.write("#{chunk.bytesize.to_s(16).upcase}\r\n")
+						@stream.write(chunk)
+						@stream.write(CRLF)
+						@stream.flush
+					end
+				end
+				
+				def write_empty_body(body)
+					# Write empty body:
+					write_persistent_header
+					@stream.write("content-length: 0\r\n\r\n")
+					
+					body.read if body
+					
+					@stream.flush
+				end
+				
+				def write_fixed_length_body(body, length)
+					write_persistent_header
+					@stream.write("content-length: #{length}\r\n\r\n")
+					
+					chunk_length = 0
+					body.each do |chunk|
+						chunk_length += chunk.bytesize
+						
+						if chunk_length > length
+							raise ArgumentError, "Trying to write #{chunk_length} bytes, but content length was #{length} bytes!"
+						end
+						
+						@stream.write(chunk)
+					end
+					
+					@stream.flush
+					
+					if chunk_length != length
+						raise ArgumentError, "Wrote #{chunk_length} bytes, but content length was #{length} bytes!"
+					end
+				end
+				
+				def write_chunked_body(body)
+					write_persistent_header
+					@stream.write("transfer-encoding: chunked\r\n\r\n")
+					
+					body.each do |chunk|
+						next if chunk.size == 0
+						
+						@stream.write("#{chunk.bytesize.to_s(16).upcase}\r\n")
+						@stream.write(chunk)
+						@stream.write(CRLF)
+						@stream.flush
+					end
+					
+					@stream.write("0\r\n\r\n")
+					@stream.flush
+				end
+				
+				def write_body_and_close(body)
+					# We can't be persistent because we don't know the data length:
+					@persistent = false
+					write_persistent_header
+					
+					@stream.write("\r\n")
+					
+					body.each do |chunk|
+						@stream.write(chunk)
+						@stream.flush
+					end
+					
+					@stream.stream.close_write
+				end
+				
+				def write_body(body, chunked = true)
+					if body.nil? or body.empty?
+						write_empty_body(body)
+					elsif length = body.length
+						write_fixed_length_body(body, length)
+					elsif chunked
+						write_chunked_body(body)
+					else
+						write_body_and_close(body)
+					end
+				end
+				
+				def write_body_head(body)
+					write_persistent_header
+					
+					if body.nil? or body.empty?
+						@stream.write("content-length: 0\r\n\r\n")
+					elsif length = body.length
+						@stream.write("content-length: #{length}\r\n\r\n")
+					else
+						@stream.write("\r\n")
+					end
+				end
+				
+				def read_chunked_body
+					buffer = String.new.b
+					
+					while chunk = read_chunk
+						buffer << chunk
+						chunk.clear
+					end
+					
+					return buffer
+				end
+				
+				def read_fixed_body(length)
+					@stream.read(length)
+				end
+				
+				def read_tunnel_body
+					read_remainder_body
+				end
+				
+				def read_remainder_body
+					@stream.read
+				end
+				
+				HEAD = "HEAD".freeze
+				CONNECT = "CONNECT".freeze
+				
+				def read_response_body(method, status, headers)
+					# RFC 7230 3.3.3
+					# 1.  Any response to a HEAD request and any response with a 1xx
+					# (Informational), 204 (No Content), or 304 (Not Modified) status
+					# code is always terminated by the first empty line after the
+					# header fields, regardless of the header fields present in the
+					# message, and thus cannot contain a message body.
+					if method == "HEAD" or status == 204 or status == 304
+						return nil
+					end
+					
+					# 2.  Any 2xx (Successful) response to a CONNECT request implies that
+					# the connection will become a tunnel immediately after the empty
+					# line that concludes the header fields.  A client MUST ignore any
+					# Content-Length or Transfer-Encoding header fields received in
+					# such a message.
+					if method == "CONNECT" and status == 200
+						return read_tunnel_body
+					end
+					
+					if body = read_body(headers)
+						return body
+					else
+						# 7.  Otherwise, this is a response message without a declared message
+						# body length, so the message body length is determined by the
+						# number of octets received prior to the server closing the
+						# connection.
+						return read_remainder_body
+					end
+				end
+				
+				def read_request_body(headers)
+					# 6.  If this is a request message and none of the above are true, then
+					# the message body length is zero (no message body is present).
+					if body = read_body(headers)
+						return body
+					end
+				end
+				
+				def read_body(headers)
+					# 3.  If a Transfer-Encoding header field is present and the chunked
+					# transfer coding (Section 4.1) is the final encoding, the message
+					# body length is determined by reading and decoding the chunked
+					# data until the transfer coding indicates the data is complete.
+					if transfer_encoding = headers[TRANSFER_ENCODING]
+						# If a message is received with both a Transfer-Encoding and a
+						# Content-Length header field, the Transfer-Encoding overrides the
+						# Content-Length.  Such a message might indicate an attempt to
+						# perform request smuggling (Section 9.5) or response splitting
+						# (Section 9.4) and ought to be handled as an error.  A sender MUST
+						# remove the received Content-Length field prior to forwarding such
+						# a message downstream.
+						if headers[CONTENT_LENGTH]
+							raise BadRequest, "Message contains both transfer encoding and content length!"
+						end
+						
+						if transfer_encoding.last == CHUNKED
+							return read_chunked_body
+						else
+							# If a Transfer-Encoding header field is present in a response and
+							# the chunked transfer coding is not the final encoding, the
+							# message body length is determined by reading the connection until
+							# it is closed by the server.  If a Transfer-Encoding header field
+							# is present in a request and the chunked transfer coding is not
+							# the final encoding, the message body length cannot be determined
+							# reliably; the server MUST respond with the 400 (Bad Request)
+							# status code and then close the connection.
+							return read_body_remainder
+						end
+					end
+
+					# 5.  If a valid Content-Length header field is present without
+					# Transfer-Encoding, its decimal value defines the expected message
+					# body length in octets.  If the sender closes the connection or
+					# the recipient times out before the indicated number of octets are
+					# received, the recipient MUST consider the message to be
+					# incomplete and close the connection.
+					if content_length = headers[CONTENT_LENGTH]
+						length = Integer(content_length)
+						if length >= 0
+							return read_fixed_body(length)
+						else
+							raise BadRequest, "Invalid content length: #{content_length}"
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/http/protocol/http2/continuation_frame.rb

@@ -34,21 +34,21 @@ module HTTP
 					flag_set?(END_HEADERS)
 				end
 				
-				def read(io, maximum_frame_size)
+				def read(stream, maximum_frame_size)
 					super
 					
 					unless end_headers?
 						@continuation = ContinuationFrame.new
 						
-						@continuation.read(io, maximum_frame_size)
+						@continuation.read(stream, maximum_frame_size)
 					end
 				end
 				
-				def write(io)
+				def write(stream)
 					super
 					
 					if continuation = self.continuation
-						continuation.write(io)
+						continuation.write(stream)
 					end
 				end
 				

data/lib/http/protocol/http2/frame.rb

@@ -36,7 +36,7 @@ module HTTP
 				include Comparable
 				
 				# Stream Identifier cannot be bigger than this:
-				# https://http2.github.io/http2-spec/#rfc.section.4.1
+				# https://http2.github.stream/http2-spec/#rfc.section.4.1
 				VALID_STREAM_ID = 0..0x7fffffff
 				
 				# The absolute maximum bounds for the length field:
@@ -151,39 +151,39 @@ module HTTP
 					return length, type, flags, stream_id
 				end
 				
-				def read_header(io)
-					@length, @type, @flags, @stream_id = Frame.parse_header(io.read(9))
+				def read_header(stream)
+					@length, @type, @flags, @stream_id = Frame.parse_header(stream.read(9))
 				end
 				
-				def read_payload(io)
-					@payload = io.read(@length)
+				def read_payload(stream)
+					@payload = stream.read(@length)
 				end
 				
-				def read(io, maximum_frame_size = MAXIMUM_ALLOWED_FRAME_SIZE)
-					read_header(io) unless @length
+				def read(stream, maximum_frame_size = MAXIMUM_ALLOWED_FRAME_SIZE)
+					read_header(stream) unless @length
 					
 					if @length > maximum_frame_size
 						raise FrameSizeError, "Frame length #{@length} exceeds maximum frame size #{maximum_frame_size}!"
 					end
 					
-					read_payload(io)
+					read_payload(stream)
 				end
 				
-				def write_header(io)
-					io.write self.header
+				def write_header(stream)
+					stream.write self.header
 				end
 				
-				def write_payload(io)
-					io.write(@payload) if @payload
+				def write_payload(stream)
+					stream.write(@payload) if @payload
 				end
 				
-				def write(io)
+				def write(stream)
 					if @payload and @length != @payload.bytesize
 						raise ProtocolError, "Invalid payload size: #{@length} != #{@payload.bytesize}"
 					end
 					
-					self.write_header(io)
-					self.write_payload(io)
+					self.write_header(stream)
+					self.write_payload(stream)
 				end
 				
 				def apply(connection)

data/lib/http/protocol/http2/framer.rb

@@ -53,23 +53,21 @@ module HTTP
 			CONNECTION_PREFACE_MAGIC = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n".freeze
 			
 			class Framer
-				def initialize(io, frames = FRAMES)
-					@io = io
+				def initialize(stream, frames = FRAMES)
+					@stream = stream
 					@frames = frames
-					
-					@buffer = String.new.b
 				end
 				
 				def close
-					@io.close
+					@stream.close
 				end
 				
 				def write_connection_preface
-					@io.write(CONNECTION_PREFACE_MAGIC)
+					@stream.write(CONNECTION_PREFACE_MAGIC)
 				end
 				
 				def read_connection_preface
-					string = @io.read(CONNECTION_PREFACE_MAGIC.bytesize)
+					string = @stream.read(CONNECTION_PREFACE_MAGIC.bytesize)
 					
 					unless string == CONNECTION_PREFACE_MAGIC
 						raise ProtocolError, "Invalid connection preface: #{string.inspect}"
@@ -89,20 +87,20 @@ module HTTP
 					frame = klass.new(stream_id, flags, type, length)
 					
 					# Read the payload:
-					frame.read(@io, maximum_frame_size)
+					frame.read(@stream, maximum_frame_size)
 					
 					return frame
 				end
 				
 				def write_frame(frame)
 					# puts "framer: write_frame #{frame.inspect}"
-					frame.write(@io)
+					frame.write(@stream)
 					
-					@io.flush
+					@stream.flush
 				end
 				
 				def read_header
-					if buffer = @io.read(9)
+					if buffer = @stream.read(9)
 						return Frame.parse_header(buffer)
 					else
 						# TODO: Is this necessary? I thought the IO would throw this.

data/lib/http/protocol/http2/ping_frame.rb

@@ -69,7 +69,7 @@ module HTTP
 					return frame
 				end
 				
-				def read_payload(io)
+				def read_payload(stream)
 					super
 					
 					if @length > 8

data/lib/http/protocol/http2/priority_frame.rb

@@ -69,7 +69,7 @@ module HTTP
 					connection.receive_priority(self)
 				end
 				
-				def read_payload(io)
+				def read_payload(stream)
 					super
 					
 					if @length != 5

data/lib/http/protocol/http2/reset_stream_frame.rb

@@ -61,7 +61,7 @@ module HTTP
 					connection.receive_reset_stream(self)
 				end
 				
-				def read_payload(io)
+				def read_payload(stream)
 					super
 					
 					if @length != 4

data/lib/http/protocol/http2/settings_frame.rb

@@ -218,7 +218,7 @@ module HTTP
 					connection.receive_settings(self)
 				end
 				
-				def read_payload(io)
+				def read_payload(stream)
 					super
 					
 					if @stream_id != 0

data/lib/http/protocol/reference.rb

@@ -0,0 +1,188 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+module HTTP
+	module Protocol
+		# A relative reference, excluding any authority.
+		class Reference
+			def initialize(path, query_string, fragment, parameters)
+				@path = path
+				@query_string = query_string
+				@fragment = fragment
+				@parameters = parameters
+			end
+			
+			def self.[] reference
+				if reference.is_a? self
+					return reference
+				else
+					return self.parse(reference)
+				end
+			end
+			
+			# Generate a reference from a path and user parameters. The path may contain a `#fragment` or `?query=parameters`.
+			def self.parse(path = '/', parameters = nil)
+				base, fragment = path.split('#', 2)
+				path, query_string = base.split('?', 2)
+				
+				self.new(path, query_string, fragment, parameters)
+			end
+			
+			# The path component, e.g. /foo/bar/index.html
+			attr :path
+			
+			# The un-parsed query string, e.g. 'x=10&y=20'
+			attr :query_string
+			
+			# A fragment, the part after the '#'
+			attr :fragment
+			
+			# User supplied parameters that will be appended to the query part.
+			attr :parameters
+			
+			def parameters?
+				@parameters and !@parameters.empty?
+			end
+			
+			def query_string?
+				@query_string and !@query_string.empty?
+			end
+			
+			def fragment?
+				@fragment and !@fragment.empty?
+			end
+			
+			def append(buffer)
+				if query_string?
+					buffer << escape_path(@path) << '?' << @query_string
+					buffer << '&' << encode(@parameters) if parameters?
+				else
+					buffer << escape_path(@path)
+					buffer << '?' << encode(@parameters) if parameters?
+				end
+				
+				if fragment?
+					buffer << '#' << escape(@fragment)
+				end
+				
+				return buffer
+			end
+			
+			def to_str
+				append(String.new)
+			end
+			
+			alias to_s to_str
+			
+			def + other
+				other = self.class[other]
+				
+				self.class.new(
+					expand_path(self.path, other.path),
+					other.query_string,
+					other.fragment,
+					other.parameters,
+				)
+			end
+			
+			def [] parameters
+				self.dup(nil, parameters)
+			end
+			
+			def dup(path = nil, parameters = nil)
+				if @parameters
+					if parameters
+						parameters = @parameters.merge(parameters)
+					else
+						parameters = @parameters
+					end
+				end
+				
+				if path
+					path = @path + '/' + path
+				else
+					path = @path
+				end
+				
+				self.class.new(path, @query_string, @fragment, parameters)
+			end
+			
+			private
+			
+			def expand_path(base, relative)
+				if relative.start_with? '/'
+					return relative
+				else
+					path = base.split('/')
+					parts = relative.split('/')
+					
+					parts.each do |part|
+						if part == '..'
+							path.pop
+						else
+							path << part
+						end
+					end
+					
+					return path.join('/')
+				end
+			end
+			
+			# Escapes a generic string, using percent encoding.
+			def escape(string)
+				encoding = string.encoding
+				string.b.gsub(/([^a-zA-Z0-9_.\-]+)/) do |m|
+					'%' + m.unpack('H2' * m.bytesize).join('%').upcase
+				end.force_encoding(encoding)
+			end
+			
+			# According to https://tools.ietf.org/html/rfc3986#section-3.3, we escape non-pchar.
+			NON_PCHAR = /([^a-zA-Z0-9_\-\.~!$&'()*+,;=:@\/]+)/.freeze
+			
+			# Escapes a path
+			def escape_path(path)
+				encoding = path.encoding
+				path.b.gsub(NON_PCHAR) do |m|
+					'%' + m.unpack('H2' * m.bytesize).join('%').upcase
+				end.force_encoding(encoding)
+			end
+			
+			# Encodes a hash or array into a query string
+			def encode(value, prefix = nil)
+				case value
+				when Array
+					return value.map {|v|
+						encode(v, "#{prefix}[]")
+					}.join("&")
+				when Hash
+					return value.map {|k, v|
+						encode(v, prefix ? "#{prefix}[#{escape(k.to_s)}]" : escape(k.to_s))
+					}.reject(&:empty?).join('&')
+				when nil
+					return prefix
+				else
+					raise ArgumentError, "value must be a Hash" if prefix.nil?
+					
+					return "#{prefix}=#{escape(value.to_s)}"
+				end
+			end
+		end
+	end
+end

data/lib/http/protocol/version.rb

@@ -20,6 +20,6 @@
 
 module HTTP
 	module Protocol
-		VERSION = "0.3.2"
+		VERSION = "0.4.0"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: http-protocol
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-21 00:00:00.000000000 Z
+date: 2018-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-hpack
@@ -83,6 +83,8 @@ files:
 - lib/http/protocol.rb
 - lib/http/protocol/error.rb
 - lib/http/protocol/headers.rb
+- lib/http/protocol/http10/connection.rb
+- lib/http/protocol/http11/connection.rb
 - lib/http/protocol/http2/client.rb
 - lib/http/protocol/http2/connection.rb
 - lib/http/protocol/http2/continuation_frame.rb
@@ -101,6 +103,7 @@ files:
 - lib/http/protocol/http2/settings_frame.rb
 - lib/http/protocol/http2/stream.rb
 - lib/http/protocol/http2/window_update_frame.rb
+- lib/http/protocol/reference.rb
 - lib/http/protocol/version.rb
 homepage: https://github.com/socketry/http-protocol
 licenses: []
@@ -121,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Provides abstractions to handle HTTP1 and HTTP2 protocols.