Modernize code.

Author: ioquatix

.github/copilot-instructions.md

@@ -0,0 +1,20 @@
+# GitHub Copilot Instructions
+
+## Use Agent Context
+
+When working on this project, consult the `agents.md` file for project-specific guidelines, architecture decisions, and development patterns. This file contains curated information that will help you make better decisions aligned with the project's goals and standards.
+
+If the file does not exist, you will need to install it, by running the following command:
+
+```bash
+$ bundle install
+$ bundle exec bake agent:context:install
+```
+
+This command will set up the necessary context files that help you understand the project structure, dependencies, and conventions.
+
+## Ignoring Files
+
+The `.gitignore` file is split into two sections, separated by a blank line. The first section is automatically generated, while the second section is user controlled.
+
+While working on pull requests, you should not add unrelated changes to the `.gitignore` file as part of the pull request.

.gitignore

@@ -1,5 +1,6 @@
-/.bundle
+/agents.md
 /.context
+/.bundle
 /pkg
 /gems.locked
 /.covered.db

.rubocop.yml

@@ -1,12 +1,23 @@
 plugins:
+  - rubocop-md
   - rubocop-socketry
 
 AllCops:
   DisabledByDefault: true
 
+# Socketry specific rules:
+
 Layout/ConsistentBlankLineIndentation:
   Enabled: true
 
+Layout/BlockDelimiterSpacing:
+  Enabled: true
+
+Style/GlobalExceptionVariables:
+  Enabled: true
+
+# General Layout rules:
+
 Layout/IndentationStyle:
   Enabled: true
   EnforcedStyle: tabs
@@ -33,6 +44,9 @@ Layout/BeginEndAlignment:
   Enabled: true
   EnforcedStyleAlignWith: start_of_line
 
+Layout/RescueEnsureAlignment:
+  Enabled: true
+
 Layout/ElseAlignment:
   Enabled: true
 
@@ -41,10 +55,15 @@ Layout/DefEndAlignment:
 
 Layout/CaseIndentation:
   Enabled: true
+  EnforcedStyle: end
 
 Layout/CommentIndentation:
   Enabled: true
 
+Layout/FirstHashElementIndentation:
+  Enabled: true
+  EnforcedStyle: consistent
+
 Layout/EmptyLinesAroundClassBody:
   Enabled: true
 

examples/server/server.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2022-2024, by Samuel Williams.
+# Copyright, 2022-2025, by Samuel Williams.
 
 require "async"
 require "async/http/server"

gems.rb

@@ -21,6 +21,7 @@
 	gem "decode"
 
 	gem "rubocop"
+	gem "rubocop-md"
 	gem "rubocop-socketry"
 
 	gem "sus-fixtures-async"

readme.md

@@ -18,26 +18,26 @@ Please see the [project documentation](https://socketry.github.io/protocol-rack/
 Given a rack application, you can adapt it for use on `async-http`:
 
 ``` ruby
-require 'async'
-require 'async/http/server'
-require 'async/http/client'
-require 'async/http/endpoint'
-require 'protocol/rack/adapter'
+require "async"
+require "async/http/server"
+require "async/http/client"
+require "async/http/endpoint"
+require "protocol/rack/adapter"
 
 app = proc{|env| [200, {}, ["Hello World"]]}
 middleware = Protocol::Rack::Adapter.new(app)
 
 Async do
-  endpoint = Async::HTTP::Endpoint.parse("http://localhost:9292")
-  
-  server_task = Async(transient: true) do
-    server = Async::HTTP::Server.new(middleware, endpoint)
-    server.run
-  end
-  
-  client = Async::HTTP::Client.new(endpoint)
-  puts client.get("/").read
-  # "Hello World"
+	endpoint = Async::HTTP::Endpoint.parse("http://localhost:9292")
+	
+	server_task = Async(transient: true) do
+		server = Async::HTTP::Server.new(middleware, endpoint)
+		server.run
+	end
+	
+	client = Async::HTTP::Client.new(endpoint)
+	puts client.get("/").read
+		# "Hello World"
 end
 ```
 
@@ -46,21 +46,21 @@ end
 While not tested, in theory any Rack compatible server can host `Protocol::HTTP` compatible middlewares.
 
 ``` ruby
-require 'protocol/http/middleware'
-require 'protocol/rack'
+require "protocol/http/middleware"
+require "protocol/rack"
 
 # Your native application:
 middleware = Protocol::HTTP::Middleware::HelloWorld
 
-run proc{|env|
-  # Convert the rack request to a compatible rich request object:
-  request = Protocol::Rack::Request[env]
-  
-  # Call your application
-  response = middleware.call(request)
-  
-  Protocol::Rack::Adapter.make_response(env, response)
-}
+run do |env|
+	# Convert the rack request to a compatible rich request object:
+	request = Protocol::Rack::Request[env]
+	
+	# Call your application
+	response = middleware.call(request)
+	
+	Protocol::Rack::Adapter.make_response(env, response)
+end
 ```
 
 ## Releases

test/protocol/rack/adapter.rb

@@ -178,7 +178,7 @@
 			let(:response) {client.get("/")}
 
 			with "nil response" do
-				let(:app) {->(env) {nil}}
+				let(:app) {->(env){nil}}
 
 				it "raises an error" do
 					expect(response.status).to be == 500
@@ -187,7 +187,7 @@
 			end
 
 			with "nil headers" do
-				let(:app) {->(env) {[200, nil, []]}}
+				let(:app) {->(env){[200, nil, []]}}
 
 				it "raises an error" do
 					expect(response.status).to be == 500

test/protocol/rack/adapter/generic.rb

@@ -125,7 +125,7 @@
 
 	with "response callbacks" do
 		let(:callback_called) {false}
-		let(:callback) {->(env, status, headers, exception) {@callback_called = true}}
+		let(:callback) {->(env, status, headers, exception){@callback_called = true}}
 		let(:app) do
 			proc do |env|
 				env[Protocol::Rack::RACK_RESPONSE_FINISHED] = [callback]

test/protocol/rack/adapter/rack2.rb

@@ -14,31 +14,31 @@
 	include Sus::Fixtures::Console::CapturedLogger
 
 	with "#call" do
-		let(:app) {->(env) {[200, {}, []]}}
+		let(:app) {->(env){[200, {}, []]}}
 		let(:adapter) {subject.new(app)}
 
 		let(:body) {Protocol::HTTP::Body::Buffered.new}
 		let(:request) {Protocol::HTTP::Request.new("https", "example.com", "GET", "/", "http/1.1", Protocol::HTTP::Headers[{"accept" => "text/html"}], body)}
 		let(:response) {adapter.call(request)}
 
 		with "set-cookie headers that has multiple values" do
-			let(:app) {->(env) {[200, {"set-cookie" => "a=b\nx=y"}, []]}}
+			let(:app) {->(env){[200, {"set-cookie" => "a=b\nx=y"}, []]}}
 
 			it "can make a response newline separated headers" do
 				expect(response.headers["set-cookie"]).to be == ["a=b", "x=y"]
 			end
 		end
 
 		with "content-length header" do
-			let(:app) {->(env) {[200, {"content-length" => "10"}, ["1234567890"]]}}
+			let(:app) {->(env){[200, {"content-length" => "10"}, ["1234567890"]]}}
 
 			it "removes content-length header" do
 				expect(response.headers).not.to be(:include?, "content-length")
 			end
 		end
 
 		with "connection: close header" do
-			let(:app) {->(env) {[200, {"connection" => "close"}, []]}}
+			let(:app) {->(env){[200, {"connection" => "close"}, []]}}
 
 			it "removes content-length header" do
 				expect(response.headers).not.to be(:include?, "connection")
@@ -47,7 +47,7 @@
 
 		with "body that responds to #to_path" do
 			let(:body) {Array.new}
-			let(:app) {->(env) {[200, {}, body]}}
+			let(:app) {->(env){[200, {}, body]}}
 
 			it "should generate file body" do
 				expect(body).to receive(:to_path).and_return("/dev/null")
@@ -56,7 +56,7 @@
 			end
 
 			with "206 partial response status" do
-				let(:app) {->(env) {[200, {}, body]}}
+				let(:app) {->(env){[200, {}, body]}}
 
 				it "should not modify partial responses" do
 					expect(response.body).to be_a(Protocol::Rack::Body::Enumerable)
@@ -75,7 +75,7 @@
 
 		with "response handling" do
 			with "array response" do
-				let(:app) {->(env) {[200, {}, ["Hello"]]}}
+				let(:app) {->(env){[200, {}, ["Hello"]]}}
 
 				it "handles array response correctly" do
 					expect(response.body).to be_a(Protocol::Rack::Body::Enumerable)
@@ -85,31 +85,31 @@
 
 		with "header transformation" do
 			with "array values" do
-				let(:app) {->(env) {[200, {"x-custom" => "a\nb"}, []]}}
+				let(:app) {->(env){[200, {"x-custom" => "a\nb"}, []]}}
 
 				it "joins array values with newlines in response" do
 					expect(response.headers["x-custom"]).to be == ["a", "b"]
 				end
 			end
 
 			with "non-array values" do
-				let(:app) {->(env) {[200, {"x-custom" => "value"}, []]}}
+				let(:app) {->(env){[200, {"x-custom" => "value"}, []]}}
 
 				it "preserves non-array values" do
 					expect(response.headers["x-custom"]).to be == ["value"]
 				end
 			end
 
 			with "multiple set-cookie headers" do
-				let(:app) {->(env) {[200, {"set-cookie" => "a=b\nx=y"}, []]}}
+				let(:app) {->(env){[200, {"set-cookie" => "a=b\nx=y"}, []]}}
 
 				it "joins set-cookie headers with newlines" do
 					expect(response.headers["set-cookie"]).to be == ["a=b", "x=y"]
 				end
 			end
 
 			with "rack specific headers" do
-				let(:app) {->(env) {[200, {"rack.hijack" => ->(stream){}}, []]}}
+				let(:app) {->(env){[200, {"rack.hijack" => ->(stream){}}, []]}}
 
 				it "preserves rack specific headers in meta" do
 					expect(response.headers).not.to be(:include?, "rack.hijack")
@@ -149,7 +149,7 @@
 		let(:adapter) {subject.new(app)}
 
 		let(:callback_called) {false}
-		let(:callback) {->(env, status, headers, exception) {@callback_called = true}}
+		let(:callback) {->(env, status, headers, exception){@callback_called = true}}
 		let(:app) do
 			proc do |env|
 				env[Protocol::Rack::RACK_RESPONSE_FINISHED] = [callback]

test/protocol/rack/adapter/rack3.rb

@@ -12,31 +12,31 @@
 	include Sus::Fixtures::Console::CapturedLogger
 
 	with "#call" do
-		let(:app) {->(env) {[200, {}, []]}}
+		let(:app) {->(env){[200, {}, []]}}
 		let(:adapter) {subject.new(app)}
 
 		let(:body) {Protocol::HTTP::Body::Buffered.new}
 		let(:request) {Protocol::HTTP::Request.new("https", "example.com", "GET", "/", "http/1.1", Protocol::HTTP::Headers[{"accept" => "text/html"}], body)}
 		let(:response) {adapter.call(request)}
 
 		with "set-cookie headers that has multiple values" do
-			let(:app) {->(env) {[200, {"set-cookie" => ["a=b", "x=y"]}, []]}}
+			let(:app) {->(env){[200, {"set-cookie" => ["a=b", "x=y"]}, []]}}
 
 			it "can make a response newline separated headers" do
 				expect(response.headers["set-cookie"]).to be == ["a=b", "x=y"]
 			end
 		end
 
 		with "content-length header" do
-			let(:app) {->(env) {[200, {"content-length" => "10"}, ["1234567890"]]}}
+			let(:app) {->(env){[200, {"content-length" => "10"}, ["1234567890"]]}}
 
 			it "removes content-length header" do
 				expect(response.headers).not.to be(:include?, "content-length")
 			end
 		end
 
 		with "connection: close header" do
-			let(:app) {->(env) {[200, {"connection" => "close"}, []]}}
+			let(:app) {->(env){[200, {"connection" => "close"}, []]}}
 
 			it "removes content-length header" do
 				expect(response.headers).not.to be(:include?, "connection")
@@ -45,7 +45,7 @@
 
 		with "body that responds to #to_path" do
 			let(:fake_file) {Array.new}
-			let(:app) {->(env) {[200, {}, fake_file]}}
+			let(:app) {->(env){[200, {}, fake_file]}}
 
 			it "should generate file body" do
 				expect(fake_file).to receive(:to_path).and_return("/dev/null")
@@ -54,7 +54,7 @@
 			end
 
 			with "206 partial response status" do
-				let(:app) {->(env) {[200, {}, fake_file]}}
+				let(:app) {->(env){[200, {}, fake_file]}}
 
 				it "should not modify partial responses" do
 					expect(response.body).to be(:kind_of?, Protocol::Rack::Body::Enumerable)
@@ -64,7 +64,7 @@
 
 		with "a request that has response finished callbacks" do
 			let(:callback) {->(env, status, headers, error){}}
-			let(:app) {->(env) {env["rack.response_finished"] << callback; [200, {}, ["Hello World!"]]}}
+			let(:app) {->(env){env["rack.response_finished"] << callback; [200, {}, ["Hello World!"]]}}
 
 			it "should call the callbacks" do
 				expect(callback).to receive(:call)