Completely eradicate the use of invoked. Fixes rack#2305.

Author: samuel-williams-shopify

SPEC.rdoc

@@ -140,7 +140,7 @@ The error stream. See the section below on the error stream for more information
 
 ==== <tt>rack.response_finished</tt>
 
-If present, an array of callables that will be run by the server after the response has been processed. The callables are called with <tt>environment, status, headers, error</tt> arguments and should not raise any exceptions. The callables would typically be called after sending the response to the client, but it could also be called if an error occurs while generating the response or sending the response (in that case, the +error+ argument will be a kind of +Exception+). The callables will be invoked in reverse order.
+If present, an array of callables that will be run by the server after the response has been processed. The callables are called with <tt>environment, status, headers, error</tt> arguments and should not raise any exceptions. The callables would typically be called after sending the response to the client, but it could also be called if an error occurs while generating the response or sending the response (in that case, the +error+ argument will be a kind of +Exception+). The callables will be called in reverse order.
 
 === The Input Stream
 
@@ -181,7 +181,7 @@ Partial hijack is used for bi-directional streaming of the request and response
 
 If <tt>rack.hijack?</tt> is present in +env+ and truthy, an application may set the special response header <tt>rack.hijack</tt> to an object that responds to +call+, accepting a +stream+ argument.
 
-After the response status and headers have been sent, this hijack callback will be invoked with a +stream+ argument which follows the same interface as outlined in "Streaming Body". Servers must ignore the +body+ part of the response tuple when the <tt>rack.hijack</tt> response header is present. Using an empty +Array+ is recommended.
+After the response status and headers have been sent, this hijack callback will be called with a +stream+ argument which follows the same interface as outlined in "Streaming Body". Servers must ignore the +body+ part of the response tuple when the <tt>rack.hijack</tt> response header is present. Using an empty +Array+ is recommended.
 
 The special response header <tt>rack.hijack</tt> must only be set if the request +env+ has a truthy <tt>rack.hijack?</tt>.
 
@@ -239,15 +239,15 @@ 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+. It must only be called once. It must not be called after being closed, and must only yield +String+ values.
+The Enumerable Body must respond to +each+. It must only be consumed once (calling this method consumes the body). It 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+. It must only be called once. It must not be called after being closed. It takes a +stream+ argument.
+The Streaming Body must respond to +call+. It must only be consumed once (calling this method consumes the body). It must not be called after being closed. It takes 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.
 

lib/rack/lint.rb

@@ -82,7 +82,7 @@ def initialize(app, env)
         @status = nil
         @headers = nil
         @body = nil
-        @invoked = nil
+        @consumed = nil
         @content_length = nil
         @closed = false
         @size = 0
@@ -467,7 +467,7 @@ def check_environment(env)
         ##
         ## ==== <tt>rack.response_finished</tt>
         ##
-        ## If present, an array of callables that will be run by the server after the response has been processed. The callables are called with <tt>environment, status, headers, error</tt> arguments and should not raise any exceptions. The callables would typically be called after sending the response to the client, but it could also be called if an error occurs while generating the response or sending the response (in that case, the +error+ argument will be a kind of +Exception+). The callables will be invoked in reverse order.
+        ## If present, an array of callables that will be run by the server after the response has been processed. The callables are called with <tt>environment, status, headers, error</tt> arguments and should not raise any exceptions. The callables would typically be called after sending the response to the client, but it could also be called if an error occurs while generating the response or sending the response (in that case, the +error+ argument will be a kind of +Exception+). The callables will be called in reverse order.
         if rack_response_finished = env[RACK_RESPONSE_FINISHED]
           raise LintError, "rack.response_finished must be an array of callable objects" unless rack_response_finished.is_a?(Array)
           rack_response_finished.each do |callable|
@@ -656,7 +656,7 @@ def check_hijack_response(headers, env)
             end
           end
           ##
-          ## After the response status and headers have been sent, this hijack callback will be invoked with a +stream+ argument which follows the same interface as outlined in "Streaming Body". Servers must ignore the +body+ part of the response tuple when the <tt>rack.hijack</tt> response header is present. Using an empty +Array+ is recommended.
+          ## After the response status and headers have been sent, this hijack callback will be called with a +stream+ argument which follows the same interface as outlined in "Streaming Body". Servers must ignore the +body+ part of the response tuple when the <tt>rack.hijack</tt> response header is present. Using an empty +Array+ is recommended.
         else
           ##
           ## The special response header <tt>rack.hijack</tt> must only be set if the request +env+ has a truthy <tt>rack.hijack?</tt>.
@@ -858,13 +858,13 @@ def 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 called once. \
-        raise LintError, "Response body must only be invoked once (#{@invoked})" unless @invoked.nil?
+        ## It must only be consumed once (calling this method consumes the body). \
+        raise LintError, "Response body must only be consumed once (#{@consumed})" unless @consumed.nil?
 
         ## It must not be called after being closed, \
         raise LintError, "Response body is already closed" if @closed
 
-        @invoked = :each
+        @consumed = :each
 
         @body.each do |chunk|
           ## and must only yield +String+ values.
@@ -924,13 +924,13 @@ def call(stream)
         ## The Streaming Body must respond to +call+. \
         raise LintError, "Streaming Body must respond to call" unless @body.respond_to?(:call)
 
-        ## It must only be called once. \
-        raise LintError, "Response body must only be invoked once (#{@invoked})" unless @invoked.nil?
+        ## It must only be consumed once (calling this method consumes the body). \
+        raise LintError, "Response body must only be consumed once (#{@consumed})" unless @consumed.nil?
 
         ## It must not be called after being closed. \
         raise LintError, "Response body is already closed" if @closed
 
-        @invoked = :call
+        @consumed = :call
 
         ## It takes a +stream+ argument.
         ##

test/spec_lint.rb

@@ -662,7 +662,7 @@ def body.to_path; nil end
       body.each { |part| }
       body.each { |part| }
     }.must_raise(Rack::Lint::LintError).
-      message.must_equal 'Response body must only be invoked once (each)'
+      message.must_equal 'Response body must only be consumed once (each)'
 
     lambda {
       body = Rack::Lint.new(lambda { |env|
@@ -796,7 +796,7 @@ def to_path.to_path; false end
       body.call(StringIO.new)
       body.call(nil)
     }.must_raise(Rack::Lint::LintError).
-      message.must_equal 'Response body must only be invoked once (call)'
+      message.must_equal 'Response body must only be consumed once (call)'
 
     lambda {
       body = Rack::Lint.new(lambda { |env|