Class: Rack::Lint::Wrapper

Inherits:
Object
  • Object
show all
Defined in:
lib/rack/lint.rb

Defined Under Namespace

Classes: ErrorWrapper, InputWrapper, StreamWrapper

Constant Summary collapse

BODY_METHODS =
{to_ary: true, each: true, call: true, to_path: true}

Instance Method Summary collapse

Constructor Details

#initialize(app, env) ⇒ Wrapper

Returns a new instance of Wrapper.


39
40
41
42
43
44
45
46
47
48
49
50
51
52
# File 'lib/rack/lint.rb', line 39

def initialize(app, env)
  @app = app
  @env = env
  @response = nil
  @head_request = false

  @status = nil
  @headers = nil
  @body = nil
  @invoked = nil
  @content_length = nil
  @closed = false
  @size = 0
end

Instance Method Details

#call(stream) ⇒ Object

Streaming Body

Raises:


855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
# File 'lib/rack/lint.rb', line 855

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 not be called after being closed.
  raise LintError, "Response body is already closed" if @closed

  @invoked = :call

  ## It takes a +stream+ argument.
  ##
  ## The +stream+ argument must implement:
  ## <tt>read, write, <<, flush, close, close_read, close_write, closed?</tt>
  ##
  @body.call(StreamWrapper.new(stream))
end

#check_content_length(status, headers) ⇒ Object

The content-length


693
694
695
696
697
698
699
700
701
702
703
704
# File 'lib/rack/lint.rb', line 693

def check_content_length(status, headers)
  headers.each { |key, value|
    if key == 'content-length'
      ## There must not be a <tt>content-length</tt> header key when the
      ## +Status+ is 1xx, 204, or 304.
      if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.key? status.to_i
        raise LintError, "content-length header found in #{status} response, not allowed"
      end
      @content_length = value
    end
  }
end

#check_content_type(status, headers) ⇒ Object

The content-type


677
678
679
680
681
682
683
684
685
686
687
688
# File 'lib/rack/lint.rb', line 677

def check_content_type(status, headers)
  headers.each { |key, value|
    ## There must not be a <tt>content-type</tt> header key when the +Status+ is 1xx,
    ## 204, or 304.
    if key == "content-type"
      if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.key? status.to_i
        raise LintError, "content-type header found in #{status} response, not allowed"
      end
      return
    end
  }
end

#check_environment(env) ⇒ Object

The Environment

Raises:


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
# File 'lib/rack/lint.rb', line 97

def check_environment(env)
  ## The environment must be an unfrozen instance of Hash that includes
  ## CGI-like headers. The Rack application is free to modify the
  ## environment.
  raise LintError, "env #{env.inspect} is not a Hash, but #{env.class}" unless env.kind_of? Hash
  raise LintError, "env should not be frozen, but is" if env.frozen?

  ##
  ## The environment is required to include these variables
  ## (adopted from {PEP 333}[https://peps.python.org/pep-0333/]), except when they'd be empty, but see
  ## below.

  ## <tt>REQUEST_METHOD</tt>:: The HTTP request method, such as
  ##                           "GET" or "POST". This cannot ever
  ##                           be an empty string, and so is
  ##                           always required.

  ## <tt>SCRIPT_NAME</tt>:: The initial portion of the request
  ##                        URL's "path" that corresponds to the
  ##                        application object, so that the
  ##                        application knows its virtual
  ##                        "location". This may be an empty
  ##                        string, if the application corresponds
  ##                        to the "root" of the server.

  ## <tt>PATH_INFO</tt>:: The remainder of the request URL's
  ##                      "path", designating the virtual
  ##                      "location" of the request's target
  ##                      within the application. This may be an
  ##                      empty string, if the request URL targets
  ##                      the application root and does not have a
  ##                      trailing slash. This value may be
  ##                      percent-encoded when originating from
  ##                      a URL.

  ## <tt>QUERY_STRING</tt>:: The portion of the request URL that
  ##                         follows the <tt>?</tt>, if any. May be
  ##                         empty, but is always required!

  ## <tt>SERVER_NAME</tt>:: When combined with <tt>SCRIPT_NAME</tt> and
  ##                        <tt>PATH_INFO</tt>, these variables can be
  ##                        used to complete the URL. Note, however,
  ##                        that <tt>HTTP_HOST</tt>, if present,
  ##                        should be used in preference to
  ##                        <tt>SERVER_NAME</tt> for reconstructing
  ##                        the request URL.
  ##                        <tt>SERVER_NAME</tt> can never be an empty
  ##                        string, and so is always required.

  ## <tt>SERVER_PORT</tt>:: An optional +Integer+ which is the port the
  ##                        server is running on. Should be specified if
  ##                        the server is running on a non-standard port.

  ## <tt>SERVER_PROTOCOL</tt>:: A string representing the HTTP version used
  ##                            for the request.

  ## <tt>HTTP_</tt> Variables:: Variables corresponding to the
  ##                            client-supplied HTTP request
  ##                            headers (i.e., variables whose
  ##                            names begin with <tt>HTTP_</tt>). The
  ##                            presence or absence of these
  ##                            variables should correspond with
  ##                            the presence or absence of the
  ##                            appropriate HTTP header in the
  ##                            request. See
  ##                            {RFC3875 section 4.1.18}[https://tools.ietf.org/html/rfc3875#section-4.1.18]
  ##                            for specific behavior.

  ## In addition to this, the Rack environment must include these
  ## Rack-specific variables:

  ## <tt>rack.url_scheme</tt>:: +http+ or +https+, depending on the
  ##                            request URL.

  ## <tt>rack.input</tt>:: See below, the input stream.

  ## <tt>rack.errors</tt>:: See below, the error stream.

  ## <tt>rack.hijack?</tt>:: See below, if present and true, indicates
  ##                         that the server supports partial hijacking.

  ## <tt>rack.hijack</tt>:: See below, if present, an object responding
  ##                        to +call+ that is used to perform a full
  ##                        hijack.

  ## Additional environment specifications have approved to
  ## standardized middleware APIs. None of these are required to
  ## be implemented by the server.

  ## <tt>rack.session</tt>:: A hash-like interface for storing
  ##                         request session data.
  ##                         The store must implement:
  if session = env[RACK_SESSION]
    ##                         store(key, value)         (aliased as []=);
    unless session.respond_to?(:store) && session.respond_to?(:[]=)
      raise LintError, "session #{session.inspect} must respond to store and []="
    end

    ##                         fetch(key, default = nil) (aliased as []);
    unless session.respond_to?(:fetch) && session.respond_to?(:[])
      raise LintError, "session #{session.inspect} must respond to fetch and []"
    end

    ##                         delete(key);
    unless session.respond_to?(:delete)
      raise LintError, "session #{session.inspect} must respond to delete"
    end

    ##                         clear;
    unless session.respond_to?(:clear)
      raise LintError, "session #{session.inspect} must respond to clear"
    end

    ##                         to_hash (returning unfrozen Hash instance);
    unless session.respond_to?(:to_hash) && session.to_hash.kind_of?(Hash) && !session.to_hash.frozen?
      raise LintError, "session #{session.inspect} must respond to to_hash and return unfrozen Hash instance"
    end
  end

  ## <tt>rack.logger</tt>:: A common object interface for logging messages.
  ##                        The object must implement:
  if logger = env[RACK_LOGGER]
    ##                         info(message, &block)
    unless logger.respond_to?(:info)
      raise LintError, "logger #{logger.inspect} must respond to info"
    end

    ##                         debug(message, &block)
    unless logger.respond_to?(:debug)
      raise LintError, "logger #{logger.inspect} must respond to debug"
    end

    ##                         warn(message, &block)
    unless logger.respond_to?(:warn)
      raise LintError, "logger #{logger.inspect} must respond to warn"
    end

    ##                         error(message, &block)
    unless logger.respond_to?(:error)
      raise LintError, "logger #{logger.inspect} must respond to error"
    end

    ##                         fatal(message, &block)
    unless logger.respond_to?(:fatal)
      raise LintError, "logger #{logger.inspect} must respond to fatal"
    end
  end

  ## <tt>rack.multipart.buffer_size</tt>:: An Integer hint to the multipart parser as to what chunk size to use for reads and writes.
  if bufsize = env[RACK_MULTIPART_BUFFER_SIZE]
    unless bufsize.is_a?(Integer) && bufsize > 0
      raise LintError, "rack.multipart.buffer_size must be an Integer > 0 if specified"
    end
  end

  ## <tt>rack.multipart.tempfile_factory</tt>:: An object responding to #call with two arguments, the filename and content_type given for the multipart form field, and returning an IO-like object that responds to #<< and optionally #rewind. This factory will be used to instantiate the tempfile for each multipart form file upload field, rather than the default class of Tempfile.
  if tempfile_factory = env[RACK_MULTIPART_TEMPFILE_FACTORY]
    raise LintError, "rack.multipart.tempfile_factory must respond to #call" unless tempfile_factory.respond_to?(:call)
    env[RACK_MULTIPART_TEMPFILE_FACTORY] = lambda do |filename, content_type|
      io = tempfile_factory.call(filename, content_type)
      raise LintError, "rack.multipart.tempfile_factory return value must respond to #<<" unless io.respond_to?(:<<)
      io
    end
  end

  ## The server or the application can store their own data in the
  ## environment, too.  The keys must contain at least one dot,
  ## and should be prefixed uniquely.  The prefix <tt>rack.</tt>
  ## is reserved for use with the Rack core distribution and other
  ## accepted specifications and must not be used otherwise.
  ##

  %w[REQUEST_METHOD SERVER_NAME QUERY_STRING SERVER_PROTOCOL
     rack.input rack.errors].each { |header|
    raise LintError, "env missing required key #{header}" unless env.include? header
  }

  ## The <tt>SERVER_PORT</tt> must be an Integer if set.
  server_port = env["SERVER_PORT"]
  unless server_port.nil? || (Integer(server_port) rescue false)
    raise LintError, "env[SERVER_PORT] is not an Integer"
  end

  ## The <tt>SERVER_NAME</tt> must be a valid authority as defined by RFC7540.
  unless (URI.parse("http://#{env[SERVER_NAME]}/") rescue false)
    raise LintError, "#{env[SERVER_NAME]} must be a valid authority"
  end

  ## The <tt>HTTP_HOST</tt> must be a valid authority as defined by RFC7540.
  unless (URI.parse("http://#{env[HTTP_HOST]}/") rescue false)
    raise LintError, "#{env[HTTP_HOST]} must be a valid authority"
  end

  ## The <tt>SERVER_PROTOCOL</tt> must match the regexp <tt>HTTP/\d(\.\d)?</tt>.
  server_protocol = env['SERVER_PROTOCOL']
  unless %r{HTTP/\d(\.\d)?}.match?(server_protocol)
    raise LintError, "env[SERVER_PROTOCOL] does not match HTTP/\\d(\\.\\d)?"
  end

  ## If the <tt>HTTP_VERSION</tt> is present, it must equal the <tt>SERVER_PROTOCOL</tt>.
  if env['HTTP_VERSION'] && env['HTTP_VERSION'] != server_protocol
    raise LintError, "env[HTTP_VERSION] does not equal env[SERVER_PROTOCOL]"
  end

  ## The environment must not contain the keys
  ## <tt>HTTP_CONTENT_TYPE</tt> or <tt>HTTP_CONTENT_LENGTH</tt>
  ## (use the versions without <tt>HTTP_</tt>).
  %w[HTTP_CONTENT_TYPE HTTP_CONTENT_LENGTH].each { |header|
    if env.include? header
      raise LintError, "env contains #{header}, must use #{header[5, -1]}"
    end
  }

  ## The CGI keys (named without a period) must have String values.
  ## If the string values for CGI keys contain non-ASCII characters,
  ## they should use ASCII-8BIT encoding.
  env.each { |key, value|
    next  if key.include? "."   # Skip extensions
    unless value.kind_of? String
      raise LintError, "env variable #{key} has non-string value #{value.inspect}"
    end
    next if value.encoding == Encoding::ASCII_8BIT
    unless value.b !~ /[\x80-\xff]/n
      raise LintError, "env variable #{key} has value containing non-ASCII characters and has non-ASCII-8BIT encoding #{value.inspect} encoding: #{value.encoding}"
    end
  }

  ## There are the following restrictions:

  ## * <tt>rack.url_scheme</tt> must either be +http+ or +https+.
  unless %w[http https].include?(env[RACK_URL_SCHEME])
    raise LintError, "rack.url_scheme unknown: #{env[RACK_URL_SCHEME].inspect}"
  end

  ## * There must be a valid input stream in <tt>rack.input</tt>.
  check_input env[RACK_INPUT]
  ## * There must be a valid error stream in <tt>rack.errors</tt>.
  check_error env[RACK_ERRORS]
  ## * There may be a valid hijack callback in <tt>rack.hijack</tt>
  check_hijack env

  ## * The <tt>REQUEST_METHOD</tt> must be a valid token.
  unless env[REQUEST_METHOD] =~ /\A[0-9A-Za-z!\#$%&'*+.^_`|~-]+\z/
    raise LintError, "REQUEST_METHOD unknown: #{env[REQUEST_METHOD].dump}"
  end

  ## * The <tt>SCRIPT_NAME</tt>, if non-empty, must start with <tt>/</tt>
  if env.include?(SCRIPT_NAME) && env[SCRIPT_NAME] != "" && env[SCRIPT_NAME] !~ /\A\//
    raise LintError, "SCRIPT_NAME must start with /"
  end
  ## * The <tt>PATH_INFO</tt>, if non-empty, must start with <tt>/</tt>
  if env.include?(PATH_INFO) && env[PATH_INFO] != "" && env[PATH_INFO] !~ /\A\//
    raise LintError, "PATH_INFO must start with /"
  end
  ## * The <tt>CONTENT_LENGTH</tt>, if given, must consist of digits only.
  if env.include?("CONTENT_LENGTH") && env["CONTENT_LENGTH"] !~ /\A\d+\z/
    raise LintError, "Invalid CONTENT_LENGTH: #{env["CONTENT_LENGTH"]}"
  end

  ## * One of <tt>SCRIPT_NAME</tt> or <tt>PATH_INFO</tt> must be
  ##   set. <tt>PATH_INFO</tt> should be <tt>/</tt> if
  ##   <tt>SCRIPT_NAME</tt> is empty.
  unless env[SCRIPT_NAME] || env[PATH_INFO]
    raise LintError, "One of SCRIPT_NAME or PATH_INFO must be set (make PATH_INFO '/' if SCRIPT_NAME is empty)"
  end
  ##   <tt>SCRIPT_NAME</tt> never should be <tt>/</tt>, but instead be empty.
  unless env[SCRIPT_NAME] != "/"
    raise LintError, "SCRIPT_NAME cannot be '/', make it '' and PATH_INFO '/'"
  end

  ## <tt>rack.response_finished</tt>:: An array of callables run by the server after the response has been
  ## processed. This would typically be invoked after sending the response to the client, but it could also be
  ## invoked if an error occurs while generating the response or sending the response; in that case, the error
  ## argument will be a subclass of +Exception+.
  ## The callables are invoked with +env, status, headers, error+ arguments and should not raise any
  ## exceptions. They should be invoked in reverse order of registration.
  if callables = env[RACK_RESPONSE_FINISHED]
    raise LintError, "rack.response_finished must be an array of callable objects" unless callables.is_a?(Array)

    callables.each do |callable|
      raise LintError, "rack.response_finished values must respond to call(env, status, headers, error)" unless callable.respond_to?(:call)
    end
  end
end

#check_error(error) ⇒ Object

The Error Stream


491
492
493
494
495
496
497
498
# File 'lib/rack/lint.rb', line 491

def check_error(error)
  ## The error stream must respond to +puts+, +write+ and +flush+.
  [:puts, :write, :flush].each { |method|
    unless error.respond_to? method
      raise LintError, "rack.error #{error} does not respond to ##{method}"
    end
  }
end

#check_header_value(key, value) ⇒ Object


667
668
669
670
671
672
# File 'lib/rack/lint.rb', line 667

def check_header_value(key, value)
  ## such that each String instance must not contain characters below 037.
  if value =~ /[\000-\037]/
    raise LintError, "invalid header value #{key}: #{value.inspect}"
  end
end

#check_headers(headers) ⇒ Object

The Headers


627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
# File 'lib/rack/lint.rb', line 627

def check_headers(headers)
  ## The headers must be a unfrozen Hash.
  unless headers.kind_of?(Hash)
    raise LintError, "headers object should be a hash, but isn't (got #{headers.class} as headers)"
  end

  if headers.frozen?
    raise LintError, "headers object should not be frozen, but is"
  end

  headers.each do |key, value|
    ## The header keys must be Strings.
    unless key.kind_of? String
      raise LintError, "header key must be a string, was #{key.class}"
    end

    ## Special headers starting "rack." are for communicating with the
    ## server, and must not be sent back to the client.
    next if key.start_with?("rack.")

    ## The header must not contain a +Status+ key.
    raise LintError, "header must not contain status" if key == "status"
    ## Header keys must conform to RFC7230 token specification, i.e. cannot
    ## contain non-printable ASCII, DQUOTE or "(),/:;<=>[email protected][\]{}".
    raise LintError, "invalid header name: #{key}" if key =~ /[\(\),\/:;<=>\[email protected]\[\\\]{}[:cntrl:]]/
    ## 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 instance,
    if value.kind_of?(String)
      check_header_value(key, value)
    elsif value.kind_of?(Array)
      ## or an Array of String instances,
      value.each{|value| check_header_value(key, value)}
    else
      raise LintError, "a header value must be a String or Array of Strings, but the value of '#{key}' is a #{value.class}"
    end
  end
end

#check_hijack(env) ⇒ Object

Hijacking

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 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 HTTP/1 connection. It occurs before any headers are written and causes the request to ignores any response generated by the application.

It is intended to be used when applications need access to raw HTTP/1 connection.


551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
# File 'lib/rack/lint.rb', line 551

def check_hijack(env)
  ## If +rack.hijack+ is present in +env+, it must respond to +call+
  if original_hijack = env[RACK_HIJACK]
    raise LintError, "rack.hijack must respond to call" unless original_hijack.respond_to?(:call)

    env[RACK_HIJACK] = proc do
      io = original_hijack.call

      ## and return an +IO+ instance 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
    end
  end
end

#check_hijack_response(headers, env) ⇒ Object

Partial Hijack

Partial hijack is used for bi-directional streaming of the request and response body. It occurs after the status and headers are written by the server and causes the server to ignore the Body of the response.

It is intended to be used when applications need bi-directional streaming.


579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
# File 'lib/rack/lint.rb', line 579

def check_hijack_response(headers, env)
  ## If +rack.hijack?+ is present in +env+ and truthy,
  if env[RACK_IS_HIJACK]
    ## an application may set the special response header +rack.hijack+
    if original_hijack = headers[RACK_HIJACK]
      ## to an object that responds to +call+,
      unless original_hijack.respond_to?(:call)
        raise LintError, 'rack.hijack header must respond to #call'
      end
      ## accepting a +stream+ argument.
      return proc do |io|
        original_hijack.call StreamWrapper.new(io)
      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
    ## +rack.hijack+ response header is present. Using an empty +Array+
    ## instance is recommended.
  else
    ##
    ## The special response header +rack.hijack+ must only be set
    ## if the request +env+ has a truthy +rack.hijack?+.
    if headers.key?(RACK_HIJACK)
      raise LintError, 'rack.hijack header must not be present if server does not support hijacking'
    end
  end

  nil
end

#check_input(input) ⇒ Object

The Input Stream

The input stream is an IO-like object which contains the raw HTTP POST data.


387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
# File 'lib/rack/lint.rb', line 387

def check_input(input)
  ## When applicable, its external encoding must be "ASCII-8BIT" and it
  ## must be opened in binary mode, for Ruby 1.9 compatibility.
  if input.respond_to?(:external_encoding) && input.external_encoding != Encoding::ASCII_8BIT
    raise LintError, "rack.input #{input} does not have ASCII-8BIT as its external encoding"
  end
  if input.respond_to?(:binmode?) && !input.binmode?
    raise LintError, "rack.input #{input} is not opened in binary mode"
  end

  ## The input stream must respond to +gets+, +each+, and +read+.
  [:gets, :each, :read].each { |method|
    unless input.respond_to? method
      raise LintError, "rack.input #{input} does not respond to ##{method}"
    end
  }
end

#check_status(status) ⇒ Object

The Response

The Status


616
617
618
619
620
621
622
# File 'lib/rack/lint.rb', line 616

def check_status(status)
  ## This is an HTTP status. It must be an Integer greater than or equal to
  ## 100.
  unless status.is_a?(Integer) && status >= 100
    raise LintError, "Status must be an Integer >=100"
  end
end

#closeObject

The Body

The Body is typically an Array of String instances, an enumerable that yields String instances, a Proc instance, or a File-like object.

The Body must respond to each or call. It may optionally respond to to_path or to_ary. A Body that responds to each is considered to be an Enumerable Body. A Body that responds to call is considered to be a Streaming Body.

A Body that responds to both each and call must be treated as an Enumerable Body, not a Streaming Body. If it responds to each, you must call each and not call. If the Body doesn't respond to each, then you can assume it responds to call.

The Body must either be consumed or returned. The Body is consumed by optionally calling either each or call. Then, if the Body responds to close, it must be called to release any resources associated with the generation of the body. In other words, close must always be called at least once; typically after the web server has sent the response to the client, but also in cases where the Rack application makes internal/virtual requests and discards the response.


744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
# File 'lib/rack/lint.rb', line 744

def close
  ##
  ## After calling +close+, the Body is considered closed and should not
  ## be consumed again.
  @closed = true

  ## If the original Body is replaced by a new Body, the new Body must
  ## also consume the original Body by calling +close+ if possible.
  @body.close if @body.respond_to?(:close)

  index = @lint.index(self)
  unless @env['rack.lint'][0..index].all? {|lint| lint.instance_variable_get(:@closed)}
    raise LintError, "Body has not been closed"
  end
end

#eachObject

Enumerable Body

Raises:


778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
# File 'lib/rack/lint.rb', line 778

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 not be called after being closed.
  raise LintError, "Response body is already closed" if @closed

  @invoked = :each

  @body.each do |chunk|
    ## and must only yield String values.
    unless chunk.kind_of? String
      raise LintError, "Body yielded non-string value #{chunk.inspect}"
    end

    ##
    ## The Body itself should not be an instance of String, as this will
    ## break in Ruby 1.9.
    ##
    ## 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 @lint[0] == self
      @env['rack.lint.body_iteration'] += 1
    else
      if (@env['rack.lint.body_iteration'] -= 1) > 0
        raise LintError, "New body must yield at least once per iteration of old body"
      end
    end

    @size += chunk.bytesize
    yield chunk
  end

  verify_content_length(@size)

  verify_to_path
end

#respond_to?(name) ⇒ Boolean

Returns:

  • (Boolean)

826
827
828
829
830
831
832
# File 'lib/rack/lint.rb', line 826

def respond_to?(name, *)
  if BODY_METHODS.key?(name)
    @body.respond_to?(name)
  else
    super
  end
end

#responseObject

Raises:


54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
# File 'lib/rack/lint.rb', line 54

def response
  ## It takes exactly one argument, the *environment*
  raise LintError, "No env given" unless @env
  check_environment(@env)

  @env[RACK_INPUT] = InputWrapper.new(@env[RACK_INPUT])
  @env[RACK_ERRORS] = ErrorWrapper.new(@env[RACK_ERRORS])

  ## and returns a non-frozen Array of exactly three values:
  @response = @app.call(@env)
  raise LintError, "response is not an Array, but #{@response.class}" unless @response.kind_of? Array
  raise LintError, "response is frozen" if @response.frozen?
  raise LintError, "response array has #{@response.size} elements instead of 3" unless @response.size == 3

  @status, @headers, @body = @response
  ## The *status*,
  check_status(@status)

  ## the *headers*,
  check_headers(@headers)

  hijack_proc = check_hijack_response(@headers, @env)
  if hijack_proc
    @headers[RACK_HIJACK] = hijack_proc
  end

  ## and the *body*.
  check_content_type(@status, @headers)
  check_content_length(@status, @headers)
  @head_request = @env[REQUEST_METHOD] == HEAD

  @lint = (@env['rack.lint'] ||= []) << self

  if (@env['rack.lint.body_iteration'] ||= 0) > 0
    raise LintError, "Middleware must not call #each directly"
  end

  return [@status, @headers, self]
end

#to_aryObject

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.


842
843
844
845
846
847
848
849
850
# File 'lib/rack/lint.rb', line 842

def to_ary
  @body.to_ary.tap do |content|
    unless content == @body.enum_for.to_a
      raise LintError, "#to_ary not identical to contents produced by calling #each"
    end
  end
ensure
  close
end

#to_pathObject


822
823
824
# File 'lib/rack/lint.rb', line 822

def to_path
  @body.to_path
end

#verify_content_length(size) ⇒ Object


706
707
708
709
710
711
712
713
714
715
716
# File 'lib/rack/lint.rb', line 706

def verify_content_length(size)
  if @head_request
    unless size == 0
      raise LintError, "Response body was given for HEAD request, but should be empty"
    end
  elsif @content_length
    unless @content_length == size.to_s
      raise LintError, "content-length header was #{@content_length}, but should be #{size}"
    end
  end
end

#verify_to_pathObject


760
761
762
763
764
765
766
767
768
769
770
771
772
773
# File 'lib/rack/lint.rb', line 760

def verify_to_path
  ##
  ## If the Body responds to +to_path+, it must return a +String+
  ## path for the local file system whose contents are identical
  ## to that produced by calling +each+; this may be used by the
  ## server as an alternative, possibly more efficient way to
  ## transport the response. The +to_path+ method does not consume
  ## the body.
  if @body.respond_to?(:to_path)
    unless ::File.exist? @body.to_path
      raise LintError, "The file identified by body.to_path does not exist"
    end
  end
end