Add more set-like version constraint operations.

lib/src/version_constraint.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_constraint;
 
 import 'patterns.dart';
 import 'version.dart';
 import 'version_range.dart';
+import 'version_union.dart';
 
 /// A [VersionConstraint] is a predicate that can determine whether a given
 /// version is valid or not.
 ///
 /// For example, a ">= 2.0.0" constraint allows any version that is "2.0.0" or
 /// greater. Version objects themselves implement this to match a specific
 /// version.
 abstract class VersionConstraint {
   /// A [VersionConstraint] that allows all versions.
   static VersionConstraint any = new VersionRange();
@@ skipping 141 matching lines @@
   /// all versions.
   factory VersionConstraint.intersection(
       Iterable<VersionConstraint> constraints) {
     var constraint = new VersionRange();
     for (var other in constraints) {
       constraint = constraint.intersect(other);
     }
     return constraint;
   }
 
+  /// Creates a new version constraint that is the union of [constraints].
+  ///
+  /// It allows any versions that any of those constraints allows. If
+  /// [constraints] is empty, this returns a constraint that allows no versions.
+  factory VersionConstraint.unionOf(
+          Iterable<VersionConstraint> constraints) =>
+      VersionUnion.create(constraints);
+
   /// 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);
 
+  /// Returns `true` if this constraint allows all the versions that [other]
+  /// allows.
+  bool allowsAll(VersionConstraint other);
+
+  /// Returns `true` if this constraint allows any of the versions that [other]
+  /// allows.
+  bool allowsAny(VersionConstraint other);
+
   /// Creates a new [VersionConstraint] that only allows [Version]s allowed by
   /// both this and [other].
   VersionConstraint intersect(VersionConstraint other);
+
+  /// Creates a new [VersionConstraint] that allows [Versions]s allowed by
+  /// either this or [other].
+  VersionConstraint union(VersionConstraint other);
 }
 
 class _EmptyVersion implements VersionConstraint {
   const _EmptyVersion();
 
   bool get isEmpty => true;
   bool get isAny => false;
   bool allows(Version other) => false;
+  bool allowsAll(Version other) => other.isEmpty;
+  bool allowsAny(Version other) => false;
   VersionConstraint intersect(VersionConstraint other) => this;
+  VersionConstraint union(VersionConstraint other) => other;
   String toString() => '<empty>';
 }
 
 class _CompatibleWithVersionRange extends VersionRange {
   _CompatibleWithVersionRange(Version version) : super(
       min: version, includeMin: true,
       max: version.nextBreaking, includeMax: false);
 
   String toString() => '^$min';
 }