Add support for showing latest dev/stable versions

app/lib/handlers.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 pub_dartlang_org.handlers;
 
 import 'dart:async';
 import 'dart:math';
 import 'dart:convert';
 
@@ skipping 210 matching lines @@
     if (responseAsJson) {
       return packageShowHandlerJson(request, Uri.decodeComponent(path));
     } else {
       return packageShowHandlerHtml(request, Uri.decodeComponent(path));
     }
   }
 
   var package = Uri.decodeComponent(path.substring(0, slash));
   if (path.substring(slash).startsWith('/versions')) {
     path = path.substring(slash + '/versions'.length);
-    if (path.startsWith('/') && path.endsWith('.yaml')) {
-      path = path.substring(1, path.length - '.yaml'.length);
-      String version = Uri.decodeComponent(path);
-      return packageVersionHandlerYaml(request, package, version);
+    if (path.startsWith('/')) {
+      if (path.endsWith('.yaml')) {
+        path = path.substring(1, path.length - '.yaml'.length);
+        String version = Uri.decodeComponent(path);
+        return packageVersionHandlerYaml(request, package, version);
+      } else {
+        path = path.substring(1);
+        String version = Uri.decodeComponent(path);
+        return packageVersionHandlerHtml(request, package, version);
+      }
     } else {
       return packageVersionsHandler(request, package);
     }
   }
   return _notFoundHandler(request);
 }
 
 /// Handles requests for /packages/<package> - JSON
 packageShowHandlerJson(shelf.Request request, String packageName) async {
   Package package = await backend.lookupPackage(packageName);
   if (package == null) return _notFoundHandler(request);
 
   var versions = await backend.versionsOfPackage(packageName);
   _sortVersionsDesc(versions, decreasing: false);
 
   var json = {
     'name' : package.name,
     'uploaders': package.uploaderEmails,
     'versions':
         versions.map((packageVersion) => packageVersion.version).toList(),
   };
   return _jsonResponse(json);
 }
 
 /// Handles requests for /packages/<package> - HTML
 packageShowHandlerHtml(shelf.Request request, String packageName) async {
+  return packageVersionHandlerHtml(request, packageName, null);
+}
+
+/// Handles requests for /packages/<package>/versions
+packageVersionsHandler(shelf.Request request, String packageName) async {
+  var versions = await backend.versionsOfPackage(packageName);
+  if (versions.isEmpty) return _notFoundHandler(request);
+
+  _sortVersionsDesc(versions);
+
+  var versionDownloadUrls =  await Future.wait(
+      versions.map((PackageVersion version) {
+    return backend.downloadUrl(packageName, version.version);
+  }).toList());
+
+  return _htmlResponse(templateService.renderPkgVersionsPage(
+      packageName, versions, versionDownloadUrls));
+}
+
+/// Handles requests for /packages/<package>/versions/<version>
+packageVersionHandlerHtml(request,
+                          String packageName,
+                          String versionName) async {
   String cachedPage;
   if (backend.uiPackageCache != null) {
-    cachedPage = await backend.uiPackageCache.getUIPackagePage(packageName);
+    cachedPage = await backend.uiPackageCache.getUIPackagePage(
+        packageName, versionName);
   }
 
   if (cachedPage == null) {
     Package package = await backend.lookupPackage(packageName);
     if (package == null) return _notFoundHandler(request);
 
     var versions = await backend.versionsOfPackage(packageName);
-    _sortVersionsDesc(versions);
 
-    var latestVersion = versions.where(
-        (version) => version.key == package.latestVersionKey).first;
+    _sortVersionsDesc(versions, decreasing: true, pubSorting: true);
+    var latestStable = versions[0];
+    var first10Versions = versions.take(10).toList();
 
-    var first10Versions = versions.take(10).toList();
+    _sortVersionsDesc(versions, decreasing: true, pubSorting: false);
+    var latestDev = versions[0];
+
+    var selectedVersion;
+    if (versionName != null) {
+      for (var v in versions) {
+        if (v.version == versionName) selectedVersion = v;
+      }
+      // TODO: cache error?
+      if (selectedVersion == null) {
+        return _notFoundHandler(request);
+      }
+    } else {
+      if (selectedVersion == null) {
+        selectedVersion = latestStable;
+      }
+    }
 
     var versionDownloadUrls = await Future.wait(
         first10Versions.map((PackageVersion version) {
           return backend.downloadUrl(packageName, version.version);
         }).toList());
 
     cachedPage = templateService.renderPkgShowPage(
-        package, first10Versions, versionDownloadUrls, latestVersion,
-        versions.length);
+        package, first10Versions, versionDownloadUrls, selectedVersion,
+        latestStable, latestDev, versions.length);
     if (backend.uiPackageCache != null) {
-      await backend.uiPackageCache.setUIPackagePage(packageName, cachedPage);
+      await backend.uiPackageCache.setUIPackagePage(
+          packageName, versionName, cachedPage);
     }
   }
 
   return _htmlResponse(cachedPage);
 }
 
-/// Handles requests for /packages/<package>/versions
-packageVersionsHandler(shelf.Request request, String packageName) async {
-  var versions = await backend.versionsOfPackage(packageName);
-  if (versions.isEmpty) return _notFoundHandler(request);
-
-  _sortVersionsDesc(versions);
-
-  var versionDownloadUrls =  await Future.wait(
-      versions.map((PackageVersion version) {
-    return backend.downloadUrl(packageName, version.version);
-  }).toList());
-
-  return _htmlResponse(templateService.renderPkgVersionsPage(
-      packageName, versions, versionDownloadUrls));
-}
-
 /// Handles requests for /packages/<package>/versions/<version>.yaml
 packageVersionHandlerYaml(request, String package, String version) async {
   var packageVersion = await backend.lookupPackageVersion(package, version);
   if (packageVersion == null) {
     return _notFoundHandler(request);
   } else {
     return _yamlResponse(packageVersion.pubspec.jsonString);
   }
 }
 
@@ skipping 112 matching lines @@
       body: content,
       headers: {'content-type' : 'application/atom+xml; charset="utf-8"'});
 }
 
 shelf.Response _redirectResponse(url) {
   return new shelf.Response.seeOther(url);
 }
 
 
 /// Sorts [versions] according to the semantic versioning specification.
-void _sortVersionsDesc(List<PackageVersion> versions, {bool decreasing: true}) {
+///
+/// If [pubSorting] is `true` then pub's priorization ordering is used, which
+/// will rang pre-release versions lower than stable versions (e.g. it will
+/// order "0.9.0-dev.1 < 0.8.0").  Otherwise it will use semantic version
+/// sorting (e.g. it will order "0.8.0 < 0.9.0-dev.1").
+void _sortVersionsDesc(List<PackageVersion> versions,
+                       {bool decreasing: true, bool pubSorting: true}) {
   versions.sort((PackageVersion a, PackageVersion b) {
-    if (decreasing) {
-      return semver.Version.prioritize(b.semanticVersion, a.semanticVersion);
+    if (pubSorting) {
+      if (decreasing) {
+        return semver.Version.prioritize(b.semanticVersion, a.semanticVersion);
+      } else {
+        return semver.Version.prioritize(a.semanticVersion, b.semanticVersion);
+      }
     } else {
-      return semver.Version.prioritize(a.semanticVersion, b.semanticVersion);
+      if (decreasing) {
+        return b.semanticVersion.compareTo(a.semanticVersion);
+      } else {
+        return a.semanticVersion.compareTo(b.semanticVersion);
+      }
     }
   });
 }
 
 
 /// Extracts the 'page' query parameter from [url].
 ///
 /// Returns a valid positive integer. If [maxPages] is given, the result is
 /// clamped to [maxPages].
 int _pageFromUrl(Uri url, {int maxPages}) {
   var pageAsString = url.queryParameters['page'];
   int pageAsInt = 1;
   if (pageAsString != null) {
     try {
       pageAsInt = max(int.parse(pageAsString), 1);
     } catch (_, __) { }
   }
 
   if (maxPages != null && pageAsInt > maxPages) pageAsInt = maxPages;
   return pageAsInt;
 }