Add a context field to Message in shelf.

pkg/shelf/lib/src/response.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library shelf.response;
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:http_parser/http_parser.dart';
@@ skipping 35 matching lines @@
   /// This indicates that the request has succeeded.
   ///
   /// [body] is the response body. It may be either a [String], a
   /// [Stream<List<int>>], or `null` to indicate no body. If it's a [String],
   /// [encoding] is used to encode it to a [Stream<List<int>>]. It defaults to
   /// UTF-8.
   ///
   /// If [encoding] is passed, the "encoding" field of the Content-Type header
   /// in [headers] will be set appropriately. If there is no existing
   /// Content-Type header, it will be set to "application/octet-stream".
-  Response.ok(body, {Map<String, String> headers, Encoding encoding})
-      : this(200, body: body, headers: headers, encoding: encoding);
+  Response.ok(body, {Map<String, String> headers, Encoding encoding, 
+    Map<String, Object> context})
+      : this(200, body: body, headers: headers, encoding: encoding,
+          context: context);
 
   /// Constructs a 301 Moved Permanently response.
   ///
   /// This indicates that the requested resource has moved permanently to a new
   /// URI. [location] is that URI; it can be either a [String] or a [Uri]. It's
   /// automatically set as the Location header in [headers].
   ///
   /// [body] is the response body. It may be either a [String], a
   /// [Stream<List<int>>], or `null` to indicate no body. If it's a [String],
   /// [encoding] is used to encode it to a [Stream<List<int>>]. It defaults to
   /// UTF-8.
   ///
   /// If [encoding] is passed, the "encoding" field of the Content-Type header
   /// in [headers] will be set appropriately. If there is no existing
   /// Content-Type header, it will be set to "application/octet-stream".
   Response.movedPermanently(location, {body, Map<String, String> headers,
-      Encoding encoding})
-      : this._redirect(301, location, body, headers, encoding);
+      Encoding encoding, Map<String, Object> context})
+      : this._redirect(301, location, body, headers, encoding,
+          context: context);
 
   /// Constructs a 302 Found response.
   ///
   /// This indicates that the requested resource has moved temporarily to a new
   /// URI. [location] is that URI; it can be either a [String] or a [Uri]. It's
   /// automatically set as the Location header in [headers].
   ///
   /// [body] is the response body. It may be either a [String], a
   /// [Stream<List<int>>], or `null` to indicate no body. If it's a [String],
   /// [encoding] is used to encode it to a [Stream<List<int>>]. It defaults to
   /// UTF-8.
   ///
   /// If [encoding] is passed, the "encoding" field of the Content-Type header
   /// in [headers] will be set appropriately. If there is no existing
   /// Content-Type header, it will be set to "application/octet-stream".
   Response.found(location, {body, Map<String, String> headers,
-      Encoding encoding})
-      : this._redirect(302, location, body, headers, encoding);
+      Encoding encoding, Map<String, Object> context})
+      : this._redirect(302, location, body, headers, encoding,
+          context: context);
 
   /// Constructs a 303 See Other response.
   ///
   /// This indicates that the response to the request should be retrieved using
   /// a GET request to a new URI. [location] is that URI; it can be either a
   /// [String] or a [Uri]. It's automatically set as the Location header in
   /// [headers].
   ///
   /// [body] is the response body. It may be either a [String], a
   /// [Stream<List<int>>], or `null` to indicate no body. If it's a [String],
   /// [encoding] is used to encode it to a [Stream<List<int>>]. It defaults to
   /// UTF-8.
   ///
   /// If [encoding] is passed, the "encoding" field of the Content-Type header
   /// in [headers] will be set appropriately. If there is no existing
   /// Content-Type header, it will be set to "application/octet-stream".
   Response.seeOther(location, {body, Map<String, String> headers,
-      Encoding encoding})
-      : this._redirect(303, location, body, headers, encoding);
+      Encoding encoding, Map<String, Object> context})
+      : this._redirect(303, location, body, headers, encoding,
+          context: context);
 
   /// Constructs a helper constructor for redirect responses.
   Response._redirect(int statusCode, location, body,
-      Map<String, String> headers, Encoding encoding)
+      Map<String, String> headers, Encoding encoding, 
+      { Map<String, Object> context })
       : this(statusCode,
             body: body,
             encoding: encoding,
             headers: _addHeader(
-                headers, 'location', _locationToString(location)));
+                headers, 'location', _locationToString(location)),
+            context: context);
 
   /// Constructs a 304 Not Modified response.
   ///
   /// This is used to respond to a conditional GET request that provided
   /// information used to determine whether the requested resource has changed
   /// since the last request. It indicates that the resource has not changed and
   /// the old value should be used.
-  Response.notModified({Map<String, String> headers})
+  Response.notModified({Map<String, String> headers, 
+    Map<String, Object> context})
       : this(304, headers: _addHeader(
-            headers, 'date', formatHttpDate(new DateTime.now())));
+            headers, 'date', formatHttpDate(new DateTime.now())),
+            context: context);
 
   /// Constructs a 403 Forbidden response.
   ///
   /// This indicates that the server is refusing to fulfill the request.
   ///
   /// [body] is the response body. It may be either a [String], a
   /// [Stream<List<int>>], or `null` to indicate no body. If it's a [String],
   /// [encoding] is used to encode it to a [Stream<List<int>>]. It defaults to
   /// UTF-8.
   ///
   /// If [encoding] is passed, the "encoding" field of the Content-Type header
   /// in [headers] will be set appropriately. If there is no existing
   /// Content-Type header, it will be set to "application/octet-stream".
   Response.forbidden(body, {Map<String, String> headers,
-      Encoding encoding})
-      : this(403, body: body, headers: headers);
+      Encoding encoding, Map<String, Object> context})
+      : this(403, body: body, headers: headers,
+          context: context);
 
   /// Constructs a 404 Not Found response.
   ///
   /// This indicates that the server didn't find any resource matching the
   /// requested URI.
   ///
   /// [body] is the response body. It may be either a [String], a
   /// [Stream<List<int>>], or `null` to indicate no body. If it's a [String],
   /// [encoding] is used to encode it to a [Stream<List<int>>]. It defaults to
   /// UTF-8.
   ///
   /// If [encoding] is passed, the "encoding" field of the Content-Type header
   /// in [headers] will be set appropriately. If there is no existing
   /// Content-Type header, it will be set to "application/octet-stream".
-  Response.notFound(body, {Map<String, String> headers, Encoding encoding})
-      : this(404, body: body, headers: headers);
+  Response.notFound(body, {Map<String, String> headers, Encoding encoding, 
+    Map<String, Object> context})
+      : this(404, body: body, headers: headers,
+          context: context);
 
   /// Constructs a 500 Internal Server Error response.
   ///
   /// This indicates that the server had an internal error that prevented it
   /// from fulfilling the request.
   ///
   /// [body] is the response body. It may be either a [String], a
   /// [Stream<List<int>>], or `null` to indicate no body. If it's `null` or not
   /// passed, a default error message is used. If it's a [String], [encoding] is
   /// used to encode it to a [Stream<List<int>>]. It defaults to UTF-8.
   ///
   /// If [encoding] is passed, the "encoding" field of the Content-Type header
   /// in [headers] will be set appropriately. If there is no existing
   /// Content-Type header, it will be set to "application/octet-stream".
   Response.internalServerError({body, Map<String, String> headers,
-      Encoding encoding})
+      Encoding encoding, Map<String, Object> context})
       : this(500,
             headers: body == null ? _adjust500Headers(headers) : headers,
-            body: body == null ? 'Internal Server Error' : body);
+            body: body == null ? 'Internal Server Error' : body,
+            context: context);
 
   /// Constructs an HTTP response with the given [statusCode].
   ///
   /// [statusCode] must be greater than or equal to 100.
   ///
   /// [body] is the response body. It may be either a [String], a
   /// [Stream<List<int>>], or `null` to indicate no body. If it's `null` or not
   /// passed, a default error message is used. If it's a [String], [encoding] is
   /// used to encode it to a [Stream<List<int>>]. It defaults to UTF-8.
   ///
   /// If [encoding] is passed, the "encoding" field of the Content-Type header
   /// in [headers] will be set appropriately. If there is no existing
   /// Content-Type header, it will be set to "application/octet-stream".
   Response(this.statusCode, {body, Map<String, String> headers,
-      Encoding encoding})
+      Encoding encoding, Map<String, Object> context})
       : super(_bodyToStream(body, encoding),
-          headers: _adjustHeaders(headers, encoding)) {
+          headers: _adjustHeaders(headers, encoding),
+          context: context) {
     if (statusCode < 100) {
       throw new ArgumentError("Invalid status code: $statusCode.");
     }
   }
 }
 
 /// Converts [body] to a byte stream.
 ///
 /// [body] may be either a [String], a [Stream<List<int>>], or `null`. If it's a
 /// [String], [encoding] will be used to convert it to a [Stream<List<int>>].
@@ skipping 51 matching lines @@
 /// Converts [location], which may be a [String] or a [Uri], to a [String].
 ///
 /// Throws an [ArgumentError] if [location] isn't a [String] or a [Uri].
 String _locationToString(location) {
   if (location is String) return location;
   if (location is Uri) return location.toString();
 
   throw new ArgumentError('Response location must be a String or Uri, was '
       '"$location".');
 }