Fix newly enforced package:pedantic lints (#24)

kevmoo · natebosch · commit 8050a55b16fa · 2019-12-13T10:52:40.000-08:00
- prefer_single_quotes

Drop unused author field pubspec.
diff --git a/lib/shelf_web_socket.dart b/lib/shelf_web_socket.dart
@@ -47,8 +47,8 @@ Handler webSocketHandler(Function onConnection,
     Duration pingInterval}) {
   if (onConnection is! _BinaryFunction) {
     if (protocols != null) {
-      throw ArgumentError("If protocols is non-null, onConnection must "
-          "take two arguments, the WebSocket and the protocol.");
+      throw ArgumentError('If protocols is non-null, onConnection must '
+          'take two arguments, the WebSocket and the protocol.');
     }
 
     var innerOnConnection = onConnection;
diff --git a/lib/src/web_socket_handler.dart b/lib/src/web_socket_handler.dart
@@ -54,8 +54,8 @@ class WebSocketHandler {
     if (key == null) return _badRequest('missing Sec-WebSocket-Key header.');
 
     if (!request.canHijack) {
-      throw ArgumentError("webSocketHandler may only be used with a server "
-          "that supports request hijacking.");
+      throw ArgumentError('webSocketHandler may only be used with a server '
+          'that supports request hijacking.');
     }
 
     // The Origin header is always set by browser connections. By filtering out
@@ -71,12 +71,12 @@ class WebSocketHandler {
     var protocol = _chooseProtocol(request);
     request.hijack((channel) {
       var sink = utf8.encoder.startChunkedConversion(channel.sink);
-      sink.add("HTTP/1.1 101 Switching Protocols\r\n"
-          "Upgrade: websocket\r\n"
-          "Connection: Upgrade\r\n"
-          "Sec-WebSocket-Accept: ${WebSocketChannel.signKey(key)}\r\n");
-      if (protocol != null) sink.add("Sec-WebSocket-Protocol: $protocol\r\n");
-      sink.add("\r\n");
+      sink.add('HTTP/1.1 101 Switching Protocols\r\n'
+          'Upgrade: websocket\r\n'
+          'Connection: Upgrade\r\n'
+          'Sec-WebSocket-Accept: ${WebSocketChannel.signKey(key)}\r\n');
+      if (protocol != null) sink.add('Sec-WebSocket-Protocol: $protocol\r\n');
+      sink.add('\r\n');
 
       _onConnection(
           WebSocketChannel(channel, pingInterval: _pingInterval), protocol);
@@ -103,19 +103,19 @@ class WebSocketHandler {
 
   /// Returns a 404 Not Found response.
   Response _notFound() => _htmlResponse(
-      404, "404 Not Found", "Only WebSocket connections are supported.");
+      404, '404 Not Found', 'Only WebSocket connections are supported.');
 
   /// Returns a 400 Bad Request response.
   ///
   /// [message] will be HTML-escaped before being included in the response body.
   Response _badRequest(String message) => _htmlResponse(
-      400, "400 Bad Request", "Invalid WebSocket upgrade request: $message");
+      400, '400 Bad Request', 'Invalid WebSocket upgrade request: $message');
 
   /// Returns a 403 Forbidden response.
   ///
   /// [message] will be HTML-escaped before being included in the response body.
   Response _forbidden(String message) => _htmlResponse(
-      403, "403 Forbidden", "WebSocket upgrade refused: $message");
+      403, '403 Forbidden', 'WebSocket upgrade refused: $message');
 
   /// Creates an HTTP response with the given [statusCode] and an HTML body with
   /// [title] and [message].
@@ -124,7 +124,7 @@ class WebSocketHandler {
   Response _htmlResponse(int statusCode, String title, String message) {
     title = htmlEscape.convert(title);
     message = htmlEscape.convert(message);
-    return Response(statusCode, body: """
+    return Response(statusCode, body: '''
       <!doctype html>
       <html>
         <head><title>$title</title></head>
@@ -133,6 +133,6 @@ class WebSocketHandler {
           <p>$message</p>
         </body>
       </html>
-    """, headers: {'content-type': 'text/html'});
+    ''', headers: {'content-type': 'text/html'});
   }
 }
diff --git a/pubspec.yaml b/pubspec.yaml
@@ -1,9 +1,8 @@
 name: shelf_web_socket
-version: 0.2.3
+version: 0.2.4-dev
 
 description: >-
   A shelf handler that wires up a listener for every connection.
-author: Dart Team <misc@dartlang.org>
 homepage: https://github.com/dart-lang/shelf_web_socket
 
 environment:
diff --git a/test/web_socket_test.dart b/test/web_socket_test.dart
@@ -10,36 +10,36 @@ import 'package:shelf_web_socket/shelf_web_socket.dart';
 import 'package:test/test.dart';
 
 Map<String, String> get _handshakeHeaders => {
-      "Upgrade": "websocket",
-      "Connection": "Upgrade",
-      "Sec-WebSocket-Key": "x3JJHMbDL1EzLkh9GBhXDw==",
-      "Sec-WebSocket-Version": "13"
+      'Upgrade': 'websocket',
+      'Connection': 'Upgrade',
+      'Sec-WebSocket-Key': 'x3JJHMbDL1EzLkh9GBhXDw==',
+      'Sec-WebSocket-Version': '13'
     };
 
 void main() {
-  test("can communicate with a dart:io WebSocket client", () async {
+  test('can communicate with a dart:io WebSocket client', () async {
     var server = await shelf_io.serve(webSocketHandler((webSocket) {
-      webSocket.sink.add("hello!");
+      webSocket.sink.add('hello!');
       webSocket.stream.first.then((request) {
-        expect(request, equals("ping"));
-        webSocket.sink.add("pong");
+        expect(request, equals('ping'));
+        webSocket.sink.add('pong');
         webSocket.sink.close();
       });
-    }), "localhost", 0);
+    }), 'localhost', 0);
 
     try {
       var webSocket = await WebSocket.connect('ws://localhost:${server.port}');
       var n = 0;
       await webSocket.listen((message) {
         if (n == 0) {
-          expect(message, equals("hello!"));
-          webSocket.add("ping");
+          expect(message, equals('hello!'));
+          webSocket.add('ping');
         } else if (n == 1) {
-          expect(message, equals("pong"));
+          expect(message, equals('pong'));
           webSocket.close();
           server.close();
         } else {
-          fail("Only expected two messages.");
+          fail('Only expected two messages.');
         }
         n++;
       }).asFuture();
@@ -48,74 +48,74 @@ void main() {
     }
   });
 
-  test("negotiates the sub-protocol", () async {
+  test('negotiates the sub-protocol', () async {
     var server = await shelf_io.serve(
         webSocketHandler((webSocket, protocol) {
-          expect(protocol, equals("two"));
+          expect(protocol, equals('two'));
           webSocket.sink.close();
-        }, protocols: ["three", "two", "x"]),
-        "localhost",
+        }, protocols: ['three', 'two', 'x']),
+        'localhost',
         0);
 
     try {
       var webSocket = await WebSocket.connect('ws://localhost:${server.port}',
-          protocols: ["one", "two", "three"]);
-      expect(webSocket.protocol, equals("two"));
+          protocols: ['one', 'two', 'three']);
+      expect(webSocket.protocol, equals('two'));
       return webSocket.close();
     } finally {
       await server.close();
     }
   });
 
-  group("with a set of allowed origins", () {
+  group('with a set of allowed origins', () {
     var server;
     var url;
     setUp(() async {
       server = await shelf_io.serve(
           webSocketHandler((webSocket) {
             webSocket.sink.close();
-          }, allowedOrigins: ["pub.dartlang.org", "GoOgLe.CoM"]),
-          "localhost",
+          }, allowedOrigins: ['pub.dartlang.org', 'GoOgLe.CoM']),
+          'localhost',
           0);
       url = 'http://localhost:${server.port}/';
     });
 
     tearDown(() => server.close());
 
-    test("allows access with an allowed origin", () {
+    test('allows access with an allowed origin', () {
       var headers = _handshakeHeaders;
       headers['Origin'] = 'pub.dartlang.org';
       expect(http.get(url, headers: headers), hasStatus(101));
     });
 
-    test("forbids access with a non-allowed origin", () {
+    test('forbids access with a non-allowed origin', () {
       var headers = _handshakeHeaders;
       headers['Origin'] = 'dartlang.org';
       expect(http.get(url, headers: headers), hasStatus(403));
     });
 
-    test("allows access with no origin", () {
+    test('allows access with no origin', () {
       expect(http.get(url, headers: _handshakeHeaders), hasStatus(101));
     });
 
-    test("ignores the case of the client origin", () {
+    test('ignores the case of the client origin', () {
       var headers = _handshakeHeaders;
       headers['Origin'] = 'PuB.DaRtLaNg.OrG';
       expect(http.get(url, headers: headers), hasStatus(101));
     });
 
-    test("ignores the case of the server origin", () {
+    test('ignores the case of the server origin', () {
       var headers = _handshakeHeaders;
       headers['Origin'] = 'google.com';
       expect(http.get(url, headers: headers), hasStatus(101));
     });
   });
 
   // Regression test for issue 21894.
-  test("allows a Connection header with multiple values", () async {
+  test('allows a Connection header with multiple values', () async {
     var server = await shelf_io.serve(webSocketHandler((webSocket) {
       webSocket.sink.close();
-    }), "localhost", 0);
+    }), 'localhost', 0);
 
     var url = 'http://localhost:${server.port}/';
     var headers = _handshakeHeaders;
@@ -124,54 +124,54 @@ void main() {
         hasStatus(101));
   });
 
-  group("HTTP errors", () {
+  group('HTTP errors', () {
     var server;
     var url;
     setUp(() async {
       server = await shelf_io.serve(webSocketHandler((_) {
-        fail("should not create a WebSocket");
-      }), "localhost", 0);
+        fail('should not create a WebSocket');
+      }), 'localhost', 0);
       url = 'http://localhost:${server.port}/';
     });
 
     tearDown(() => server.close());
 
-    test("404s for non-GET requests", () {
+    test('404s for non-GET requests', () {
       expect(http.delete(url, headers: _handshakeHeaders), hasStatus(404));
     });
 
-    test("404s for non-Upgrade requests", () {
+    test('404s for non-Upgrade requests', () {
       var headers = _handshakeHeaders;
       headers.remove('Connection');
       expect(http.get(url, headers: headers), hasStatus(404));
     });
 
-    test("404s for non-websocket upgrade requests", () {
+    test('404s for non-websocket upgrade requests', () {
       var headers = _handshakeHeaders;
       headers['Upgrade'] = 'fblthp';
       expect(http.get(url, headers: headers), hasStatus(404));
     });
 
-    test("400s for a missing Sec-WebSocket-Version", () {
+    test('400s for a missing Sec-WebSocket-Version', () {
       var headers = _handshakeHeaders;
       headers.remove('Sec-WebSocket-Version');
       expect(http.get(url, headers: headers), hasStatus(400));
     });
 
-    test("404s for an unknown Sec-WebSocket-Version", () {
+    test('404s for an unknown Sec-WebSocket-Version', () {
       var headers = _handshakeHeaders;
       headers['Sec-WebSocket-Version'] = '15';
       expect(http.get(url, headers: headers), hasStatus(404));
     });
 
-    test("400s for a missing Sec-WebSocket-Key", () {
+    test('400s for a missing Sec-WebSocket-Key', () {
       var headers = _handshakeHeaders;
       headers.remove('Sec-WebSocket-Key');
       expect(http.get(url, headers: headers), hasStatus(400));
     });
   });
 
-  test("throws an error if a unary function is provided with protocols", () {
+  test('throws an error if a unary function is provided with protocols', () {
     expect(() => webSocketHandler((_) => null, protocols: ['foo']),
         throwsArgumentError);
   });
