Changes as requested.

ioquatix · ioquatix · commit b16055b41ff4 · 2025-07-29T19:23:43.000+12:00
diff --git a/SPEC.rdoc b/SPEC.rdoc
@@ -34,7 +34,7 @@ The remainder of the request URL's "path", designating the virtual "location" of
 
 The <tt>PATH_INFO</tt>, if provided, must be a valid request target or an empty string, as defined by {RFC9110}[https://datatracker.ietf.org/doc/html/rfc9110#target.resource].
 * Only <tt>OPTIONS</tt> requests may have <tt>PATH_INFO</tt> set to <tt>*</tt> (asterisk-form).
-* Only <tt>CONNECT</tt> requests may have <tt>PATH_INFO</tt> set to an authority (authority-form). Note that in <tt>HTTP/2+</tt>, the authority-form is not a valid request target.
+* Only <tt>CONNECT</tt> requests may have <tt>PATH_INFO</tt> set to an authority (authority-form). Note that in HTTP/2+, the authority-form is not a valid request target.
 * <tt>CONNECT</tt> and <tt>OPTIONS</tt> requests must not have <tt>PATH_INFO</tt> set to a URI (absolute-form).
 * Otherwise, <tt>PATH_INFO</tt> must start with a <tt>/</tt> and must not include a fragment part starting with <tt>#</tt> (origin-form).
 
@@ -88,7 +88,7 @@ The URL scheme, which must be one of <tt>http</tt>, <tt>https</tt>, <tt>ws</tt>
 
 ==== <tt>rack.protocol</tt>
 
-An optional +Array+ of +String+ values, containing the protocols advertised by the client in the <tt>upgrade</tt> header (<tt>HTTP/1</tt>) or the <tt>:protocol</tt> pseudo-header (<tt>HTTP/2+</tt>).
+An optional +Array+ of +String+ values, containing the protocols advertised by the client in the <tt>upgrade</tt> header (HTTP/1) or the <tt>:protocol</tt> pseudo-header (HTTP/2+).
 
 ==== <tt>rack.session</tt>
 
@@ -167,13 +167,13 @@ The error stream must respond to +puts+, +write+ and +flush+:
 
 The hijacking interfaces provides a means for an application to take control of the HTTP connection. There are two distinct hijack interfaces: full hijacking where the application takes over the raw connection, and partial hijacking where the application takes over just the response body stream. In both cases, the application is responsible for closing the hijacked stream.
 
-Full hijacking only works with <tt>HTTP/1</tt>. Partial hijacking is functionally equivalent to streaming bodies, and is still optionally supported for backwards compatibility with older Rack versions.
+Full hijacking only works with HTTP/1. Partial hijacking is functionally equivalent to streaming bodies, and is still optionally supported for backwards compatibility with older Rack versions.
 
 ==== Full Hijack
 
-Full hijack is used to completely take over an <tt>HTTP/1</tt> connection. It occurs before any headers are written and causes the server to ignore any response generated by the application. It is intended to be used when applications need access to the raw <tt>HTTP/1</tt> connection.
+Full hijack is used to completely take over an HTTP/1 connection. It occurs before any headers are written and causes the server to ignore any response generated by the application. It is intended to be used when applications need access to the raw HTTP/1 connection.
 
-If <tt>rack.hijack</tt> is present in +env+, it must respond to +call+ and return an +IO+ object which can be used to read and write to the underlying connection using <tt>HTTP/1</tt> semantics and formatting.
+If <tt>rack.hijack</tt> is present in +env+, it must respond to +call+ and return an +IO+ object which can be used to read and write to the underlying connection using HTTP/1 semantics and formatting.
 
 ==== Partial Hijack
 
@@ -205,9 +205,9 @@ This is an HTTP status. It must be an Integer greater than or equal to 100.
 The headers must be an unfrozen +Hash+. The header keys must be +String+ values. Special headers starting <tt>rack.</tt> are for communicating with the server, and must not be sent back to the client.
 
 * The headers must not contain a <tt>"status"</tt> key.
-* Header keys must conform to {RFC7230}[https://tools.ietf.org/html/rfc7230] token specification, i.e. cannot contain non-printable <tt>ASCII</tt>, <tt>DQUOTE</tt> or <tt>(),/:;<=>?@[\]{}</tt>.
-* Header keys must not contain uppercase <tt>ASCII</tt> characters (A-Z).
-* Header values must be either a +String+, or an +Array+ of +String+ values, such that each +String+ must not contain characters with an <tt>ASCII</tt> ordinal below <tt>040</tt> (32).
+* Header keys must conform to {RFC7230}[https://tools.ietf.org/html/rfc7230] token specification, i.e. cannot contain non-printable ASCII, <tt>DQUOTE</tt> or <tt>(),/:;<=>?@[\]{}</tt>.
+* Header keys must not contain uppercase ASCII characters (A-Z).
+* Header values must be either a +String+, or an +Array+ of +String+ values, such that each +String+ must not contain characters with an ASCII ordinal below 040 (32).
 
 ==== The <tt>content-type</tt> Header
 
@@ -221,7 +221,7 @@ There must not be a <tt>content-length</tt> header key when the status is <tt>1x
 
 If the <tt>rack.protocol</tt> header is present, it must be a +String+, and must be one of the values from the <tt>rack.protocol</tt> array from the environment.
 
-Setting this value informs the server that it should perform a connection upgrade. In <tt>HTTP/1</tt>, this is done using the +upgrade+ header. In <tt>HTTP/2</tt>, this is done by accepting the request.
+Setting this value informs the server that it should perform a connection upgrade. In HTTP/1, this is done using the +upgrade+ header. In HTTP/2+, this is done by accepting the request.
 
 === The Body
 
@@ -239,17 +239,17 @@ If the Body responds to +to_path+, it must return either +nil+ or a +String+. If
 
 ==== Enumerable Body
 
-The Enumerable Body must respond to +each+, which must not be called more than once, and must not be called after being closed. The +each+ method must only yield +String+ values.
+The Enumerable Body must respond to +each+, which must only be called once, must not be called after being closed, and must only yield +String+ values.
 
 Middleware must not call +each+ directly on the Body. Instead, middleware can return a new Body that calls +each+ on the original Body, yielding at least once per iteration.
 
 If the Body responds to +to_ary+, it must return an +Array+ whose contents are identical to that produced by calling +each+. Middleware may call +to_ary+ directly on the Body and return a new Body in its place. In other words, middleware can only process the Body directly if it responds to +to_ary+. If the Body responds to both +to_ary+ and +close+, its implementation of +to_ary+ must call +close+.
 
 ==== Streaming Body
 
-The Streaming Body must respond to +call+, which must not be called more than once, and must not be called after being closed. The +call+ method must accept a +stream+ argument.
+The Streaming Body must respond to +call+, which must only be called once, must not be called after being closed, and accept a +stream+ argument.
 
-The +stream+ argument must respond to: +read+, +write+, <tt><<</tt>, +flush+, +close+, +close_read+, +close_write+, and +closed?+. The semantics of these +IO+ methods must be a best effort match to those of a normal Ruby +IO+ or +Socket+ object, using standard arguments and raising standard exceptions. Servers may simply pass on real +IO+ objects to the Streaming Body. In some cases (e.g. when using <tt>transfer-encoding</tt> or <tt>HTTP/2+</tt>), the server may need to provide a wrapper that implements the required methods, in order to provide the correct semantics.
+The +stream+ argument must respond to: +read+, +write+, <tt><<</tt>, +flush+, +close+, +close_read+, +close_write+, and +closed?+. The semantics of these +IO+ methods must be a best effort match to those of a normal Ruby +IO+ or +Socket+ object, using standard arguments and raising standard exceptions. Servers may simply pass on real +IO+ objects to the Streaming Body. In some cases (e.g. when using <tt>transfer-encoding</tt> or HTTP/2+), the server may need to provide a wrapper that implements the required methods, in order to provide the correct semantics.
 
 == Thanks
 
diff --git a/lib/rack/lint.rb b/lib/rack/lint.rb
@@ -213,7 +213,7 @@ def check_environment(env)
               raise LintError, "Only OPTIONS requests may have PATH_INFO set to '*' (asterisk-form)"
             end
           when REQUEST_PATH_AUTHORITY_FORM
-            ## * Only <tt>CONNECT</tt> requests may have <tt>PATH_INFO</tt> set to an authority (authority-form). Note that in <tt>HTTP/2+</tt>, the authority-form is not a valid request target.
+            ## * Only <tt>CONNECT</tt> requests may have <tt>PATH_INFO</tt> set to an authority (authority-form). Note that in HTTP/2+, the authority-form is not a valid request target.
             unless env[REQUEST_METHOD] == CONNECT
               raise LintError, "Only CONNECT requests may have PATH_INFO set to an authority (authority-form)"
             end
@@ -325,7 +325,7 @@ def check_environment(env)
         ##
         ## ==== <tt>rack.protocol</tt>
         ##
-        ## An optional +Array+ of +String+ values, containing the protocols advertised by the client in the <tt>upgrade</tt> header (<tt>HTTP/1</tt>) or the <tt>:protocol</tt> pseudo-header (<tt>HTTP/2+</tt>).
+        ## An optional +Array+ of +String+ values, containing the protocols advertised by the client in the <tt>upgrade</tt> header (HTTP/1) or the <tt>:protocol</tt> pseudo-header (HTTP/2+).
         if protocols = env[RACK_PROTOCOL]
           unless protocols.is_a?(Array) && protocols.all?{|protocol| protocol.is_a?(String)}
             raise LintError, "rack.protocol must be an Array of Strings"
@@ -610,11 +610,11 @@ def close(*args)
       ##
       ## The hijacking interfaces provides a means for an application to take control of the HTTP connection. There are two distinct hijack interfaces: full hijacking where the application takes over the raw connection, and partial hijacking where the application takes over just the response body stream. In both cases, the application is responsible for closing the hijacked stream.
       ##
-      ## Full hijacking only works with <tt>HTTP/1</tt>. Partial hijacking is functionally equivalent to streaming bodies, and is still optionally supported for backwards compatibility with older Rack versions.
+      ## Full hijacking only works with HTTP/1. Partial hijacking is functionally equivalent to streaming bodies, and is still optionally supported for backwards compatibility with older Rack versions.
       ##
       ## ==== Full Hijack
       ##
-      ## Full hijack is used to completely take over an <tt>HTTP/1</tt> connection. It occurs before any headers are written and causes the server to ignore any response generated by the application. It is intended to be used when applications need access to the raw <tt>HTTP/1</tt> connection.
+      ## Full hijack is used to completely take over an HTTP/1 connection. It occurs before any headers are written and causes the server to ignore any response generated by the application. It is intended to be used when applications need access to the raw HTTP/1 connection.
       ##
       def check_hijack(env)
         ## If <tt>rack.hijack</tt> is present in +env+, it must respond to +call+ \
@@ -624,7 +624,7 @@ def check_hijack(env)
           env[RACK_HIJACK] = proc do
             io = original_hijack.call
 
-            ## and return an +IO+ object which can be used to read and write to the underlying connection using <tt>HTTP/1</tt> semantics and formatting.
+            ## and return an +IO+ object which can be used to read and write to the underlying connection using HTTP/1 semantics and formatting.
             raise LintError, "rack.hijack must return an IO instance" unless io.is_a?(IO)
 
             io
@@ -724,9 +724,9 @@ def check_headers(headers)
           ##
           ## * The headers must not contain a <tt>"status"</tt> key.
           raise LintError, "headers must not contain status" if key == "status"
-          ## * Header keys must conform to {RFC7230}[https://tools.ietf.org/html/rfc7230] token specification, i.e. cannot contain non-printable <tt>ASCII</tt>, <tt>DQUOTE</tt> or <tt>(),/:;<=>?@[\]{}</tt>.
+          ## * Header keys must conform to {RFC7230}[https://tools.ietf.org/html/rfc7230] token specification, i.e. cannot contain non-printable ASCII, <tt>DQUOTE</tt> or <tt>(),/:;<=>?@[\]{}</tt>.
           raise LintError, "invalid header name: #{key}" if key =~ /[\(\),\/:;<=>\?@\[\\\]{}[:cntrl:]]/
-          ## * Header keys must not contain uppercase <tt>ASCII</tt> characters (A-Z).
+          ## * Header keys must not contain uppercase ASCII characters (A-Z).
           raise LintError, "uppercase character in header name: #{key}" if key =~ /[A-Z]/
 
           ## * Header values must be either a +String+, \
@@ -742,7 +742,7 @@ def check_headers(headers)
       end
 
       def check_header_value(key, value)
-        ## such that each +String+ must not contain characters with an <tt>ASCII</tt> ordinal below <tt>040</tt> (32).
+        ## such that each +String+ must not contain characters with an ASCII ordinal below 040 (32).
         if value =~ /[\000-\037]/
           raise LintError, "invalid header value #{key}: #{value.inspect}"
         end
@@ -808,7 +808,7 @@ def check_rack_protocol_header(status, headers)
         end
       end
       ##
-      ## Setting this value informs the server that it should perform a connection upgrade. In <tt>HTTP/1</tt>, this is done using the +upgrade+ header. In <tt>HTTP/2</tt>, this is done by accepting the request.
+      ## Setting this value informs the server that it should perform a connection upgrade. In HTTP/1, this is done using the +upgrade+ header. In HTTP/2+, this is done by accepting the request.
       ##
       ## === The Body
       ##
@@ -851,13 +851,13 @@ def verify_to_path
       ## ==== Enumerable Body
       ##
       def each
-        ## The Enumerable Body must respond to +each+. \
+        ## The Enumerable Body must respond to +each+, \
         raise LintError, "Enumerable Body must respond to each" unless @body.respond_to?(:each)
 
-        ## It must only be consumed once (calling this method consumes the body). \
+        ## which must only be called once, \
         raise LintError, "Response body must only be consumed once (#{@consumed})" unless @consumed.nil?
 
-        ## It must not be called after being closed, \
+        ## must not be called after being closed, \
         raise LintError, "Response body is already closed" if @closed
 
         @consumed = :each
@@ -917,18 +917,18 @@ def to_ary
       ## ==== Streaming Body
       ##
       def call(stream)
-        ## The Streaming Body must respond to +call+. \
+        ## The Streaming Body must respond to +call+, \
         raise LintError, "Streaming Body must respond to call" unless @body.respond_to?(:call)
 
-        ## It must only be consumed once (calling this method consumes the body). \
+        ## which must only be called once, \
         raise LintError, "Response body must only be consumed once (#{@consumed})" unless @consumed.nil?
 
-        ## It must not be called after being closed. \
+        ## must not be called after being closed, \
         raise LintError, "Response body is already closed" if @closed
 
         @consumed = :call
 
-        ## It takes a +stream+ argument.
+        ## and accept a +stream+ argument.
         ##
         ## The +stream+ argument must respond to: +read+, +write+, <tt><<</tt>, +flush+, +close+, +close_read+, +close_write+, and +closed?+. \
         @body.call(StreamWrapper.new(stream))
@@ -937,7 +937,7 @@ def call(stream)
       class StreamWrapper
         extend Forwardable
 
-        ## The semantics of these +IO+ methods must be a best effort match to those of a normal Ruby +IO+ or +Socket+ object, using standard arguments and raising standard exceptions. Servers may simply pass on real +IO+ objects to the Streaming Body. In some cases (e.g. when using <tt>transfer-encoding</tt> or <tt>HTTP/2+</tt>), the server may need to provide a wrapper that implements the required methods, in order to provide the correct semantics.
+        ## The semantics of these +IO+ methods must be a best effort match to those of a normal Ruby +IO+ or +Socket+ object, using standard arguments and raising standard exceptions. Servers may simply pass on real +IO+ objects to the Streaming Body. In some cases (e.g. when using <tt>transfer-encoding</tt> or HTTP/2+), the server may need to provide a wrapper that implements the required methods, in order to provide the correct semantics.
         REQUIRED_METHODS = [
           :read, :write, :<<, :flush, :close,
           :close_read, :close_write, :closed?
