Add more set-like version constraint operations.

lib/src/version_range.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_range;
 
 import 'version.dart';
 import 'version_constraint.dart';
+import 'version_union.dart';
 
 /// Constrains versions to a fall within a given range.
 ///
 /// If there is a minimum, then this only allows versions that are at that
 /// minimum or greater. If there is a maximum, then only versions less than
 /// that are allowed. In other words, this allows `>= min, < max`.
 class VersionRange implements VersionConstraint {
   /// The minimum end of the range.
   ///
   /// If [includeMin] is `true`, this will be the minimum allowed version.
@@ skipping 73 matching lines @@
           !max.isPreRelease && other.isPreRelease &&
           other.major == max.major && other.minor == max.minor &&
           other.patch == max.patch) {
         return false;
       }
     }
 
     return true;
   }
 
+  bool allowsAll(VersionConstraint other) {
+    if (other.isEmpty) return true;
+    if (other is Version) return allows(other);

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

All these type checks make me think it might be cleaner to use the visitor
pattern:

bool allowsAll(VersionConstraint other) => other.versionRangeAllowsAll(this);
bool allowsAny(VersionConstraint other) => other.versionRangeAllowsAny(this);

That would let you define specific methods for each pair of types. Thoughts?

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

That seems like a lot more conceptual overhead, and I don't think it's useful
for users to define those methods on VersionConstraint.

+
+    if (other is VersionUnion) {
+      return other.constraints.every((constraint) => allowsAll(constraint));
+    }
+
+    if (other is VersionRange) {
+      if (min != null) {
+        if (other.min == null) return false;
+        if (min > other.min) return false;
+        if (min == other.min && !includeMin && other.includeMin) return false;
+      }
+
+      if (max != null) {
+        if (other.max == null) return false;
+        if (max < other.max) return false;
+        if (max == other.max && !includeMax && other.includeMax) return false;
+      }
+
+      return true;
+    }
+
+    throw new ArgumentError('Unknown VersionConstraint type $other.');
+  }
+
+  bool allowsAny(VersionConstraint other) {
+    if (other.isEmpty) return false;
+    if (other is Version) return allows(other);
+
+    if (other is VersionUnion) {
+      return other.constraints.any((constraint) => allowsAny(constraint));
+    }
+
+    if (other is VersionRange) {
+      if (min == null || (other.min != null && min < other.min)) {
+        if (other.min == null) return true;

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

How about hoisting this out of the outer loop? It's a little hard to grok this
as it is. More like:

if (min == null && other.min == null) return true;
if (min == null || min < other.min) { ... }

Some comments would help too.

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

Done.

+        if (max == null) return true;
+        if (max > other.min) return true;
+        if (max < other.min) return false;
+        assert(max == other.min);
+        return includeMax && other.includeMin;
+      }
+
+      if (other.max == null) return true;
+      if (min < other.max) return true;
+      if (min > other.max) return false;
+      assert(min == other.max);
+      return includeMin && other.includeMax;
+    }
+
+    throw new ArgumentError('Unknown VersionConstraint type $other.');
+  }
+
   VersionConstraint intersect(VersionConstraint other) {
     if (other.isEmpty) return other;
+    if (other is VersionUnion) return other.intersect(this);
 
     // A range and a Version just yields the version if it's in the range.
     if (other is Version) {
       return allows(other) ? other : VersionConstraint.empty;
     }
 
     if (other is VersionRange) {
       // Intersect the two ranges.
       var intersectMin = min;
       var intersectIncludeMin = includeMin;
@@ skipping 41 matching lines @@
       }
 
       // If we got here, there is an actual range.
       return new VersionRange(min: intersectMin, max: intersectMax,
           includeMin: intersectIncludeMin, includeMax: intersectIncludeMax);
     }
 
     throw new ArgumentError('Unknown VersionConstraint type $other.');
   }
 
+  VersionConstraint union(VersionConstraint other) {
+    if (other is Version) {
+      if (allows(other)) return this;
+
+      if (other == min) {
+        return new VersionRange(
+            min: this.min, max: this.max,
+            includeMin: true, includeMax: this.includeMax);
+      }
+
+      if (other == max) {
+        return new VersionRange(
+            min: this.min, max: this.max,
+            includeMin: this.includeMin, includeMax: true);
+      }
+    }
+
+    if (other is VersionRange) {
+      // If the two ranges don't overlap, we won't be able to create a single
+      // VersionRange for both of them.
+      var edgesTouch = max == other.min && (includeMax || other.includeMin);

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

What about the other order:

other.max == min && (other.includeMax || includeMin);

?

Can you just use allowsAny(other) here?

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

Done.
Done.

+      if (max != null && other.min != null && max <= other.min && !edgesTouch) {
+        return new VersionConstraint.unionOf([this, other]);
+      }
+
+      var unionMin = min;
+      var unionIncludeMin = includeMin;
+      var unionMax = max;
+      var unionIncludeMax = includeMax;
+
+      if (unionMin == null) {
+        // Do nothing.
+      } else if (other.min == null || other.min < unionMin) {

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

I think it's a bit easier to read if you use "min" instead of "unionMin" here...

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

I was mirroring intersect(), but sure.

+        unionMin = other.min;
+        unionIncludeMin = other.includeMin;
+      } else if (unionMin == other.min && other.includeMin) {

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

...and here. That way the reader doesn't have to see if the assignments to
unionMin affect it.

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

Done.

+        // If the edges are the same but one is inclusive, make it inclusive.
+        unionIncludeMin = true;
+      }
+
+      if (unionMax == null) {
+        // Do nothing.
+      } else if (other.max == null || other.max > unionMax) {
+        unionMax = other.max;
+        unionIncludeMax = other.includeMax;
+      } else if (unionMax == other.max && other.includeMax) {
+        // If the edges are the same but one is inclusive, make it inclusive.
+        unionIncludeMax = true;
+      }
+
+      return new VersionRange(min: unionMin, max: unionMax,
+          includeMin: unionIncludeMin, includeMax: unionIncludeMax);
+    }
+
+    return new VersionConstraint.unionOf([this, other]);
+  }
+
   String toString() {
     var buffer = new StringBuffer();
 
     if (min != null) {
       buffer.write(includeMin ? '>=' : '>');
       buffer.write(min);
     }
 
     if (max != null) {
       if (min != null) buffer.write(' ');
       buffer.write(includeMax ? '<=' : '<');
       buffer.write(max);
     }
 
     if (min == null && max == null) buffer.write('any');
     return buffer.toString();
   }
 }