Make the oauth2 lib handle OAuth2 401 errors.

pkg/oauth2/lib/src/utils.dart

Index: pkg/oauth2/lib/src/utils.dart
diff --git a/pkg/oauth2/lib/src/utils.dart b/pkg/oauth2/lib/src/utils.dart
index 583a5bc4438ecea546e41cb8b833b235448676de..122e74f3fcfdcd0886bb71007876d950c35ed16d 100644
--- a/pkg/oauth2/lib/src/utils.dart
+++ b/pkg/oauth2/lib/src/utils.dart
@@ -65,6 +65,62 @@ List<String> split1(String toSplit, String pattern) {
       toSplit.substring(index + pattern.length)];
 }
 
+/** A pair of values. */

[Bob Nystrom, 2012/12/04 01:41:48]

If you're creating this type anyway, how about just creating a more specific and
 semantic AuthenticateHeader class?

[nweiz, 2012/12/04 01:51:35]

Why would I create a specific type when I could make a more general one? I think
there's a lot of benefit to it being available for use in case anything else
internal needs to use it, and in being copy-paste identical with the version in
pub (well, given that it's not in the core libraries). This also makes the
pairOf function in utils_test nicer than it would be otherwise.

[Bob Nystrom, 2012/12/04 01:59:42]

Why make types at all: They help clarify intent and semantics. Especially where
the result of parseAuthenticateHeader is being used, there's no nearby type
annotation to help understand what kind of object it's returning.
I'm sympathetic here. If Dart actually had tuples, I'd be in favor of using
them. But it doesn't, and the prevailing style seems to be pretty... nominal. In
this case, using a pair doesn't save you anything because you still have to
define the pair class. Given that, I'd rather see it have a name and nicely
named fields.

Actually, even better would be to move parseAuthenticateHeader into it as a
constructor:

class AuthenticateHeader {
  final String scheme;
  final Map<> fields;

  factory AuthenticateHeader.parse() { ... }
}

WDYT?

[nweiz, 2012/12/04 21:39:26]

Done. I'm still not convinced this is better, but I don't think it much either
way.

+class Pair<E, F> {
+  E first;
+  F last;
+
+  Pair(this.first, this.last);
+
+  String toString() => '($first, $last)';
+
+  bool operator==(other) {
+    if (other is! Pair) return false;
+    return other.first == first && other.last == last;
+  }
+}
+
+/// Parses a WWW-Authenticate header value, as per [RFC 2617][]. This returns a
+/// pair where the first value is the authentication scheme, and the second is a
+/// map of parameters.
+///
+/// Throws a [FormatException] if the header has invalid formatting.
+///
+/// [RFC 2617]: http://tools.ietf.org/html/rfc2617
+Pair<String, Map<String, String>> parseAuthenticateHeader(String header) {
+  var split = split1(header, ' ');
+  if (split.length == 0) {
+    throw new FormatException('Invalid WWW-Authenticate header: "$header"');
+  } else if (split.length == 1 || split[1].trim().isEmpty) {
+    return new Pair(split[0].toLowerCase(), {});
+  }
+  var scheme = split[0].toLowerCase();
+  var paramString = split[1];
+
+  // From http://www.w3.org/Protocols/rfc2616/rfc2616-sec2.html.
+  var tokenChar = r'[^\0-\x1F()<>@,;:\\"/\[\]?={} \t\x7F]';
+  var quotedStringChar = r'(?:[^\0-\x1F\x7F"]|\\.)';
+  var regexp = new RegExp('^ *($tokenChar+)="($quotedStringChar*)" *(, *)?');
+
+  var params = {};
+  var match;
+  do {
+    match = regexp.firstMatch(paramString);

[Bob Nystrom, 2012/12/04 01:41:48]

Can you use allMatches() here?

[nweiz, 2012/12/04 01:51:35]

No. I need to enforce that each match follows directly after the one before it,
and that the first one starts at the beginning of the string.

[Bob Nystrom, 2012/12/04 01:59:42]

OK, that's what I figured. Just checking.

+    if (match == null) {
+      throw new FormatException('Invalid WWW-Authenticate header: "$header"');
+    }
+
+    paramString = paramString.substring(match.end);
+    params[match.group(1).toLowerCase()] = match.group(2);
+  } while (match.group(3) != null);
+
+  if (!paramString.trim().isEmpty) {
+    throw new FormatException('Invalid WWW-Authenticate header: "$header"');
+  }
+
+  return new Pair<String, Map<String, String>>(scheme, params);
+}
+
 /// Returns a [Future] that asynchronously completes to `null`.
 Future get async {
   var completer = new Completer();