Add a validator for dependency version constraints.

utils/pub/version.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Handles version numbers, following the [Semantic Versioning][semver] spec.
  *
  * [semver]: http://semver.org/
  */
 library version;
@@ skipping 56 matching lines @@
 
       String preRelease = match[5];
       String build = match[8];
 
       return new Version(major, minor, patch, pre: preRelease, build: build);
     } on FormatException catch (ex) {
       throw new FormatException('Could not parse "$text".');
     }
   }
 
+  /// Returns the primary version out of a list of candidates. This is the
+  /// highest-numbered stable (non-prerelease) version. If there are no stable
+  /// versions, it's just the highest-numbered version.
+  static Version primary(List<Version> versions) {
+    var primary;
+    for (var version in versions) {
+      if (primary == null || (!version.isPreRelease && primary.isPreRelease) ||
+          (version.isPreRelease == primary.isPreRelease && version > primary)) {
+        primary = version;
+      }
+    }
+    return primary;
+  }
+
   bool operator ==(other) {
     if (other is! Version) return false;
     return compareTo(other) == 0;
   }
 
   bool operator <(Version other) => compareTo(other) < 0;
   bool operator >(Version other) => compareTo(other) > 0;
   bool operator <=(Version other) => compareTo(other) <= 0;
   bool operator >=(Version other) => compareTo(other) >= 0;
 
+  bool get isAny => false;
   bool get isEmpty => false;
 
+  /// Whether or not this is a pre-release version.
+  bool get isPreRelease => preRelease != null;
+
   /** Tests if [other] matches this version exactly. */
   bool allows(Version other) => this == other;
 
   VersionConstraint intersect(VersionConstraint other) {
     if (other.isEmpty) return other;
 
     // Intersect a version and a range.
     if (other is VersionRange) return other.intersect(this);
 
     // Intersecting two versions only works if they are the same.
@@ skipping 146 matching lines @@
       constraint = constraint.intersect(other);
     }
     return constraint;
   }
 
   /**
    * Returns `true` if this constraint allows no versions.
    */
   bool get isEmpty;
 
+  /// Returns `true` if this constraint allows all versions.
+  bool get isAny;
+
   /**
    * Returns `true` if this constraint allows [version].
    */
   bool allows(Version version);
 
   /**
    * Creates a new [VersionConstraint] that only allows [Version]s allowed by
    * both this and [other].
    */
   VersionConstraint intersect(VersionConstraint other);
@@ skipping 49 matching lines @@
     if (other is! VersionRange) return false;
 
     return min == other.min &&
            max == other.max &&
            includeMin == other.includeMin &&
            includeMax == other.includeMax;
   }
 
   bool get isEmpty => false;
 
+  bool get isAny => !includeMin && !includeMax;
+
   /** Tests if [other] matches falls within this version range. */
   bool allows(Version other) {
     if (min != null && other < min) return false;
     if (min != null && !includeMin && other == min) return false;
     if (max != null && other > max) return false;
     if (max != null && !includeMax && other == max) return false;
     return true;
   }
 
   VersionConstraint intersect(VersionConstraint other) {
@@ skipping 74 matching lines @@
 
     if (min == null && max == null) buffer.add('any');
     return buffer.toString();
   }
 }
 
 class _EmptyVersion implements VersionConstraint {
   const _EmptyVersion();
 
   bool get isEmpty => true;
+  bool get isAny => false;
   bool allows(Version other) => false;
   VersionConstraint intersect(VersionConstraint other) => this;
   String toString() => '<empty>';
 }