protocol-http1 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a739005ea471dd8601ea3844e71a6437981bcd5e4cb3e7d5c85f7eb699d55a8
+  data.tar.gz: 31c5dc038dceaa79552fb76bb56667f85e7e61ac568f06c564d426a9f6606784
+SHA512:
+  metadata.gz: 7aebf8675b398d210cc4fb457d498ea4a682112a93f4d298ced3ed24709dd3d1532eaa6ba56ceeaeb1c521545b23a48f557ba8616aec2f6d3fb2a57937e5ccb7
+  data.tar.gz: fcac06a0408e7bafede84eb1ab675bddfec3cc17605690fdc6f6111dc626412a65ff0f0dbefcd908d1c6b14068c4ac2adc03d0f9c717fb8ef9fef2b7f5d62f0e

data/.editorconfig

@@ -0,0 +1,6 @@
+root = true
+
+[*]
+indent_style = tab
+indent_size = 2
+

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--warnings
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+dist: xenial
+cache: bundler
+
+matrix:
+  include:
+    - rvm: 2.4
+    - rvm: 2.5
+    - rvm: 2.6
+    - rvm: 2.6
+      env: COVERAGE=PartialSummary,Coveralls
+    - rvm: truffleruby
+    - rvm: jruby-head
+      env: JRUBY_OPTS="--debug -X+O"
+    - rvm: ruby-head
+  allow_failures:
+    - rvm: truffleruby
+    - rvm: ruby-head
+    - rvm: jruby-head

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in protocol-http1.gemspec
+gemspec

data/README.md

@@ -0,0 +1,92 @@
+# Protocol::HTTP1
+
+Provides a low-level implementation of the HTTP/1 protocol.
+
+[![Build Status](https://secure.travis-ci.com/socketry/protocol-http1.svg)](http://travis-ci.com/socketry/protocol-http1)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'protocol-http1'
+```
+
+And then execute:
+
+	$ bundle
+
+Or install it yourself as:
+
+	$ gem install protocol-http1
+
+## Usage
+
+Here is a basic HTTP/1.1 client:
+
+```ruby
+require 'async'
+require 'async/io/stream'
+require 'async/http/url_endpoint'
+require 'protocol/http1/connection'
+
+Async.run do
+	endpoint = Async::HTTP::URLEndpoint.parse("https://www.google.com/search?q=kittens", alpn_protocols: ["http/1.1"])
+	
+	peer = endpoint.connect
+	
+	puts "Connected to #{peer} #{peer.remote_address.inspect}"
+	
+	# IO Buffering...
+	stream = Async::IO::Stream.new(peer)
+	client = Protocol::HTTP1::Connection.new(stream)
+	
+	def client.read_line
+		@stream.read_until(Protocol::HTTP1::Connection::CRLF) or raise EOFError
+	end
+	
+	puts "Writing request..."
+	client.write_request("www.google.com", "GET", "/search?q=kittens", "HTTP/1.1", [["Accept", "*/*"]])
+	client.write_body(nil)
+	
+	puts "Reading response..."
+	response = client.read_response("GET")
+	
+	puts "Got response: #{response.inspect}"
+	
+	puts "Closing client..."
+	client.close
+end
+```
+
+## Contributing
+
+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
+
+## License
+
+Released under the MIT license.
+
+Copyright, 2019, by [Samuel G. D. Williams](http://www.codeotaku.com/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/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/examples/http1/request.rb

@@ -0,0 +1,38 @@
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
+
+require 'async'
+require 'async/io/stream'
+require 'async/http/url_endpoint'
+require 'protocol/http1/connection'
+require 'pry'
+
+Async.run do
+	endpoint = Async::HTTP::URLEndpoint.parse("https://www.google.com/search?q=kittens", alpn_protocols: ["http/1.1"])
+	
+	peer = endpoint.connect
+	
+	puts "Connected to #{peer} #{peer.remote_address.inspect}"
+	
+	# IO Buffering...
+	stream = Async::IO::Stream.new(peer)
+	client = Protocol::HTTP1::Connection.new(stream)
+	
+	def client.read_line
+		@stream.read_until(Protocol::HTTP1::Connection::CRLF) or raise EOFError
+	end
+	
+	puts "Writing request..."
+	client.write_request("www.google.com", "GET", "/search?q=kittens", "HTTP/1.1", [["Accept", "*/*"]])
+	client.write_body(nil)
+	
+	puts "Reading response..."
+	response = client.read_response("GET")
+	
+	puts "Got response: #{response.inspect}"
+	
+	puts "Closing client..."
+	client.close
+end
+
+puts "Exiting."

data/lib/protocol/http1.rb

@@ -0,0 +1,22 @@
+# Copyright, 2019, 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 'http1/version'
+require_relative 'http1/connection'

data/lib/protocol/http1/connection.rb

@@ -0,0 +1,437 @@
+# 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 'protocol/http/headers'
+
+require_relative 'error'
+
+module Protocol
+	module HTTP1
+		CONTENT_LENGTH = 'content-length'.freeze
+		
+		TRANSFER_ENCODING = 'transfer-encoding'.freeze
+		CHUNKED = 'chunked'.freeze
+		
+		CONNECTION = 'connection'.freeze
+		CLOSE = 'close'.freeze
+		KEEP_ALIVE = 'keep-alive'.freeze
+		
+		HOST = 'host'.freeze
+		UPGRADE = 'upgrade'.freeze
+		
+		class Connection
+			CRLF = "\r\n".freeze
+			HTTP10 = "HTTP/1.0".freeze
+			HTTP11 = "HTTP/1.1".freeze
+			
+			def initialize(stream, persistent = true)
+				@stream = stream
+				
+				@persistent = persistent
+				@upgrade = nil
+				
+				@count = 0
+			end
+			
+			attr :stream
+			
+			# Whether the connection is persistent.
+			attr :persistent
+			
+			# Whether the connection has been upgraded, and to what.
+			attr :upgrade
+			
+			# The number of requests processed.
+			attr :count
+			
+			def upgrade?(headers)
+				if upgrade = headers[UPGRADE]
+					return upgrade.first
+				end
+			end
+			
+			def persistent?(version, headers)
+				if version == HTTP10
+					if connection = headers[CONNECTION]
+						return connection.include?(KEEP_ALIVE)
+					else
+						return false
+					end
+				else
+					if connection = headers[CONNECTION]
+						return !connection.include?(CLOSE)
+					else
+						return true
+					end
+				end
+			end
+			
+			def upgrade!(protocol)
+				@upgrade = protocol
+				@persistent = false
+				
+				return @stream
+			end
+			
+			# Write the appropriate header for connection persistence.
+			def write_connection_header(version)
+				if @upgrade
+					@stream.write("connection: upgrade\r\nupgrade: #{@upgrade}\r\n")
+				else
+					if version == HTTP10
+						@stream.write("connection: keep-alive\r\n") if @persistent
+					else
+						@stream.write("connection: close\r\n") unless @persistent
+					end
+				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
+			
+			# 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)
+				write_connection_header(version)
+			end
+			
+			def write_response(version, status, headers, body = nil, head = false)
+				@stream.write("#{version} #{status}\r\n")
+				
+				write_headers(headers)
+				write_connection_header(version)
+				write_body(body, version == HTTP11, head)
+			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
+				@stream.gets(CRLF, chomp: true) or raise EOFError
+			end
+			
+			def read_request
+				method, path, version = read_line.split(/\s+/, 3)
+				headers = read_headers
+				
+				@persistent = persistent?(version, headers)
+				@upgrade = upgrade?(headers)
+				
+				body = read_request_body(headers)
+				
+				@count += 1
+				
+				return headers.delete(HOST), method, path, version, headers, body
+			end
+			
+			def read_response(method)
+				version, status, reason = read_line.split(/\s+/, 3)
+				
+				status = Integer(status)
+				
+				headers = read_headers
+				
+				@persistent = persistent?(version, headers)
+				
+				body = read_response_body(method, status, headers)
+				
+				@count += 1
+				
+				return version, 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 HTTP::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:
+				@stream.read(2)
+				
+				return chunk
+			end
+			
+			def write_upgrade_body
+				@stream.write("\r\n")
+				@stream.flush
+				
+				return @stream unless block_given?
+				
+				begin
+					yield @stream
+				rescue
+					@stream.close_write
+				end
+			end
+			
+			def write_empty_body(body)
+				@stream.write("content-length: 0\r\n\r\n")
+				@stream.flush
+				
+				if body
+					body.close if body.respond_to?(:close)
+				end
+			end
+			
+			def write_fixed_length_body(body, length, head)
+				@stream.write("content-length: #{length}\r\n\r\n")
+				@stream.flush
+				
+				if head
+					body.close if body.respond_to?(:close)
+					
+					return
+				end
+				
+				chunk_length = 0
+				body.each do |chunk|
+					chunk_length += chunk.bytesize
+					
+					if chunk_length > length
+						raise ProtocolError, "Trying to write #{chunk_length} bytes, but content length was #{length} bytes!"
+					end
+					
+					@stream.write(chunk)
+				end
+				
+				@stream.flush
+				
+				if chunk_length != length
+					raise ProtocolError, "Wrote #{chunk_length} bytes, but content length was #{length} bytes!"
+				end
+			end
+			
+			def write_chunked_body(body, head)
+				@stream.write("transfer-encoding: chunked\r\n\r\n")
+				@stream.flush
+				
+				if head
+					body.close if body.respond_to?(:close)
+					
+					return
+				end
+				
+				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, head)
+				# We can't be persistent because we don't know the data length:
+				@persistent = false
+				@stream.write("\r\n")
+				@stream.flush
+				
+				if head
+					body.close if body.respond_to?(:close)
+				else
+					body.each do |chunk|
+						@stream.write(chunk)
+						@stream.flush
+					end
+				end
+				
+				@stream.close_write
+			end
+			
+			def write_body(body, chunked = true, head = false)
+				if body.nil? or body.empty?
+					write_empty_body(body)
+				elsif body.respond_to?(:call)
+					write_upgrade_body(&body)
+				elsif length = body.length
+					write_fixed_length_body(body, length, head)
+				elsif @persistent and chunked
+					# We specifically ensure that non-persistent connections do not use chunked response, so that hijacking works as expected.
+					write_chunked_body(body, head)
+				else
+					write_body_and_close(body, head)
+				end
+				
+				@stream.flush
+			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 >= 100 and status < 200) 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
+				
+				return read_body(headers, true)
+			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).
+				return read_body(headers)
+			end
+			
+			def read_body(headers, remainder = false)
+				# 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.delete(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_remainder_body
+					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.delete(CONTENT_LENGTH)
+					length = Integer(content_length)
+					if length > 0
+						return read_fixed_body(length)
+					elsif length == 0
+						return nil
+					else
+						raise BadRequest, "Invalid content length: #{content_length}"
+					end
+				end
+				
+				if remainder
+					# 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
+		end
+	end
+end

data/lib/protocol/http1/error.rb

@@ -0,0 +1,31 @@
+# Copyright, 2019, 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 'protocol/http/error'
+
+module Protocol
+	module HTTP1
+		class BadRequest < HTTP::BadRequest
+		end
+		
+		class ProtocolError < HTTP::ProtocolError
+		end
+	end
+end

data/lib/protocol/http1/version.rb

@@ -0,0 +1,5 @@
+module Protocol
+	module HTTP1
+		VERSION = "0.1.0"
+	end
+end

data/protocol-http1.gemspec

@@ -0,0 +1,29 @@
+
+require_relative 'lib/protocol/http1/version'
+
+Gem::Specification.new do |spec|
+	spec.name          = "protocol-http1"
+	spec.version       = Protocol::HTTP1::VERSION
+	spec.authors       = ["Samuel Williams"]
+	spec.email         = ["samuel.williams@oriontransfer.co.nz"]
+
+	spec.summary       = "A low level implementation of the HTTP/1 protocol."
+	spec.homepage      = "https://github.com/socketry/protocol-http1"
+	spec.license       = "MIT"
+
+	# Specify which files should be added to the gem when it is released.
+	# The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+	spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+		`git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+	end
+
+	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+	spec.require_paths = ["lib"]
+
+	spec.add_dependency "protocol-http"
+
+	spec.add_development_dependency "covered"
+	spec.add_development_dependency "bundler", "~> 1.17"
+	spec.add_development_dependency "rake", "~> 10.0"
+	spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: protocol-http1
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: protocol-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: covered
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- samuel.williams@oriontransfer.co.nz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- examples/http1/request.rb
+- lib/protocol/http1.rb
+- lib/protocol/http1/connection.rb
+- lib/protocol/http1/error.rb
+- lib/protocol/http1/version.rb
+- protocol-http1.gemspec
+homepage: https://github.com/socketry/protocol-http1
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.2
+signing_key: 
+specification_version: 4
+summary: A low level implementation of the HTTP/1 protocol.
+test_files: []