Add support for showing latest dev/stable versions

app/lib/package_memcache.dart

 // Copyright (c) 2015, 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 pub_dartlang_org.package_memcache;
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:logging/logging.dart';
 import 'package:memcache/memcache.dart';
 import 'package:pub_server/shelf_pubserver.dart';
 
 final Logger _logger = new Logger('pub.package_memcache');
 
 abstract class UIPackageCache {
-  Future<String> getUIPackagePage(String package);
+  // If [version] is `null` then it corresponds to the cache entry which can be
+  // invalidated via [invalidateUiPackagePage].
+  Future<String> getUIPackagePage(String package, String version);
 
-  Future setUIPackagePage(String package, String data);
+  // If [version] is `null` then it corresponds to the cache entry which can be
+  // invalidated via [invalidateUiPackagePage].
+  Future setUIPackagePage(String package, String version, String data);
 
   Future invalidateUIPackagePage(String package);
 }
 
 /// Uses a [Memache] to set/get/invalidate metadata for packages.
 class AppEnginePackageMemcache implements PackageCache, UIPackageCache {
   static const Duration EXPIRATION = const Duration(minutes: 60);
   static const String KEY_PREFIX = 'dart_package_json';
   static const String UI_KEY_PREFIX = 'dart_package_ui';
 
@@ skipping 16 matching lines @@
 
     return result;
   }
 
   Future setPackageData(String package, List<int> data) {
     _logger.info('memcache["$package"] setting to new data');
     return _ignoreErrors(
         memcache.set(_packageKey(package), data, expiration: EXPIRATION));
   }
 
-  Future<String> getUIPackagePage(String package) async {
+  Future<String> getUIPackagePage(String package, String version) async {
     var result = await _ignoreErrors(
-        memcache.get(_packageUIKey(package), asBinary: true));
+        memcache.get(_packageUIKey(package, version), asBinary: true));
 
     if (result != null) {
       _logger.info('memcache["$package"] rendered UI found');
       return UTF8.decode(result);
     }
 
     _logger.info('memcache["$package"] rendered UI not found');
     return null;
   }
 
-  Future setUIPackagePage(String package, String data) async {
+  Future setUIPackagePage(String package, String version, String data) async {
     _logger.info('memcache["$package"] setting to new rendered UI data');
     return _ignoreErrors(
-        memcache.set(_packageUIKey(package),
+        memcache.set(_packageUIKey(package, version),
         UTF8.encode(data),
         expiration: EXPIRATION));
   }
 
   Future invalidateUIPackagePage(String package) async {
     _logger.info('memcache["$package"] invalidating UI data');
-    return _ignoreErrors(memcache.remove(_packageUIKey(package)));
+    return _ignoreErrors(memcache.remove(_packageUIKey(package, null)));
   }
 
   Future invalidatePackageData(String package) {
     _logger.info('memcache["$package"] invalidate entry');
     return _ignoreErrors(Future.wait([
         // TODO: Once the Python version is retired, we can remove this.
         memcache.remove('package_json_$package'),
         memcache.remove(_packageKey(package)),
-        memcache.remove(_packageUIKey(package)),
+        memcache.remove(_packageUIKey(package, null)),
     ]));
   }
 
   String _packageKey(String package) => '$keyPrefix$package';
 
-  String _packageUIKey(String package) => '$uiKeyPrefix$package';
+  String _packageUIKey(String package, String version) {
+    if (version == null) return '$uiKeyPrefix$package';
+    return '$uiKeyPrefix$package**$version';
+  }
 
   // We are ignoring any memcache errors and just return `null` in this case.
   //
   // NOTE: The worst what can happen is that up to `EXPIRATION` time passes
   // before a value gets automatically evicted from memcache
   //    => The duration for inconsistency is limited to 60 minutes ATM.
   Future _ignoreErrors(Future f) {
     return f.catchError((error, stackTrace) {
       _logger.warning(
           'Ignoring failed memcache API call (error: $error)',
           error, stackTrace);
     });
   }
 }