Re-implement priority header according to RFC9218.

Author: ioquatix

lib/protocol/http/header/priority.rb

@@ -10,54 +10,44 @@ module HTTP
 		module Header
 			# Represents the `priority` header, used to indicate the relative importance of an HTTP request.
 			#
-			# The `priority` header allows clients to express their preference for how resources should be prioritized by the server. It can include directives like `urgency` to specify the importance of a request, and `progressive` to indicate whether a response can be delivered incrementally.
+			# The `priority` header allows clients to express their preference for how resources should be prioritized by the server. It supports directives like `u=` to specify the urgency level of a request, and `i` to indicate whether a response can be delivered incrementally. The urgency levels range from 0 (highest priority) to 7 (lowest priority), while the `i` directive is a boolean flag.
 			class Priority < Split
-				# Urgency levels as defined in RFC 9218:
-				#
-				# These levels indicate the relative importance of a request, helping servers and intermediaries allocate resources efficiently. Properly setting urgency can significantly improve user-perceived performance by prioritizing critical content and deferring less important tasks.
-				module Urgency
-					# `background` priority indicates a request that is not time-sensitive and can be processed with minimal impact to other tasks. It is ideal for requests like analytics or logging, which do not directly impact the user's current experience.
-					BACKGROUND = "background"
-					
-					# `low` priority indicates a request that is important but not critical. It is suitable for content like non-blocking images, videos, or scripts that enhance the experience but do not affect core functionality.
-					LOW = "low"
-					
-					# `normal` priority (default) indicates the standard priority for most requests. It is appropriate for content like text, CSS, or essential images that are necessary for the primary user experience but do not require urgent delivery.
-					NORMAL = "normal"
-					
-					# `high` priority indicates the highest priority, used for requests that are essential and time-critical to the user experience. Examples include content above-the-fold on a webpage, critical API calls, or resources required for rendering.
-					HIGH = "high"
-				end
-				
-				# The `progressive` flag indicates that the response can be delivered incrementally (progressively) as data becomes available. This is particularly useful for large resources like images or video streams, where partial delivery improves the user experience by allowing content to render or play before the full response is received.
-				PROGRESSIVE = "progressive"
-				
 				# Initialize the priority header with the given value.
 				#
-				# @parameter value [String | Nil] the value of the priority header, if any.
+				# @parameter value [String | Nil] the value of the priority header, if any. The value should be a comma-separated string of directives.
 				def initialize(value = nil)
 					super(value&.downcase)
 				end
 
 				# Add a value to the priority header.
+				#
+				# @parameter value [String] the directive to add to the header.
 				def << value
 					super(value.downcase)
 				end
 
-				# Returns the urgency level if specified.
+				# The default urgency level if not specified.
+				DEFAULT_URGENCY = 3
+				
+				# Returns the urgency level if specified. 0 is the highest priority, and 7 is the lowest.
 				#
-				# @returns [String | Nil] the urgency level if specified, or `nil`.
-				def urgency
-					if value = self.find{|value| value.start_with?("urgency=")}
+				# @returns [Integer | Nil] the urgency level if specified, or `nil` if not present.
+				def urgency(default = DEFAULT_URGENCY)
+					if value = self.find { |value| value.start_with?("u=") }
 						_, level = value.split("=", 2)
-						
-						return level
+						return level.to_i
 					end
+					
+					return default
 				end
 
-				# @returns [Boolean] whether the request should be delivered progressively.
-				def progressive?
-					self.include?(PROGRESSIVE)
+				# Checks if the response should be delivered incrementally.
+				#
+				# The `i` directive, when present, indicates that the response can be delivered incrementally as data becomes available.
+				#
+				# @returns [Boolean] whether the request should be delivered incrementally.
+				def incremental?
+					self.include?("i")
 				end
 			end
 		end

test/protocol/http/header/priority.rb

@@ -6,75 +6,77 @@
 require "protocol/http/header/priority"
 
 describe Protocol::HTTP::Header::Priority do
-	let(:header) {subject.new(description)}
+	let(:header) { subject.new(description) }
 
-	with "urgency=low, progressive" do
+	with "u=1, i" do
 		it "correctly parses priority header" do
 			expect(header).to have_attributes(
-				urgency: be == "low",
-				progressive?: be == true,
+				urgency: be == 1,
+				incremental?: be == true,
 			)
 		end
 	end
 
-	with "urgency=high" do
+	with "u=0" do
 		it "correctly parses priority header" do
 			expect(header).to have_attributes(
-				urgency: be == "high",
-				progressive?: be == false,
+				urgency: be == 0,
+				incremental?: be == false,
 			)
 		end
 	end
 
-	with "progressive" do
-		it "correctly parses progressive flag" do
+	with "i" do
+		it "correctly parses incremental flag" do
 			expect(header).to have_attributes(
-				urgency: be_nil,
-				progressive?: be == true,
+				# Default urgency level is used:
+				urgency: be == 3,
+				incremental?: be == true,
 			)
 		end
 	end
 
-	with "urgency=background" do
-		it "correctly parses urgency" do
+	with "u=6" do
+		it "correctly parses urgency level" do
 			expect(header).to have_attributes(
-				urgency: be == "background",
+				urgency: be == 6,
 			)
 		end
 	end
 
-	with "urgency=extreeeeem, progressive" do
-		it "gracefully handles non-standard urgency" do
+	with "u=9, i" do
+		it "gracefully handles non-standard urgency levels" do
 			expect(header).to have_attributes(
 				# Non-standard value is preserved
-				urgency: be == "extreeeeem",
-				progressive?: be == true,
+				urgency: be == 9,
+				incremental?: be == true,
 			)
 		end
 	end
 
-	with "urgency=low, urgency=high" do
+	with "u=2, u=5" do
 		it "prioritizes the first urgency directive" do
 			expect(header).to have_attributes(
-				urgency: be == "low", # First occurrence takes precedence
+				# First occurrence takes precedence
+				urgency: be == 2,
 			)
 		end
 	end
 
 	with "#<<" do
-		let(:header) {subject.new}
+		let(:header) { subject.new }
 
 		it "can append values" do
-			header << "urgency=low"
+			header << "u=4"
 			expect(header).to have_attributes(
-				urgency: be == "low",
+				urgency: be == 4,
 			)
 		end
 
-		it "can append progressive flag" do
-			header << "progressive"
+		it "can append incremental flag" do
+			header << "i"
 			expect(header).to have_attributes(
-				progressive?: be == true,
+				incremental?: be == true,
 			)
 		end
 	end