Add more set-like version constraint operations.

lib/src/version.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_semver.src.version;
 
-import 'dart:math';
+import 'dart:math' as math;
 
 import 'package:collection/equality.dart';
 
 import 'patterns.dart';
 import 'version_constraint.dart';
 import 'version_range.dart';
 
 /// The equality operator to use for comparing version components.
 final _equality = const IterableEquality();
 
 /// A parsed semantic version number.
-class Version implements Comparable<Version>, VersionConstraint {
+class Version implements Comparable<Version>, VersionConstraint, VersionRange {
   /// No released version: i.e. "0.0.0".
   static Version get none => new Version(0, 0, 0);
 
   /// Compares [a] and [b] to see which takes priority over the other.
   ///
   /// Returns `1` if [a] takes priority over [b] and `-1` if vice versa. If
   /// [a] and [b] are equivalent, returns `0`.
   ///
   /// Unlike [compareTo], which *orders* versions, this determines which
   /// version a user is likely to prefer. In particular, it prioritizes
@@ skipping 48 matching lines @@
   /// string or a non-negative integer. It may also be empty, indicating that
   /// this version has no build identifier.
   final List build;
 
   /// The original string representation of the version number.
   ///
   /// This preserves textual artifacts like leading zeros that may be left out
   /// of the parsed version.
   final String _text;
 
+  Version get min => this;
+  Version get max => this;
+  bool get includeMin => true;
+  bool get includeMax => true;
+
   Version._(this.major, this.minor, this.patch, String preRelease, String build,
             this._text)
       : preRelease = preRelease == null ? [] : _splitParts(preRelease),
         build = build == null ? [] : _splitParts(build) {
     if (major < 0) throw new ArgumentError(
         'Major version must be non-negative.');
     if (minor < 0) throw new ArgumentError(
         'Minor version must be non-negative.');
     if (patch < 0) throw new ArgumentError(
         'Patch version must be non-negative.');
@@ skipping 132 matching lines @@
     return _incrementMajor();
   }
 
   Version _incrementMajor() => new Version(major + 1, 0, 0);
   Version _incrementMinor() => new Version(major, minor + 1, 0);
   Version _incrementPatch() => new Version(major, minor, patch + 1);
 
   /// Tests if [other] matches this version exactly.
   bool allows(Version other) => this == other;
 
-  VersionConstraint intersect(VersionConstraint other) {
-    if (other.isEmpty) return other;
+  bool allowsAll(VersionConstraint other) => other.isEmpty || other == this;
 
-    // Intersect a version and a range.
-    if (other is VersionRange) return other.intersect(this);
+  bool allowsAny(VersionConstraint other) => other.allows(this);
 
-    // Intersecting two versions only works if they are the same.
-    if (other is Version) {
-      return this == other ? this : VersionConstraint.empty;
+  VersionConstraint intersect(VersionConstraint other) =>
+      other.allows(this) ? this : VersionConstraint.empty;
+
+  VersionConstraint union(VersionConstraint other) {
+    if (other.allows(this)) return other;
+
+    if (other is VersionRange) {
+      if (other.min == this) {
+        return new VersionRange(
+            min: other.min, max: other.max,
+            includeMin: true, includeMax: other.includeMax);
+      }
+
+      if (other.max == this) {
+        return new VersionRange(
+            min: other.min, max: other.max,
+            includeMin: other.includeMin, includeMax: true);
+      }
     }
 
-    throw new ArgumentError(
-        'Unknown VersionConstraint type $other.');
+    return new VersionConstraint.unionOf([this, other]);
   }
 
   int compareTo(Version other) {
     if (major != other.major) return major.compareTo(other.major);
     if (minor != other.minor) return minor.compareTo(other.minor);
     if (patch != other.patch) return patch.compareTo(other.patch);
 
     // Pre-releases always come before no pre-release string.
     if (!isPreRelease && other.isPreRelease) return 1;
     if (!other.isPreRelease && isPreRelease) return -1;
 
     var comparison = _compareLists(preRelease, other.preRelease);
     if (comparison != 0) return comparison;
 
     // Builds always come after no build string.
     if (build.isEmpty && other.build.isNotEmpty) return -1;
     if (other.build.isEmpty && build.isNotEmpty) return 1;
     return _compareLists(build, other.build);
   }
 
   String toString() => _text;
 
   /// Compares a dot-separated component of two versions.
   ///
   /// This is used for the pre-release and build version parts. This follows
   /// Rule 12 of the Semantic Versioning spec (v2.0.0-rc.1).
   int _compareLists(List a, List b) {
-    for (var i = 0; i < max(a.length, b.length); i++) {
+    for (var i = 0; i < math.max(a.length, b.length); i++) {
       var aPart = (i < a.length) ? a[i] : null;
       var bPart = (i < b.length) ? b[i] : null;
 
       if (aPart == bPart) continue;
 
       // Missing parts come before present ones.
       if (aPart == null) return -1;
       if (bPart == null) return 1;
 
       if (aPart is num) {
@@ skipping 12 matching lines @@
           // Compare two strings.
           return aPart.compareTo(bPart);
         }
       }
     }
 
     // The lists are entirely equal.
     return 0;
   }
 }