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 'package:collection/equality.dart';
 
@@ skipping 219 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;

[Bob Nystrom, 2015/05/05 20:49:09]

What about:

var v123 = new Version.parse("1.2.3");
v123.allowsAll(new VersionRange(min: v123, max: v123, includeMin: true,
includeMax: true);

[nweiz, 2015/05/05 22:52:33]

In general, we don't handle VersionRanges that look like Versions—otherwise they
would be "=="-equivalent. If we do handle them, we should make sure they're
equivalent in every way, but I don't see an especially clean way of doing so.
Since you can't naturally end up with such a version range, I'm not too worried
about it.

 
-    // 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;
@@ skipping 40 matching lines @@
           // Compare two strings.
           return aPart.compareTo(bPart);
         }
       }
     }
 
     // The lists are entirely equal.
     return 0;
   }
 }