Format all dart: library files

sdk/lib/io/http_headers.dart

 // Copyright (c) 2013, 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.
 
 part of dart.io;
 
 class _HttpHeaders implements HttpHeaders {
   final Map<String, List<String>> _headers;
   final String protocolVersion;
 
-  bool _mutable = true;  // Are the headers currently mutable?
+  bool _mutable = true; // Are the headers currently mutable?
   List<String> _noFoldingHeaders;
 
   int _contentLength = -1;
   bool _persistentConnection = true;
   bool _chunkedTransferEncoding = false;
   String _host;
   int _port;
 
   final int _defaultPortForScheme;
 
   _HttpHeaders(this.protocolVersion,
-               {int defaultPortForScheme: HttpClient.DEFAULT_HTTP_PORT,
-                _HttpHeaders initialHeaders})
+      {int defaultPortForScheme: HttpClient.DEFAULT_HTTP_PORT,
+      _HttpHeaders initialHeaders})
       : _headers = new HashMap<String, List<String>>(),
         _defaultPortForScheme = defaultPortForScheme {
     if (initialHeaders != null) {
       initialHeaders._headers.forEach((name, value) => _headers[name] = value);
       _contentLength = initialHeaders._contentLength;
       _persistentConnection = initialHeaders._persistentConnection;
       _chunkedTransferEncoding = initialHeaders._chunkedTransferEncoding;
       _host = initialHeaders._host;
       _port = initialHeaders._port;
     }
     if (protocolVersion == "1.0") {
       _persistentConnection = false;
       _chunkedTransferEncoding = false;
     }
   }
 
-  List<String> operator[](String name) => _headers[name.toLowerCase()];
+  List<String> operator [](String name) => _headers[name.toLowerCase()];
 
   String value(String name) {
     name = name.toLowerCase();
     List<String> values = _headers[name];
     if (values == null) return null;
     if (values.length > 1) {
       throw new HttpException("More than one value for header $name");
     }
     return values[0];
   }
@@ skipping 395 matching lines @@
     if (!_mutable) throw new HttpException("HTTP headers are not mutable");
   }
 
   _updateHostHeader() {
     bool defaultPort = _port == null || _port == _defaultPortForScheme;
     _set("host", defaultPort ? host : "$host:$_port");
   }
 
   _foldHeader(String name) {
     if (name == HttpHeaders.SET_COOKIE ||
-        (_noFoldingHeaders != null &&
-         _noFoldingHeaders.indexOf(name) != -1)) {
+        (_noFoldingHeaders != null && _noFoldingHeaders.indexOf(name) != -1)) {
       return false;
     }
     return true;
   }
 
   void _finalize() {
     _mutable = false;
   }
 
   void _build(BytesBuilder builder) {
@@ skipping 47 matching lines @@
   List<Cookie> _parseCookies() {
     // Parse a Cookie header value according to the rules in RFC 6265.
     var cookies = new List<Cookie>();
     void parseCookieString(String s) {
       int index = 0;
 
       bool done() => index == -1 || index == s.length;
 
       void skipWS() {
         while (!done()) {
-         if (s[index] != " " && s[index] != "\t") return;
-         index++;
+          if (s[index] != " " && s[index] != "\t") return;
+          index++;
         }
       }
 
       String parseName() {
         int start = index;
         while (!done()) {
           if (s[index] == " " || s[index] == "\t" || s[index] == "=") break;
           index++;
         }
         return s.substring(start, index);
@@ skipping 32 matching lines @@
           // Skip it, invalid cookie data.
         }
         skipWS();
         if (done()) return;
         if (!expect(";")) {
           index = s.indexOf(';', index);
           continue;
         }
       }
     }
+
     List<String> values = _headers[HttpHeaders.COOKIE];
     if (values != null) {
       values.forEach((headerValue) => parseCookieString(headerValue));
     }
     return cookies;
   }
 
   static String _validateField(String field) {
     for (var i = 0; i < field.length; i++) {
       if (!_HttpParser._isTokenChar(field.codeUnitAt(i))) {
         throw new FormatException(
             "Invalid HTTP header field name: ${JSON.encode(field)}");
       }
     }
     return field.toLowerCase();
   }
 
   static _validateValue(value) {
     if (value is! String) return value;
     for (var i = 0; i < value.length; i++) {
       if (!_HttpParser._isValueChar(value.codeUnitAt(i))) {
         throw new FormatException(
             "Invalid HTTP header field value: ${JSON.encode(value)}");
       }
     }
     return value;
   }
 }
 
-
 class _HeaderValue implements HeaderValue {
   String _value;
   Map<String, String> _parameters;
   Map<String, String> _unmodifiableParameters;
 
   _HeaderValue([this._value = "", Map<String, String> parameters]) {
     if (parameters != null) {
       _parameters = new HashMap<String, String>.from(parameters);
     }
   }
 
   static _HeaderValue parse(String value,
-                            {parameterSeparator: ";",
-                             valueSeparator: null,
-                             preserveBackslash: false}) {
+      {parameterSeparator: ";",
+      valueSeparator: null,
+      preserveBackslash: false}) {
     // Parse the string.
     var result = new _HeaderValue();
     result._parse(value, parameterSeparator, valueSeparator, preserveBackslash);
     return result;
   }
 
   String get value => _value;
 
   void _ensureParameters() {
     if (_parameters == null) {
@@ skipping 13 matching lines @@
     StringBuffer sb = new StringBuffer();
     sb.write(_value);
     if (parameters != null && parameters.length > 0) {
       _parameters.forEach((String name, String value) {
         sb..write("; ")..write(name)..write("=")..write(value);
       });
     }
     return sb.toString();
   }
 
-  void _parse(String s,
-        String parameterSeparator,
-        String valueSeparator,
-        bool preserveBackslash) {
+  void _parse(String s, String parameterSeparator, String valueSeparator,
+      bool preserveBackslash) {
     int index = 0;
 
     bool done() => index == s.length;
 
     void skipWS() {
       while (!done()) {
         if (s[index] != " " && s[index] != "\t") return;
         index++;
       }
     }
@@ skipping 84 matching lines @@
         }
         String value = parseParameterValue();
         if (name == 'charset' && this is _ContentType && value != null) {
           // Charset parameter of ContentTypes are always lower-case.
           value = value.toLowerCase();
         }
         parameters[name] = value;
         skipWS();
         if (done()) return;
         // TODO: Implement support for multi-valued parameters.
-        if(s[index] == valueSeparator) return;
+        if (s[index] == valueSeparator) return;
         expect(parameterSeparator);
       }
     }
 
     skipWS();
     _value = parseValue();
     skipWS();
     if (done()) return;
     maybeExpect(parameterSeparator);
     parseParameters();
   }
 }
 
-
 class _ContentType extends _HeaderValue implements ContentType {
   String _primaryType = "";
   String _subType = "";
 
-  _ContentType(String primaryType,
-               String subType,
-               String charset,
-               Map<String, String> parameters)
-      : _primaryType = primaryType, _subType = subType, super("") {
+  _ContentType(String primaryType, String subType, String charset,
+      Map<String, String> parameters)
+      : _primaryType = primaryType,
+        _subType = subType,
+        super("") {
     if (_primaryType == null) _primaryType = "";
     if (_subType == null) _subType = "";
     _value = "$_primaryType/$_subType";
     if (parameters != null) {
       _ensureParameters();
       parameters.forEach((String key, String value) {
         String lowerCaseKey = key.toLowerCase();
         if (lowerCaseKey == "charset") {
           value = value.toLowerCase();
         }
@@ skipping 25 matching lines @@
 
   String get mimeType => '$primaryType/$subType';
 
   String get primaryType => _primaryType;
 
   String get subType => _subType;
 
   String get charset => parameters["charset"];
 }
 
-
 class _Cookie implements Cookie {
   String name;
   String value;
   DateTime expires;
   int maxAge;
   String domain;
   String path;
   bool httpOnly = false;
   bool secure = false;
 
@@ skipping 56 matching lines @@
           if (s[index] == ";") break;
           index++;
         }
         return s.substring(start, index).trim().toLowerCase();
       }
 
       while (!done()) {
         String name = parseAttributeName();
         String value = "";
         if (!done() && s[index] == "=") {
-          index++;  // Skip the = character.
+          index++; // Skip the = character.
           value = parseAttributeValue();
         }
         if (name == "expires") {
           expires = HttpDate._parseCookieDate(value);
         } else if (name == "max-age") {
           maxAge = int.parse(value);
         } else if (name == "domain") {
           domain = value;
         } else if (name == "path") {
           path = value;
         } else if (name == "httponly") {
           httpOnly = true;
         } else if (name == "secure") {
           secure = true;
         }
-        if (!done()) index++;  // Skip the ; character
+        if (!done()) index++; // Skip the ; character
       }
     }
 
     name = parseName();
     if (done() || name.length == 0) {
       throw new HttpException("Failed to parse header value [$s]");
     }
-    index++;  // Skip the = character.
+    index++; // Skip the = character.
     value = parseValue();
     _validate();
     if (done()) return;
-    index++;  // Skip the ; character.
+    index++; // Skip the ; character.
     parseAttributes();
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb..write(name)..write("=")..write(value);
     if (expires != null) {
       sb..write("; Expires=")..write(HttpDate.format(expires));
     }
     if (maxAge != null) {
       sb..write("; Max-Age=")..write(maxAge);
     }
     if (domain != null) {
       sb..write("; Domain=")..write(domain);
     }
     if (path != null) {
       sb..write("; Path=")..write(path);
     }
     if (secure) sb.write("; Secure");
     if (httpOnly) sb.write("; HttpOnly");
     return sb.toString();
   }
 
   void _validate() {
     const SEPERATORS = const [
-        "(", ")", "<", ">", "@", ",", ";", ":", "\\",
-        '"', "/", "[", "]", "?", "=", "{", "}"];
+      "(",
+      ")",
+      "<",
+      ">",
+      "@",
+      ",",
+      ";",
+      ":",
+      "\\",
+      '"',
+      "/",
+      "[",
+      "]",
+      "?",
+      "=",
+      "{",
+      "}"
+    ];
     for (int i = 0; i < name.length; i++) {
       int codeUnit = name.codeUnits[i];
       if (codeUnit <= 32 ||
           codeUnit >= 127 ||
           SEPERATORS.indexOf(name[i]) >= 0) {
         throw new FormatException(
             "Invalid character in cookie name, code unit: '$codeUnit'");
       }
     }
     for (int i = 0; i < value.length; i++) {
       int codeUnit = value.codeUnits[i];
       if (!(codeUnit == 0x21 ||
-            (codeUnit >= 0x23 && codeUnit <= 0x2B) ||
-            (codeUnit >= 0x2D && codeUnit <= 0x3A) ||
-            (codeUnit >= 0x3C && codeUnit <= 0x5B) ||
-            (codeUnit >= 0x5D && codeUnit <= 0x7E))) {
+          (codeUnit >= 0x23 && codeUnit <= 0x2B) ||
+          (codeUnit >= 0x2D && codeUnit <= 0x3A) ||
+          (codeUnit >= 0x3C && codeUnit <= 0x5B) ||
+          (codeUnit >= 0x5D && codeUnit <= 0x7E))) {
         throw new FormatException(
             "Invalid character in cookie value, code unit: '$codeUnit'");
       }
     }
   }
 }