From 340c972dd0e286892210e4c84bd81c463b371f10 Mon Sep 17 00:00:00 2001 From: Bob Nystrom Date: Thu, 25 Sep 2014 11:28:42 -0700 Subject: [PATCH 001/115] Initial commit! --- pkgs/pub_semver/LICENSE | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 pkgs/pub_semver/LICENSE diff --git a/pkgs/pub_semver/LICENSE b/pkgs/pub_semver/LICENSE new file mode 100644 index 0000000000..5c60afea39 --- /dev/null +++ b/pkgs/pub_semver/LICENSE @@ -0,0 +1,26 @@ +Copyright 2014, the Dart project authors. All rights reserved. +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google Inc. nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. From 56cc24edf25aaab06df40f8bff25fb17cba5aa4f Mon Sep 17 00:00:00 2001 From: Bob Nystrom Date: Fri, 26 Sep 2014 12:54:39 -0700 Subject: [PATCH 002/115] Harvest from pub. Mostly a straight copy, except: - Reorganized into smaller libraries. - Added tests for prioritize() and antiprioritize(). - Filled in a few doc comments. R=nweiz@google.com Review URL: https://chromiumcodereview.appspot.com//607663002 --- pkgs/pub_semver/.gitignore | 5 + pkgs/pub_semver/CHANGELOG.md | 3 + pkgs/pub_semver/README.md | 77 +++++ pkgs/pub_semver/lib/pub_semver.dart | 9 + pkgs/pub_semver/lib/src/patterns.dart | 19 ++ pkgs/pub_semver/lib/src/version.dart | 295 ++++++++++++++++++ .../lib/src/version_constraint.dart | 151 +++++++++ pkgs/pub_semver/lib/src/version_range.dart | 179 +++++++++++ pkgs/pub_semver/pubspec.yaml | 13 + pkgs/pub_semver/test/test_all.dart | 17 + pkgs/pub_semver/test/utils.dart | 96 ++++++ .../test/version_constraint_test.dart | 143 +++++++++ pkgs/pub_semver/test/version_range_test.dart | 202 ++++++++++++ pkgs/pub_semver/test/version_test.dart | 248 +++++++++++++++ 14 files changed, 1457 insertions(+) create mode 100644 pkgs/pub_semver/.gitignore create mode 100644 pkgs/pub_semver/CHANGELOG.md create mode 100644 pkgs/pub_semver/README.md create mode 100644 pkgs/pub_semver/lib/pub_semver.dart create mode 100644 pkgs/pub_semver/lib/src/patterns.dart create mode 100644 pkgs/pub_semver/lib/src/version.dart create mode 100644 pkgs/pub_semver/lib/src/version_constraint.dart create mode 100644 pkgs/pub_semver/lib/src/version_range.dart create mode 100644 pkgs/pub_semver/pubspec.yaml create mode 100644 pkgs/pub_semver/test/test_all.dart create mode 100644 pkgs/pub_semver/test/utils.dart create mode 100644 pkgs/pub_semver/test/version_constraint_test.dart create mode 100644 pkgs/pub_semver/test/version_range_test.dart create mode 100644 pkgs/pub_semver/test/version_test.dart diff --git a/pkgs/pub_semver/.gitignore b/pkgs/pub_semver/.gitignore new file mode 100644 index 0000000000..7178642c22 --- /dev/null +++ b/pkgs/pub_semver/.gitignore @@ -0,0 +1,5 @@ +packages +pubspec.lock + +# IntelliJ project. +.idea diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md new file mode 100644 index 0000000000..bf0e1f93f4 --- /dev/null +++ b/pkgs/pub_semver/CHANGELOG.md @@ -0,0 +1,3 @@ +# 1.0.0 + +* Initial release. diff --git a/pkgs/pub_semver/README.md b/pkgs/pub_semver/README.md new file mode 100644 index 0000000000..1cb1527911 --- /dev/null +++ b/pkgs/pub_semver/README.md @@ -0,0 +1,77 @@ +Handles version numbers and version constraints in the same way that [pub][] +does. The semantics here very closely follow the [Semantic Versioning][semver] +spec. It differs from semver in a few corner cases: + + * **Version ordering does take build suffixes into account.** This is unlike + semver 2.0.0 but like earlier versions of semver. Version `1.2.3+1` is + considered a lower number than `1.2.3+2`. + + Since a package may have published multiple versions that differ only by + build suffix, pub still has to pick one of them *somehow*. Semver leaves + that issue unresolved, so we just say that build numbers are sorted like + pre-release suffixes. + + * **Pre-release versions are excluded from most max ranges.** Let's say a + user is depending on "foo" with constraint `>=1.0.0 <2.0.0` and that "foo" + has published these versions: + + * `1.0.0` + * `1.1.0` + * `1.2.0` + * `2.0.0-alpha` + * `2.0.0-beta` + * `2.0.0` + * `2.1.0` + + Versions `2.0.0` and `2.1.0` are excluded by the constraint since neither + matches `<2.0.0`. However, since semver specifies that pre-release versions + are lower than the non-prerelease version (i.e. `2.0.0-beta < 2.0.0`, then + the `<2.0.0` constraint does technically allow those. + + But that's almost never what the user wants. If their package doesn't work + with foo `2.0.0`, it's certainly not likely to work with experimental, + unstable versions of `2.0.0`'s API, which is what pre-release versions + represent. + + To handle that, `<` version ranges to not allow pre-release versions of the + maximum unless the max is itself a pre-release. In other words, a `<2.0.0` + constraint will prohibit not just `2.0.0` but any pre-release of `2.0.0`. + However, `<2.0.0-beta` will exclude `2.0.0-beta` but allow `2.0.0-alpha`. + + * **Pre-release versions are avoided when possible.** The above case + handles pre-release versions at the top of the range, but what about in + the middle? What if "foo" has these versions: + + * `1.0.0` + * `1.2.0-alpha` + * `1.2.0` + * `1.3.0-experimental` + + When a number of versions are valid, pub chooses the best one where "best" + usually means "highest numbered". That follows the user's intuition that, + all else being equal, they want the latest and greatest. Here, that would + mean `1.3.0-experimental`. However, most users don't want to use unstable + versions of their dependencies. + + We want pre-releases to be explicitly opt-in so that package consumers + don't get unpleasant surprises and so that package maintainers are free to + put out pre-releases and get feedback without dragging all of their users + onto the bleeding edge. + + To accommodate that, when pub is choosing a version, it uses *priority* + order which is different from strict comparison ordering. Any stable + version is considered higher priority than any unstable version. The above + versions, in priority order, are: + + * `1.2.0-alpha` + * `1.3.0-experimental` + * `1.0.0` + * `1.2.0` + + This ensures that users only end up with an unstable version when there are + no alternatives. Usually this means they've picked a constraint that + specifically selects that unstable version -- they've deliberately opted + into it. + +[pub]: http://pub.dartlang.org/ +[semver]: http://semver.org/ diff --git a/pkgs/pub_semver/lib/pub_semver.dart b/pkgs/pub_semver/lib/pub_semver.dart new file mode 100644 index 0000000000..436e226005 --- /dev/null +++ b/pkgs/pub_semver/lib/pub_semver.dart @@ -0,0 +1,9 @@ +// 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; + +export 'src/version.dart'; +export 'src/version_constraint.dart'; +export 'src/version_range.dart'; diff --git a/pkgs/pub_semver/lib/src/patterns.dart b/pkgs/pub_semver/lib/src/patterns.dart new file mode 100644 index 0000000000..4a2261815c --- /dev/null +++ b/pkgs/pub_semver/lib/src/patterns.dart @@ -0,0 +1,19 @@ +// 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.patterns; + +/// Regex that matches a version number at the beginning of a string. +final START_VERSION = new RegExp( + r'^' // Start at beginning. + r'(\d+).(\d+).(\d+)' // Version number. + r'(-([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?' // Pre-release. + r'(\+([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?'); // Build. + +/// Like [START_VERSION] but matches the entire string. +final COMPLETE_VERSION = new RegExp(START_VERSION.pattern + r'$'); + +/// Parses a comparison operator ("<", ">", "<=", or ">=") at the beginning of +/// a string. +final START_COMPARISON = new RegExp(r"^[<>]=?"); diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart new file mode 100644 index 0000000000..866d89c301 --- /dev/null +++ b/pkgs/pub_semver/lib/src/version.dart @@ -0,0 +1,295 @@ +// 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'; + +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, VersionConstraint { + /// 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 + /// pre-release versions lower than stable versions, regardless of their + /// version numbers. Pub uses this when determining which version to prefer + /// when a number of versions are allowed. In that case, it will always + /// choose a stable version when possible. + /// + /// When used to sort a list, orders in ascending priority so that the + /// highest priority version is *last* in the result. + static int prioritize(Version a, Version b) { + // Sort all prerelease versions after all normal versions. This way + // the solver will prefer stable packages over unstable ones. + if (a.isPreRelease && !b.isPreRelease) return -1; + if (!a.isPreRelease && b.isPreRelease) return 1; + + return a.compareTo(b); + } + + /// Like [proiritize], but lower version numbers are considered greater than + /// higher version numbers. + /// + /// This still considers prerelease versions to be lower than non-prerelease + /// versions. Pub uses this when downgrading -- it chooses the lowest version + /// but still excludes pre-release versions when possible. + static int antiprioritize(Version a, Version b) { + if (a.isPreRelease && !b.isPreRelease) return -1; + if (!a.isPreRelease && b.isPreRelease) return 1; + + return b.compareTo(a); + } + + /// The major version number: "1" in "1.2.3". + final int major; + + /// The minor version number: "2" in "1.2.3". + final int minor; + + /// The patch version number: "3" in "1.2.3". + final int patch; + + /// The pre-release identifier: "foo" in "1.2.3-foo". + /// + /// This is split into a list of components, each of which may be either a + /// string or a non-negative integer. It may also be empty, indicating that + /// this version has no pre-release identifier. + final List preRelease; + + /// The build identifier: "foo" in "1.2.3+foo". + /// + /// This is split into a list of components, each of which may be either a + /// 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._(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.'); + } + + /// Creates a new [Version] object. + factory Version(int major, int minor, int patch, {String pre, String build}) { + var text = "$major.$minor.$patch"; + if (pre != null) text += "-$pre"; + if (build != null) text += "+$build"; + + return new Version._(major, minor, patch, pre, build, text); + } + + /// Creates a new [Version] by parsing [text]. + factory Version.parse(String text) { + final match = COMPLETE_VERSION.firstMatch(text); + if (match == null) { + throw new FormatException('Could not parse "$text".'); + } + + try { + int major = int.parse(match[1]); + int minor = int.parse(match[2]); + int patch = int.parse(match[3]); + + String preRelease = match[5]; + String build = match[8]; + + return new Version._(major, minor, patch, preRelease, build, text); + } 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 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; + } + + /// Splits a string of dot-delimited identifiers into their component parts. + /// + /// Identifiers that are numeric are converted to numbers. + static List _splitParts(String text) { + return text.split('.').map((part) { + try { + return int.parse(part); + } on FormatException catch (ex) { + // Not a number. + return part; + } + }).toList(); + } + + bool operator ==(other) { + if (other is! Version) return false; + return major == other.major && minor == other.minor && + patch == other.patch && + _equality.equals(preRelease, other.preRelease) && + _equality.equals(build, other.build); + } + + int get hashCode => major ^ minor ^ patch ^ _equality.hash(preRelease) ^ + _equality.hash(build); + + 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.isNotEmpty; + + /// Gets the next major version number that follows this one. + /// + /// If this version is a pre-release of a major version release (i.e. the + /// minor and patch versions are zero), then it just strips the pre-release + /// suffix. Otherwise, it increments the major version and resets the minor + /// and patch. + Version get nextMajor { + if (isPreRelease && minor == 0 && patch == 0) { + return new Version(major, minor, patch); + } + + return new Version(major + 1, 0, 0); + } + + /// Gets the next minor version number that follows this one. + /// + /// If this version is a pre-release of a minor version release (i.e. the + /// patch version is zero), then it just strips the pre-release suffix. + /// Otherwise, it increments the minor version and resets the patch. + Version get nextMinor { + if (isPreRelease && patch == 0) { + return new Version(major, minor, patch); + } + + return new Version(major, minor + 1, 0); + } + + /// Gets the next patch version number that follows this one. + /// + /// If this version is a pre-release, then it just strips the pre-release + /// suffix. Otherwise, it increments the patch version. + Version get nextPatch { + if (isPreRelease) { + return new Version(major, minor, patch); + } + + return 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; + + // Intersect a version and a range. + if (other is VersionRange) return other.intersect(this); + + // Intersecting two versions only works if they are the same. + if (other is Version) { + return this == other ? this : VersionConstraint.empty; + } + + throw new ArgumentError( + 'Unknown VersionConstraint type $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++) { + 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) { + if (bPart is num) { + // Compare two numbers. + return aPart.compareTo(bPart); + } else { + // Numbers come before strings. + return -1; + } + } else { + if (bPart is num) { + // Strings come after numbers. + return 1; + } else { + // Compare two strings. + return aPart.compareTo(bPart); + } + } + } + + // The lists are entirely equal. + return 0; + } +} diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart new file mode 100644 index 0000000000..499892ee23 --- /dev/null +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -0,0 +1,151 @@ +// 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'; + +/// 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(); + + /// A [VersionConstraint] that allows no versions -- the empty set. + static VersionConstraint empty = const _EmptyVersion(); + + /// Parses a version constraint. + /// + /// This string is either "any" or a series of version parts. Each part can + /// be one of: + /// + /// * A version string like `1.2.3`. In other words, anything that can be + /// parsed by [Version.parse()]. + /// * A comparison operator (`<`, `>`, `<=`, or `>=`) followed by a version + /// string. + /// + /// Whitespace is ignored. + /// + /// Examples: + /// + /// any + /// 1.2.3-alpha + /// <=5.1.4 + /// >2.0.4 <= 2.4.6 + factory VersionConstraint.parse(String text) { + // Handle the "any" constraint. + if (text.trim() == "any") return new VersionRange(); + + var originalText = text; + var constraints = []; + + skipWhitespace() { + text = text.trim(); + } + + // Try to parse and consume a version number. + matchVersion() { + var version = START_VERSION.firstMatch(text); + if (version == null) return null; + + text = text.substring(version.end); + return new Version.parse(version[0]); + } + + // Try to parse and consume a comparison operator followed by a version. + matchComparison() { + var comparison = START_COMPARISON.firstMatch(text); + if (comparison == null) return null; + + var op = comparison[0]; + text = text.substring(comparison.end); + skipWhitespace(); + + var version = matchVersion(); + if (version == null) { + throw new FormatException('Expected version number after "$op" in ' + '"$originalText", got "$text".'); + } + + switch (op) { + case '<=': return new VersionRange(max: version, includeMax: true); + case '<': return new VersionRange(max: version, includeMax: false); + case '>=': return new VersionRange(min: version, includeMin: true); + case '>': return new VersionRange(min: version, includeMin: false); + } + throw "Unreachable."; + } + + while (true) { + skipWhitespace(); + if (text.isEmpty) break; + + var version = matchVersion(); + if (version != null) { + constraints.add(version); + continue; + } + + var comparison = matchComparison(); + if (comparison != null) { + constraints.add(comparison); + continue; + } + + // If we got here, we couldn't parse the remaining string. + throw new FormatException('Could not parse version "$originalText". ' + 'Unknown text at "$text".'); + } + + if (constraints.isEmpty) { + throw new FormatException('Cannot parse an empty string.'); + } + + return new VersionConstraint.intersection(constraints); + } + + /// Creates a new version constraint that is the intersection of + /// [constraints]. + /// + /// It only allows versions that all of those constraints allow. If + /// constraints is empty, then it returns a VersionConstraint that allows + /// all versions. + factory VersionConstraint.intersection( + Iterable constraints) { + var constraint = new VersionRange(); + for (var other in constraints) { + 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); +} + +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() => ''; +} diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart new file mode 100644 index 0000000000..7020077a7f --- /dev/null +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -0,0 +1,179 @@ +// 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'; + +/// 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. + /// Otherwise, it will be the highest version below the range that is not + /// allowed. + /// + /// This may be `null` in which case the range has no minimum end and allows + /// any version less than the maximum. + final Version min; + + /// The maximum end of the range. + /// + /// If [includeMax] is `true`, this will be the maximum allowed version. + /// Otherwise, it will be the lowest version above the range that is not + /// allowed. + /// + /// This may be `null` in which case the range has no maximum end and allows + /// any version greater than the minimum. + final Version max; + + /// If `true` then [min] is allowed by the range. + final bool includeMin; + + /// If `true`, then [max] is allowed by the range. + final bool includeMax; + + /// Creates a new version range from [min] to [max], either inclusive or + /// exclusive. + /// + /// If it is an error if [min] is greater than [max]. + /// + /// Either [max] or [min] may be omitted to not clamp the range at that end. + /// If both are omitted, the range allows all versions. + /// + /// If [includeMin] is `true`, then the minimum end of the range is inclusive. + /// Likewise, passing [includeMax] as `true` makes the upper end inclusive. + VersionRange({this.min, this.max, + this.includeMin: false, this.includeMax: false}) { + if (min != null && max != null && min > max) { + throw new ArgumentError( + 'Minimum version ("$min") must be less than maximum ("$max").'); + } + } + + bool operator ==(other) { + 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 => min == null && max == null; + + /// Tests if [other] falls within this version range. + bool allows(Version other) { + if (min != null) { + if (other < min) return false; + if (!includeMin && other == min) return false; + } + + if (max != null) { + if (other > max) return false; + if (!includeMax && other == max) return false; + + // If the max isn't itself a pre-release, don't allow any pre-release + // versions of the max. + // + // See: https://www.npmjs.org/doc/misc/semver.html + if (!includeMax && + !max.isPreRelease && other.isPreRelease && + other.major == max.major && other.minor == max.minor && + other.patch == max.patch) { + return false; + } + } + + return true; + } + + VersionConstraint intersect(VersionConstraint other) { + if (other.isEmpty) return other; + + // 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; + var intersectMax = max; + var intersectIncludeMax = includeMax; + + if (other.min == null) { + // Do nothing. + } else if (intersectMin == null || intersectMin < other.min) { + intersectMin = other.min; + intersectIncludeMin = other.includeMin; + } else if (intersectMin == other.min && !other.includeMin) { + // The edges are the same, but one is exclusive, make it exclusive. + intersectIncludeMin = false; + } + + if (other.max == null) { + // Do nothing. + } else if (intersectMax == null || intersectMax > other.max) { + intersectMax = other.max; + intersectIncludeMax = other.includeMax; + } else if (intersectMax == other.max && !other.includeMax) { + // The edges are the same, but one is exclusive, make it exclusive. + intersectIncludeMax = false; + } + + if (intersectMin == null && intersectMax == null) { + // Open range. + return new VersionRange(); + } + + // If the range is just a single version. + if (intersectMin == intersectMax) { + // If both ends are inclusive, allow that version. + if (intersectIncludeMin && intersectIncludeMax) return intersectMin; + + // Otherwise, no versions. + return VersionConstraint.empty; + } + + if (intersectMin != null && intersectMax != null && + intersectMin > intersectMax) { + // Non-overlapping ranges, so empty. + return VersionConstraint.empty; + } + + // 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.'); + } + + 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(); + } +} diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml new file mode 100644 index 0000000000..63b09e1299 --- /dev/null +++ b/pkgs/pub_semver/pubspec.yaml @@ -0,0 +1,13 @@ +name: pub_semver +version: 1.0.0 +author: Dart Team +description: > + Versions and version constraints implementing pub's versioning policy. This + is very similar to vanilla semver, with a few corner cases. +homepage: http://github.com/dart-lang/pub_semver +dependencies: + collection: ">=0.9.0 <2.0.0" +dev_dependencies: + unittest: ">=0.9.0 <0.12.0" +environment: + sdk: ">=1.0.0 <2.0.0" diff --git a/pkgs/pub_semver/test/test_all.dart b/pkgs/pub_semver/test/test_all.dart new file mode 100644 index 0000000000..533dde82e8 --- /dev/null +++ b/pkgs/pub_semver/test/test_all.dart @@ -0,0 +1,17 @@ +// 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.test.test_all; + +import 'package:unittest/unittest.dart'; + +import 'version_constraint_test.dart' as version_constraint_test; +import 'version_range_test.dart' as version_range_test; +import 'version_test.dart' as version_test; + +main() { + group('Version', version_test.main); + group('VersionConstraint', version_constraint_test.main); + group('VersionRange', version_range_test.main); +} diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart new file mode 100644 index 0000000000..da8968313a --- /dev/null +++ b/pkgs/pub_semver/test/utils.dart @@ -0,0 +1,96 @@ +// 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.test.utils; + +import 'package:unittest/unittest.dart'; + +import 'package:pub_semver/pub_semver.dart'; + +/// Some stock example versions to use in tests. +final v114 = new Version.parse('1.1.4'); +final v123 = new Version.parse('1.2.3'); +final v124 = new Version.parse('1.2.4'); +final v130 = new Version.parse('1.3.0'); +final v140 = new Version.parse('1.4.0'); +final v200 = new Version.parse('2.0.0'); +final v201 = new Version.parse('2.0.1'); +final v234 = new Version.parse('2.3.4'); +final v250 = new Version.parse('2.5.0'); +final v300 = new Version.parse('3.0.0'); + +/// A [Matcher] that tests if a [VersionConstraint] allows or does not allow a +/// given list of [Version]s. +class _VersionConstraintMatcher implements Matcher { + final List _expected; + final bool _allow; + + _VersionConstraintMatcher(this._expected, this._allow); + + bool matches(item, Map matchState) => (item is VersionConstraint) && + _expected.every((version) => item.allows(version) == _allow); + + Description describe(Description description) { + description.addAll(' ${_allow ? "allows" : "does not allow"} versions ', + ', ', '', _expected); + return description; + } + + Description describeMismatch(item, Description mismatchDescription, + Map matchState, bool verbose) { + if (item is! VersionConstraint) { + mismatchDescription.add('was not a VersionConstraint'); + return mismatchDescription; + } + + var first = true; + for (var version in _expected) { + if (item.allows(version) != _allow) { + if (first) { + if (_allow) { + mismatchDescription.addDescriptionOf(item).add(' did not allow '); + } else { + mismatchDescription.addDescriptionOf(item).add(' allowed '); + } + } else { + mismatchDescription.add(' and '); + } + first = false; + + mismatchDescription.add(version.toString()); + } + } + + return mismatchDescription; + } +} + +/// Gets a [Matcher] that validates that a [VersionConstraint] allows all +/// given versions. +Matcher allows(Version v1, [Version v2, Version v3, Version v4, + Version v5, Version v6, Version v7, Version v8]) { + var versions = _makeVersionList(v1, v2, v3, v4, v5, v6, v7, v8); + return new _VersionConstraintMatcher(versions, true); +} + +/// Gets a [Matcher] that validates that a [VersionConstraint] allows none of +/// the given versions. +Matcher doesNotAllow(Version v1, [Version v2, Version v3, Version v4, + Version v5, Version v6, Version v7, Version v8]) { + var versions = _makeVersionList(v1, v2, v3, v4, v5, v6, v7, v8); + return new _VersionConstraintMatcher(versions, false); +} + +List _makeVersionList(Version v1, [Version v2, Version v3, Version v4, + Version v5, Version v6, Version v7, Version v8]) { + var versions = [v1]; + if (v2 != null) versions.add(v2); + if (v3 != null) versions.add(v3); + if (v4 != null) versions.add(v4); + if (v5 != null) versions.add(v5); + if (v6 != null) versions.add(v6); + if (v7 != null) versions.add(v7); + if (v8 != null) versions.add(v8); + return versions; +} \ No newline at end of file diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart new file mode 100644 index 0000000000..df8c099096 --- /dev/null +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -0,0 +1,143 @@ +// 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.test.version_constraint_test; + +import 'package:unittest/unittest.dart'; + +import 'package:pub_semver/pub_semver.dart'; + +import 'utils.dart'; + +main() { + test('any', () { + expect(VersionConstraint.any.isAny, isTrue); + expect(VersionConstraint.any, allows( + new Version.parse('0.0.0-blah'), + new Version.parse('1.2.3'), + new Version.parse('12345.678.90'))); + }); + + test('empty', () { + expect(VersionConstraint.empty.isEmpty, isTrue); + expect(VersionConstraint.empty.isAny, isFalse); + expect(VersionConstraint.empty, doesNotAllow( + new Version.parse('0.0.0-blah'), + new Version.parse('1.2.3'), + new Version.parse('12345.678.90'))); + }); + + group('parse()', () { + test('parses an exact version', () { + var constraint = new VersionConstraint.parse('1.2.3-alpha'); + + expect(constraint is Version, isTrue); + expect(constraint, equals(new Version(1, 2, 3, pre: 'alpha'))); + }); + + test('parses "any"', () { + var constraint = new VersionConstraint.parse('any'); + + expect(constraint is VersionConstraint, isTrue); + expect(constraint, allows( + new Version.parse('0.0.0'), + new Version.parse('1.2.3'), + new Version.parse('12345.678.90'))); + }); + + test('parses a ">" minimum version', () { + var constraint = new VersionConstraint.parse('>1.2.3'); + + expect(constraint, allows( + new Version.parse('1.2.3+foo'), + new Version.parse('1.2.4'))); + expect(constraint, doesNotAllow( + new Version.parse('1.2.1'), + new Version.parse('1.2.3-build'), + new Version.parse('1.2.3'))); + }); + + test('parses a ">=" minimum version', () { + var constraint = new VersionConstraint.parse('>=1.2.3'); + + expect(constraint, allows( + new Version.parse('1.2.3'), + new Version.parse('1.2.3+foo'), + new Version.parse('1.2.4'))); + expect(constraint, doesNotAllow( + new Version.parse('1.2.1'), + new Version.parse('1.2.3-build'))); + }); + + test('parses a "<" maximum version', () { + var constraint = new VersionConstraint.parse('<1.2.3'); + + expect(constraint, allows( + new Version.parse('1.2.1'), + new Version.parse('1.2.2+foo'))); + expect(constraint, doesNotAllow( + new Version.parse('1.2.3'), + new Version.parse('1.2.3+foo'), + new Version.parse('1.2.4'))); + }); + + test('parses a "<=" maximum version', () { + var constraint = new VersionConstraint.parse('<=1.2.3'); + + expect(constraint, allows( + new Version.parse('1.2.1'), + new Version.parse('1.2.3-build'), + new Version.parse('1.2.3'))); + expect(constraint, doesNotAllow( + new Version.parse('1.2.3+foo'), + new Version.parse('1.2.4'))); + }); + + test('parses a series of space-separated constraints', () { + var constraint = new VersionConstraint.parse('>1.0.0 >=1.2.3 <1.3.0'); + + expect(constraint, allows( + new Version.parse('1.2.3'), + new Version.parse('1.2.5'))); + expect(constraint, doesNotAllow( + new Version.parse('1.2.3-pre'), + new Version.parse('1.3.0'), + new Version.parse('3.4.5'))); + }); + + test('ignores whitespace around operators', () { + var constraint = new VersionConstraint.parse(' >1.0.0>=1.2.3 < 1.3.0'); + + expect(constraint, allows( + new Version.parse('1.2.3'), + new Version.parse('1.2.5'))); + expect(constraint, doesNotAllow( + new Version.parse('1.2.3-pre'), + new Version.parse('1.3.0'), + new Version.parse('3.4.5'))); + }); + + test('does not allow "any" to be mixed with other constraints', () { + expect(() => new VersionConstraint.parse('any 1.0.0'), + throwsFormatException); + }); + + test('throws FormatException on a bad string', () { + var bad = [ + "", " ", // Empty string. + "foo", // Bad text. + ">foo", // Bad text after operator. + "1.0.0 foo", "1.0.0foo", // Bad text after version. + "anything", // Bad text after "any". + "<>1.0.0", // Multiple operators. + "1.0.0<" // Trailing operator. + ]; + + for (var text in bad) { + expect(() => new VersionConstraint.parse(text), + throwsFormatException); + } + }); + }); +} diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart new file mode 100644 index 0000000000..388917ff52 --- /dev/null +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -0,0 +1,202 @@ +// 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.test.version_range_test; + +import 'package:unittest/unittest.dart'; + +import 'package:pub_semver/pub_semver.dart'; + +import 'utils.dart'; + +main() { + group('constructor', () { + test('takes a min and max', () { + var range = new VersionRange(min: v123, max: v124); + expect(range.isAny, isFalse); + expect(range.min, equals(v123)); + expect(range.max, equals(v124)); + }); + + test('allows omitting max', () { + var range = new VersionRange(min: v123); + expect(range.isAny, isFalse); + expect(range.min, equals(v123)); + expect(range.max, isNull); + }); + + test('allows omitting min and max', () { + var range = new VersionRange(); + expect(range.isAny, isTrue); + expect(range.min, isNull); + expect(range.max, isNull); + }); + + test('takes includeMin', () { + var range = new VersionRange(min: v123, includeMin: true); + expect(range.includeMin, isTrue); + }); + + test('includeMin defaults to false if omitted', () { + var range = new VersionRange(min: v123); + expect(range.includeMin, isFalse); + }); + + test('takes includeMax', () { + var range = new VersionRange(max: v123, includeMax: true); + expect(range.includeMax, isTrue); + }); + + test('includeMax defaults to false if omitted', () { + var range = new VersionRange(max: v123); + expect(range.includeMax, isFalse); + }); + + test('throws if min > max', () { + expect(() => new VersionRange(min: v124, max: v123), throwsArgumentError); + }); + }); + + group('allows()', () { + test('version must be greater than min', () { + var range = new VersionRange(min: v123); + + expect(range, allows( + new Version.parse('1.3.3'), + new Version.parse('2.3.3'))); + expect(range, doesNotAllow( + new Version.parse('1.2.2'), + new Version.parse('1.2.3'))); + }); + + test('version must be min or greater if includeMin', () { + var range = new VersionRange(min: v123, includeMin: true); + + expect(range, allows( + new Version.parse('1.2.3'), + new Version.parse('1.3.3'), + new Version.parse('2.3.3'))); + expect(range, doesNotAllow(new Version.parse('1.2.2'))); + }); + + test('pre-release versions of inclusive min are excluded', () { + var range = new VersionRange(min: v123, includeMin: true); + + expect(range, allows(new Version.parse('1.2.4-dev'))); + expect(range, doesNotAllow(new Version.parse('1.2.3-dev'))); + }); + + test('version must be less than max', () { + var range = new VersionRange(max: v234); + + expect(range, allows(new Version.parse('2.3.3'))); + expect(range, doesNotAllow( + new Version.parse('2.3.4'), + new Version.parse('2.4.3'))); + }); + + test('pre-release versions of non-pre-release max are excluded', () { + var range = new VersionRange(max: v234); + + expect(range, allows(new Version.parse('2.3.3'))); + expect(range, doesNotAllow( + new Version.parse('2.3.4-dev'), + new Version.parse('2.3.4'))); + }); + + test('pre-release versions of pre-release max are included', () { + var range = new VersionRange(max: new Version.parse('2.3.4-dev.2')); + + expect(range, allows( + new Version.parse('2.3.4-dev.1'))); + expect(range, doesNotAllow( + new Version.parse('2.3.4-dev.2'), + new Version.parse('2.3.4-dev.3'))); + }); + + test('version must be max or less if includeMax', () { + var range = new VersionRange(min: v123, max: v234, includeMax: true); + + expect(range, allows( + new Version.parse('2.3.3'), + new Version.parse('2.3.4'), + // Pre-releases of the max are allowed. + new Version.parse('2.3.4-dev'))); + expect(range, doesNotAllow(new Version.parse('2.4.3'))); + }); + + test('has no min if one was not set', () { + var range = new VersionRange(max: v123); + + expect(range, allows(new Version.parse('0.0.0'))); + expect(range, doesNotAllow(new Version.parse('1.2.3'))); + }); + + test('has no max if one was not set', () { + var range = new VersionRange(min: v123); + + expect(range, allows( + new Version.parse('1.3.3'), + new Version.parse('999.3.3'))); + expect(range, doesNotAllow(new Version.parse('1.2.3'))); + }); + + test('allows any version if there is no min or max', () { + var range = new VersionRange(); + + expect(range, allows( + new Version.parse('0.0.0'), + new Version.parse('999.99.9'))); + }); + }); + + group('intersect()', () { + test('two overlapping ranges', () { + var a = new VersionRange(min: v123, max: v250); + var b = new VersionRange(min: v200, max: v300); + var intersect = a.intersect(b); + expect(intersect.min, equals(v200)); + expect(intersect.max, equals(v250)); + expect(intersect.includeMin, isFalse); + expect(intersect.includeMax, isFalse); + }); + + test('a non-overlapping range allows no versions', () { + var a = new VersionRange(min: v114, max: v124); + var b = new VersionRange(min: v200, max: v250); + expect(a.intersect(b).isEmpty, isTrue); + }); + + test('adjacent ranges allow no versions if exclusive', () { + var a = new VersionRange(min: v114, max: v124, includeMax: false); + var b = new VersionRange(min: v124, max: v200, includeMin: true); + expect(a.intersect(b).isEmpty, isTrue); + }); + + test('adjacent ranges allow version if inclusive', () { + var a = new VersionRange(min: v114, max: v124, includeMax: true); + var b = new VersionRange(min: v124, max: v200, includeMin: true); + expect(a.intersect(b), equals(v124)); + }); + + test('with an open range', () { + var open = new VersionRange(); + var a = new VersionRange(min: v114, max: v124); + expect(open.intersect(open), equals(open)); + expect(a.intersect(open), equals(a)); + }); + + test('returns the version if the range allows it', () { + expect(new VersionRange(min: v114, max: v124).intersect(v123), + equals(v123)); + expect(new VersionRange(min: v123, max: v124).intersect(v114).isEmpty, + isTrue); + }); + }); + + test('isEmpty', () { + expect(new VersionRange().isEmpty, isFalse); + expect(new VersionRange(min: v123, max: v124).isEmpty, isFalse); + }); +} diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart new file mode 100644 index 0000000000..b271eccb84 --- /dev/null +++ b/pkgs/pub_semver/test/version_test.dart @@ -0,0 +1,248 @@ +// 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.test.version_test; + +import 'package:unittest/unittest.dart'; + +import 'package:pub_semver/pub_semver.dart'; + +import 'utils.dart'; + +main() { + test('none', () { + expect(Version.none.toString(), equals('0.0.0')); + }); + + test('prioritize()', () { + // A correctly sorted list of versions in order of increasing priority. + var versions = [ + '1.0.0-alpha', + '2.0.0-alpha', + '1.0.0', + '1.0.0+build', + '1.0.1', + '1.1.0', + '2.0.0' + ]; + + // Ensure that every pair of versions is prioritized in the order that it + // appears in the list. + for (var i = 0; i < versions.length; i++) { + for (var j = 0; j < versions.length; j++) { + var a = new Version.parse(versions[i]); + var b = new Version.parse(versions[j]); + expect(Version.prioritize(a, b), equals(i.compareTo(j))); + } + } + }); + + test('antiprioritize()', () { + // A correctly sorted list of versions in order of increasing antipriority. + var versions = [ + '2.0.0-alpha', + '1.0.0-alpha', + '2.0.0', + '1.1.0', + '1.0.1', + '1.0.0+build', + '1.0.0' + ]; + + // Ensure that every pair of versions is prioritized in the order that it + // appears in the list. + for (var i = 0; i < versions.length; i++) { + for (var j = 0; j < versions.length; j++) { + var a = new Version.parse(versions[i]); + var b = new Version.parse(versions[j]); + expect(Version.antiprioritize(a, b), equals(i.compareTo(j))); + } + } + }); + + group('constructor', () { + test('throws on negative numbers', () { + expect(() => new Version(-1, 1, 1), throwsArgumentError); + expect(() => new Version(1, -1, 1), throwsArgumentError); + expect(() => new Version(1, 1, -1), throwsArgumentError); + }); + }); + + group('comparison', () { + // A correctly sorted list of versions. + var versions = [ + '1.0.0-alpha', + '1.0.0-alpha.1', + '1.0.0-beta.2', + '1.0.0-beta.11', + '1.0.0-rc.1', + '1.0.0-rc.1+build.1', + '1.0.0', + '1.0.0+0.3.7', + '1.3.7+build', + '1.3.7+build.2.b8f12d7', + '1.3.7+build.11.e0f985a', + '2.0.0', + '2.1.0', + '2.2.0', + '2.11.0', + '2.11.1' + ]; + + test('compareTo()', () { + // Ensure that every pair of versions compares in the order that it + // appears in the list. + for (var i = 0; i < versions.length; i++) { + for (var j = 0; j < versions.length; j++) { + var a = new Version.parse(versions[i]); + var b = new Version.parse(versions[j]); + expect(a.compareTo(b), equals(i.compareTo(j))); + } + } + }); + + test('operators', () { + for (var i = 0; i < versions.length; i++) { + for (var j = 0; j < versions.length; j++) { + var a = new Version.parse(versions[i]); + var b = new Version.parse(versions[j]); + expect(a < b, equals(i < j)); + expect(a > b, equals(i > j)); + expect(a <= b, equals(i <= j)); + expect(a >= b, equals(i >= j)); + expect(a == b, equals(i == j)); + expect(a != b, equals(i != j)); + } + } + }); + + test('equality', () { + expect(new Version.parse('01.2.3'), equals(new Version.parse('1.2.3'))); + expect(new Version.parse('1.02.3'), equals(new Version.parse('1.2.3'))); + expect(new Version.parse('1.2.03'), equals(new Version.parse('1.2.3'))); + expect(new Version.parse('1.2.3-01'), + equals(new Version.parse('1.2.3-1'))); + expect(new Version.parse('1.2.3+01'), + equals(new Version.parse('1.2.3+1'))); + }); + }); + + test('allows()', () { + expect(v123, allows(v123)); + expect(v123, doesNotAllow( + new Version.parse('2.2.3'), + new Version.parse('1.3.3'), + new Version.parse('1.2.4'), + new Version.parse('1.2.3-dev'), + new Version.parse('1.2.3+build'))); + }); + + test('intersect()', () { + // Intersecting the same version returns the version. + expect(v123.intersect(v123), equals(v123)); + + // Intersecting a different version allows no versions. + expect(v123.intersect(v114).isEmpty, isTrue); + + // Intersecting a range returns the version if the range allows it. + expect(v123.intersect(new VersionRange(min: v114, max: v124)), + equals(v123)); + + // Intersecting a range allows no versions if the range doesn't allow it. + expect(v114.intersect(new VersionRange(min: v123, max: v124)).isEmpty, + isTrue); + }); + + test('isEmpty', () { + expect(v123.isEmpty, isFalse); + }); + + test('nextMajor', () { + expect(v123.nextMajor, equals(v200)); + expect(v114.nextMajor, equals(v200)); + expect(v200.nextMajor, equals(v300)); + + // Ignores pre-release if not on a major version. + expect(new Version.parse('1.2.3-dev').nextMajor, equals(v200)); + + // Just removes it if on a major version. + expect(new Version.parse('2.0.0-dev').nextMajor, equals(v200)); + + // Strips build suffix. + expect(new Version.parse('1.2.3+patch').nextMajor, equals(v200)); + }); + + test('nextMinor', () { + expect(v123.nextMinor, equals(v130)); + expect(v130.nextMinor, equals(v140)); + + // Ignores pre-release if not on a minor version. + expect(new Version.parse('1.2.3-dev').nextMinor, equals(v130)); + + // Just removes it if on a minor version. + expect(new Version.parse('1.3.0-dev').nextMinor, equals(v130)); + + // Strips build suffix. + expect(new Version.parse('1.2.3+patch').nextMinor, equals(v130)); + }); + + test('nextPatch', () { + expect(v123.nextPatch, equals(v124)); + expect(v200.nextPatch, equals(v201)); + + // Just removes pre-release version if present. + expect(new Version.parse('1.2.4-dev').nextPatch, equals(v124)); + + // Strips build suffix. + expect(new Version.parse('1.2.3+patch').nextPatch, equals(v124)); + }); + + test('parse()', () { + expect(new Version.parse('0.0.0'), equals(new Version(0, 0, 0))); + expect(new Version.parse('12.34.56'), equals(new Version(12, 34, 56))); + + expect(new Version.parse('1.2.3-alpha.1'), + equals(new Version(1, 2, 3, pre: 'alpha.1'))); + expect(new Version.parse('1.2.3-x.7.z-92'), + equals(new Version(1, 2, 3, pre: 'x.7.z-92'))); + + expect(new Version.parse('1.2.3+build.1'), + equals(new Version(1, 2, 3, build: 'build.1'))); + expect(new Version.parse('1.2.3+x.7.z-92'), + equals(new Version(1, 2, 3, build: 'x.7.z-92'))); + + expect(new Version.parse('1.0.0-rc-1+build-1'), + equals(new Version(1, 0, 0, pre: 'rc-1', build: 'build-1'))); + + expect(() => new Version.parse('1.0'), throwsFormatException); + expect(() => new Version.parse('1.2.3.4'), throwsFormatException); + expect(() => new Version.parse('1234'), throwsFormatException); + expect(() => new Version.parse('-2.3.4'), throwsFormatException); + expect(() => new Version.parse('1.3-pre'), throwsFormatException); + expect(() => new Version.parse('1.3+build'), throwsFormatException); + expect(() => new Version.parse('1.3+bu?!3ild'), throwsFormatException); + }); + + group('toString()', () { + test('returns the version string', () { + expect(new Version(0, 0, 0).toString(), equals('0.0.0')); + expect(new Version(12, 34, 56).toString(), equals('12.34.56')); + + expect(new Version(1, 2, 3, pre: 'alpha.1').toString(), + equals('1.2.3-alpha.1')); + expect(new Version(1, 2, 3, pre: 'x.7.z-92').toString(), + equals('1.2.3-x.7.z-92')); + + expect(new Version(1, 2, 3, build: 'build.1').toString(), + equals('1.2.3+build.1')); + expect(new Version(1, 2, 3, pre: 'pre', build: 'bui').toString(), + equals('1.2.3-pre+bui')); + }); + + test('preserves leading zeroes', () { + expect(new Version.parse('001.02.0003-01.dev+pre.002').toString(), + equals('001.02.0003-01.dev+pre.002')); + }); + }); +} From 5dd38641be46b82ad4cce561f1bb3bf13dd7a1b5 Mon Sep 17 00:00:00 2001 From: Sean Eagan Date: Thu, 23 Oct 2014 09:10:14 -0500 Subject: [PATCH 003/115] Add Version.nextBreaking and "^" operator --- pkgs/pub_semver/README.md | 18 ++++++ pkgs/pub_semver/lib/src/patterns.dart | 3 + pkgs/pub_semver/lib/src/version.dart | 28 ++++++++- .../lib/src/version_constraint.dart | 57 ++++++++++++++++--- pkgs/pub_semver/test/utils.dart | 4 ++ .../test/version_constraint_test.dart | 37 ++++++++++++ pkgs/pub_semver/test/version_test.dart | 12 ++++ 7 files changed, 148 insertions(+), 11 deletions(-) diff --git a/pkgs/pub_semver/README.md b/pkgs/pub_semver/README.md index 1cb1527911..475c1a3abc 100644 --- a/pkgs/pub_semver/README.md +++ b/pkgs/pub_semver/README.md @@ -73,5 +73,23 @@ spec. It differs from semver in a few corner cases: specifically selects that unstable version -- they've deliberately opted into it. + * **There is a notion of compatibility between pre-1.0.0 versions.** Semver + deems all pre-1.0.0 versions to be incompatible. This means that the only + way to ensure compatibility when depending on a pre-1.0.0 package is to + pin the dependency to an exact version. Pinned version constraints prevent + automatic patch and pre-release updates. To avoid this situation, pub + defines the "next breaking" version to be the version with the left-most + non-zero digit in [major, minor, patch] incremented, and the subsequent + digits reset to zero. For example, here are some versions along with their + next breaking ones: + + `0.0.3` -> `0.0.4` + `0.7.2-alpha` -> `0.8.0` + `1.2.3` -> `2.0.0` + + To make use of this, pub defines a "^" operator which yields a version + constraint greater than or equal to a given version, but less than its next + breaking one. + [pub]: http://pub.dartlang.org/ [semver]: http://semver.org/ diff --git a/pkgs/pub_semver/lib/src/patterns.dart b/pkgs/pub_semver/lib/src/patterns.dart index 4a2261815c..59b0c091a2 100644 --- a/pkgs/pub_semver/lib/src/patterns.dart +++ b/pkgs/pub_semver/lib/src/patterns.dart @@ -17,3 +17,6 @@ final COMPLETE_VERSION = new RegExp(START_VERSION.pattern + r'$'); /// Parses a comparison operator ("<", ">", "<=", or ">=") at the beginning of /// a string. final START_COMPARISON = new RegExp(r"^[<>]=?"); + +/// Parses the "compatible with" operator ("^") at the beginning of a string. +final START_COMPATIBLE_WITH = new RegExp(r"^\^"); diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 866d89c301..496178fbef 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -189,7 +189,7 @@ class Version implements Comparable, VersionConstraint { return new Version(major, minor, patch); } - return new Version(major + 1, 0, 0); + return _incrementMajor(); } /// Gets the next minor version number that follows this one. @@ -202,7 +202,7 @@ class Version implements Comparable, VersionConstraint { return new Version(major, minor, patch); } - return new Version(major, minor + 1, 0); + return _incrementMinor(); } /// Gets the next patch version number that follows this one. @@ -214,9 +214,31 @@ class Version implements Comparable, VersionConstraint { return new Version(major, minor, patch); } - return new Version(major, minor, patch + 1); + return _incrementPatch(); } + /// Gets the next breaking version number that follows this one. + /// + /// Increments the left-most non-zero digit in ([major], [minor], [patch]). + /// In other words, if [major] and [minor] are zero (e.g. 0.0.3), then it + /// increments [patch]. If [major] is zero and [minor] is not (e.g. 0.7.2), + /// then it increments [minor]. Otherwise, it increments [major]. + Version get nextBreaking { + if (major == 0) { + if (minor == 0) { + return _incrementPatch(); + } + + return _incrementMinor(); + } + + 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; diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 499892ee23..29dd5742a4 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -23,19 +23,26 @@ abstract class VersionConstraint { /// Parses a version constraint. /// - /// This string is either "any" or a series of version parts. Each part can - /// be one of: - /// - /// * A version string like `1.2.3`. In other words, anything that can be - /// parsed by [Version.parse()]. - /// * A comparison operator (`<`, `>`, `<=`, or `>=`) followed by a version - /// string. + /// This string is one of: + /// + /// * "any". See [any]. + /// * "^" followed by a version string. Versions compatible with the + /// version number. This allows versions greater than or equal to the + /// version, and less then the next breaking version (see + /// [Version.nextBreaking]). + /// * a series of version parts. Each part can be one of: + /// * A version string like `1.2.3`. In other words, anything that can be + /// parsed by [Version.parse()]. + /// * A comparison operator (`<`, `>`, `<=`, or `>=`) followed by a + /// version string. /// /// Whitespace is ignored. /// /// Examples: /// /// any + /// ^0.7.2 + /// ^1.0.0-alpha /// 1.2.3-alpha /// <=5.1.4 /// >2.0.4 <= 2.4.6 @@ -82,9 +89,38 @@ abstract class VersionConstraint { } throw "Unreachable."; } - + + // Try to parse the "^" operator followed by a version. + matchCompatibleWith() { + var compatibleWith = START_COMPATIBLE_WITH.firstMatch(text); + if (compatibleWith == null) return null; + + var op = compatibleWith[0]; + text = text.substring(compatibleWith.end); + skipWhitespace(); + + var version = matchVersion(); + if (version == null) { + throw new FormatException('Expected version number after "$op" in ' + '"$originalText", got "$text".'); + } + + getCurrentTextIndex() => originalText.length - text.length; + var startTextIndex = getCurrentTextIndex(); + if(constraints.isNotEmpty || text.isNotEmpty) { + var constraint = op + originalText.substring(startTextIndex, + getCurrentTextIndex()); + throw new FormatException('Cannot include other constraints with ' + '"^" constraint "$constraint" in "$originalText".'); + } + + return new VersionRange(min: version, includeMin: true, + max: version.nextBreaking); + } + while (true) { skipWhitespace(); + if (text.isEmpty) break; var version = matchVersion(); @@ -98,6 +134,11 @@ abstract class VersionConstraint { constraints.add(comparison); continue; } + + var compatibleWith = matchCompatibleWith(); + if (compatibleWith != null) { + return compatibleWith; + } // If we got here, we couldn't parse the remaining string. throw new FormatException('Could not parse version "$originalText". ' diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart index da8968313a..0cc0f6582d 100644 --- a/pkgs/pub_semver/test/utils.dart +++ b/pkgs/pub_semver/test/utils.dart @@ -9,6 +9,10 @@ import 'package:unittest/unittest.dart'; import 'package:pub_semver/pub_semver.dart'; /// Some stock example versions to use in tests. +final v003 = new Version.parse('0.0.3'); +final v004 = new Version.parse('0.0.4'); +final v072 = new Version.parse('0.7.2'); +final v080 = new Version.parse('0.8.0'); final v114 = new Version.parse('1.1.4'); final v123 = new Version.parse('1.2.3'); final v124 = new Version.parse('1.2.4'); diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index df8c099096..16a3fdc241 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -123,11 +123,48 @@ main() { throwsFormatException); }); + test('parses a "^" post-1.0.0 version', () { + var constraint = new VersionConstraint.parse('^1.2.3'); + + expect(constraint, equals(new VersionRange(min: v123, includeMin: true, + max: v123.nextBreaking))); + }); + + test('parses a "^" pre-1.0.0, post-0.1.0 version', () { + var constraint = new VersionConstraint.parse('^0.7.2'); + + expect(constraint, equals(new VersionRange(min: v072, includeMin: true, + max: v072.nextBreaking))); + }); + + test('parses a "^" pre-0.1.0 version', () { + var constraint = new VersionConstraint.parse('^0.0.3'); + + expect(constraint, equals(new VersionRange(min: v003, includeMin: true, + max: v003.nextBreaking))); + }); + + test('parses a "^" pre-release version', () { + var constraint = new VersionConstraint.parse('^0.7.2-pre+1'); + + var min = new Version.parse('0.7.2-pre+1'); + expect(constraint, equals(new VersionRange(min: min, includeMin: true, + max: min.nextBreaking))); + }); + + test('does not allow "^" to be mixed with other constraints', () { + expect(() => new VersionConstraint.parse('>=1.2.3 ^1.0.0'), + throwsFormatException); + expect(() => new VersionConstraint.parse('^1.0.0 <1.2.3'), + throwsFormatException); + }); + test('throws FormatException on a bad string', () { var bad = [ "", " ", // Empty string. "foo", // Bad text. ">foo", // Bad text after operator. + "^foo", // Bad text after "^". "1.0.0 foo", "1.0.0foo", // Bad text after version. "anything", // Bad text after "any". "<>1.0.0", // Multiple operators. diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index b271eccb84..527db2942a 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -198,6 +198,18 @@ main() { expect(new Version.parse('1.2.3+patch').nextPatch, equals(v124)); }); + test('nextBreaking', () { + expect(v123.nextBreaking, equals(v200)); + expect(v072.nextBreaking, equals(v080)); + expect(v003.nextBreaking, equals(v004)); + + // Removes pre-release version if present. + expect(new Version.parse('1.2.3-dev').nextBreaking, equals(v200)); + + // Strips build suffix. + expect(new Version.parse('1.2.3+patch').nextBreaking, equals(v200)); + }); + test('parse()', () { expect(new Version.parse('0.0.0'), equals(new Version(0, 0, 0))); expect(new Version.parse('12.34.56'), equals(new Version(12, 34, 56))); From 81b8e2243478dd48e85f5f1711e704cae65f6ccf Mon Sep 17 00:00:00 2001 From: Sean Eagan Date: Thu, 23 Oct 2014 12:25:11 -0500 Subject: [PATCH 004/115] Add VersionConstraint.compatibleWith constructor --- .../lib/src/version_constraint.dart | 21 +++++++++++++------ .../test/version_constraint_test.dart | 19 ++++++++++------- 2 files changed, 26 insertions(+), 14 deletions(-) diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 29dd5742a4..1b86602c48 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -25,11 +25,9 @@ abstract class VersionConstraint { /// /// This string is one of: /// - /// * "any". See [any]. - /// * "^" followed by a version string. Versions compatible with the - /// version number. This allows versions greater than or equal to the - /// version, and less then the next breaking version (see - /// [Version.nextBreaking]). + /// * "any". [any] version. + /// * "^" followed by a version string. Versions compatible with + /// ([VersionConstraint.compatibleWith]) the version. /// * a series of version parts. Each part can be one of: /// * A version string like `1.2.3`. In other words, anything that can be /// parsed by [Version.parse()]. @@ -107,7 +105,7 @@ abstract class VersionConstraint { getCurrentTextIndex() => originalText.length - text.length; var startTextIndex = getCurrentTextIndex(); - if(constraints.isNotEmpty || text.isNotEmpty) { + if (constraints.isNotEmpty || text.isNotEmpty) { var constraint = op + originalText.substring(startTextIndex, getCurrentTextIndex()); throw new FormatException('Cannot include other constraints with ' @@ -152,6 +150,17 @@ abstract class VersionConstraint { return new VersionConstraint.intersection(constraints); } + /// Creates a version constraint which allows all versions that are + /// backward compatible with [version]. + /// + /// Versions are considered backward compatible with [version] if they + /// are greater than or equal to [version], but less than the next breaking + /// version ([Version.nextBreaking]) of [version]. + factory VersionConstraint.compatibleWith(Version version) { + return new VersionRange(min: version, includeMin: true, + max: version.nextBreaking); + } + /// Creates a new version constraint that is the intersection of /// [constraints]. /// diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index 16a3fdc241..b58eab7048 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -126,30 +126,26 @@ main() { test('parses a "^" post-1.0.0 version', () { var constraint = new VersionConstraint.parse('^1.2.3'); - expect(constraint, equals(new VersionRange(min: v123, includeMin: true, - max: v123.nextBreaking))); + expect(constraint, equals(new VersionConstraint.compatibleWith(v123))); }); test('parses a "^" pre-1.0.0, post-0.1.0 version', () { var constraint = new VersionConstraint.parse('^0.7.2'); - expect(constraint, equals(new VersionRange(min: v072, includeMin: true, - max: v072.nextBreaking))); + expect(constraint, equals(new VersionConstraint.compatibleWith(v072))); }); test('parses a "^" pre-0.1.0 version', () { var constraint = new VersionConstraint.parse('^0.0.3'); - expect(constraint, equals(new VersionRange(min: v003, includeMin: true, - max: v003.nextBreaking))); + expect(constraint, equals(new VersionConstraint.compatibleWith(v003))); }); test('parses a "^" pre-release version', () { var constraint = new VersionConstraint.parse('^0.7.2-pre+1'); var min = new Version.parse('0.7.2-pre+1'); - expect(constraint, equals(new VersionRange(min: min, includeMin: true, - max: min.nextBreaking))); + expect(constraint, equals(new VersionConstraint.compatibleWith(min))); }); test('does not allow "^" to be mixed with other constraints', () { @@ -177,4 +173,11 @@ main() { } }); }); + + test('compatibleWith', () { + var constraint = new VersionConstraint.compatibleWith(v072); + + expect(constraint, equals(new VersionRange(min: v072, includeMin: true, + max: v072.nextBreaking))); + }); } From 9a49be98d3f183c13a065335dc168d7f137deace Mon Sep 17 00:00:00 2001 From: Sean Eagan Date: Thu, 23 Oct 2014 14:11:19 -0500 Subject: [PATCH 005/115] Remove trailing whitespace --- pkgs/pub_semver/README.md | 30 +++++++++---------- pkgs/pub_semver/lib/src/version.dart | 8 ++--- .../lib/src/version_constraint.dart | 26 ++++++++-------- .../test/version_constraint_test.dart | 4 +-- 4 files changed, 34 insertions(+), 34 deletions(-) diff --git a/pkgs/pub_semver/README.md b/pkgs/pub_semver/README.md index 475c1a3abc..3bc37c53e5 100644 --- a/pkgs/pub_semver/README.md +++ b/pkgs/pub_semver/README.md @@ -73,23 +73,23 @@ spec. It differs from semver in a few corner cases: specifically selects that unstable version -- they've deliberately opted into it. - * **There is a notion of compatibility between pre-1.0.0 versions.** Semver - deems all pre-1.0.0 versions to be incompatible. This means that the only - way to ensure compatibility when depending on a pre-1.0.0 package is to - pin the dependency to an exact version. Pinned version constraints prevent - automatic patch and pre-release updates. To avoid this situation, pub - defines the "next breaking" version to be the version with the left-most - non-zero digit in [major, minor, patch] incremented, and the subsequent - digits reset to zero. For example, here are some versions along with their + * **There is a notion of compatibility between pre-1.0.0 versions.** Semver + deems all pre-1.0.0 versions to be incompatible. This means that the only + way to ensure compatibility when depending on a pre-1.0.0 package is to + pin the dependency to an exact version. Pinned version constraints prevent + automatic patch and pre-release updates. To avoid this situation, pub + defines the "next breaking" version to be the version with the left-most + non-zero digit in [major, minor, patch] incremented, and the subsequent + digits reset to zero. For example, here are some versions along with their next breaking ones: - + `0.0.3` -> `0.0.4` - `0.7.2-alpha` -> `0.8.0` - `1.2.3` -> `2.0.0` - - To make use of this, pub defines a "^" operator which yields a version - constraint greater than or equal to a given version, but less than its next + `0.7.2-alpha` -> `0.8.0` + `1.2.3` -> `2.0.0` + + To make use of this, pub defines a "^" operator which yields a version + constraint greater than or equal to a given version, but less than its next breaking one. - + [pub]: http://pub.dartlang.org/ [semver]: http://semver.org/ diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 496178fbef..d980514f48 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -220,21 +220,21 @@ class Version implements Comparable, VersionConstraint { /// Gets the next breaking version number that follows this one. /// /// Increments the left-most non-zero digit in ([major], [minor], [patch]). - /// In other words, if [major] and [minor] are zero (e.g. 0.0.3), then it - /// increments [patch]. If [major] is zero and [minor] is not (e.g. 0.7.2), + /// In other words, if [major] and [minor] are zero (e.g. 0.0.3), then it + /// increments [patch]. If [major] is zero and [minor] is not (e.g. 0.7.2), /// then it increments [minor]. Otherwise, it increments [major]. Version get nextBreaking { if (major == 0) { if (minor == 0) { return _incrementPatch(); } - + return _incrementMinor(); } 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); diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 1b86602c48..0cd45b6367 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -24,14 +24,14 @@ abstract class VersionConstraint { /// Parses a version constraint. /// /// This string is one of: - /// + /// /// * "any". [any] version. - /// * "^" followed by a version string. Versions compatible with + /// * "^" followed by a version string. Versions compatible with /// ([VersionConstraint.compatibleWith]) the version. /// * a series of version parts. Each part can be one of: /// * A version string like `1.2.3`. In other words, anything that can be /// parsed by [Version.parse()]. - /// * A comparison operator (`<`, `>`, `<=`, or `>=`) followed by a + /// * A comparison operator (`<`, `>`, `<=`, or `>=`) followed by a /// version string. /// /// Whitespace is ignored. @@ -87,7 +87,7 @@ abstract class VersionConstraint { } throw "Unreachable."; } - + // Try to parse the "^" operator followed by a version. matchCompatibleWith() { var compatibleWith = START_COMPATIBLE_WITH.firstMatch(text); @@ -96,26 +96,26 @@ abstract class VersionConstraint { var op = compatibleWith[0]; text = text.substring(compatibleWith.end); skipWhitespace(); - + var version = matchVersion(); if (version == null) { throw new FormatException('Expected version number after "$op" in ' '"$originalText", got "$text".'); } - + getCurrentTextIndex() => originalText.length - text.length; var startTextIndex = getCurrentTextIndex(); if (constraints.isNotEmpty || text.isNotEmpty) { - var constraint = op + originalText.substring(startTextIndex, + var constraint = op + originalText.substring(startTextIndex, getCurrentTextIndex()); throw new FormatException('Cannot include other constraints with ' '"^" constraint "$constraint" in "$originalText".'); } - - return new VersionRange(min: version, includeMin: true, + + return new VersionRange(min: version, includeMin: true, max: version.nextBreaking); } - + while (true) { skipWhitespace(); @@ -132,7 +132,7 @@ abstract class VersionConstraint { constraints.add(comparison); continue; } - + var compatibleWith = matchCompatibleWith(); if (compatibleWith != null) { return compatibleWith; @@ -150,14 +150,14 @@ abstract class VersionConstraint { return new VersionConstraint.intersection(constraints); } - /// Creates a version constraint which allows all versions that are + /// Creates a version constraint which allows all versions that are /// backward compatible with [version]. /// /// Versions are considered backward compatible with [version] if they /// are greater than or equal to [version], but less than the next breaking /// version ([Version.nextBreaking]) of [version]. factory VersionConstraint.compatibleWith(Version version) { - return new VersionRange(min: version, includeMin: true, + return new VersionRange(min: version, includeMin: true, max: version.nextBreaking); } diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index b58eab7048..316d57ddf3 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -173,11 +173,11 @@ main() { } }); }); - + test('compatibleWith', () { var constraint = new VersionConstraint.compatibleWith(v072); - expect(constraint, equals(new VersionRange(min: v072, includeMin: true, + expect(constraint, equals(new VersionRange(min: v072, includeMin: true, max: v072.nextBreaking))); }); } From 95d0a3c74efb7ae3ff2d880b91df0cbfb90e6ed3 Mon Sep 17 00:00:00 2001 From: Sean Eagan Date: Tue, 28 Oct 2014 08:18:49 -0500 Subject: [PATCH 006/115] compatibleWith(): implement toString() and use to parse ^ --- pkgs/pub_semver/lib/src/version_constraint.dart | 17 +++++++++++------ .../test/version_constraint_test.dart | 16 ++++++++++++---- 2 files changed, 23 insertions(+), 10 deletions(-) diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 0cd45b6367..f67375fbc5 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -112,8 +112,7 @@ abstract class VersionConstraint { '"^" constraint "$constraint" in "$originalText".'); } - return new VersionRange(min: version, includeMin: true, - max: version.nextBreaking); + return new VersionConstraint.compatibleWith(version); } while (true) { @@ -156,10 +155,8 @@ abstract class VersionConstraint { /// Versions are considered backward compatible with [version] if they /// are greater than or equal to [version], but less than the next breaking /// version ([Version.nextBreaking]) of [version]. - factory VersionConstraint.compatibleWith(Version version) { - return new VersionRange(min: version, includeMin: true, - max: version.nextBreaking); - } + factory VersionConstraint.compatibleWith(Version version) => + new _CompatibleWithVersionRange(version); /// Creates a new version constraint that is the intersection of /// [constraints]. @@ -199,3 +196,11 @@ class _EmptyVersion implements VersionConstraint { VersionConstraint intersect(VersionConstraint other) => this; String toString() => ''; } + +class _CompatibleWithVersionRange extends VersionRange { + _CompatibleWithVersionRange(Version version) : super( + min: version, includeMin: true, + max: version.nextBreaking, includeMax: false); + + String toString() => '^$min'; +} diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index 316d57ddf3..9ba69053f6 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -174,10 +174,18 @@ main() { }); }); - test('compatibleWith', () { - var constraint = new VersionConstraint.compatibleWith(v072); + group('compatibleWith()', () { + test('returns the range of compatible versions', () { + var constraint = new VersionConstraint.compatibleWith(v072); - expect(constraint, equals(new VersionRange(min: v072, includeMin: true, - max: v072.nextBreaking))); + expect(constraint, equals(new VersionRange(min: v072, includeMin: true, + max: v072.nextBreaking))); + }); + + test('toString() uses "^"', () { + var constraint = new VersionConstraint.compatibleWith(v072); + + expect(constraint.toString(), equals('^0.7.2')); + }); }); } From a23657d5d6cd9cdd9f4eefd28d94c0bf4fa3ebb5 Mon Sep 17 00:00:00 2001 From: Sean Eagan Date: Tue, 28 Oct 2014 08:22:42 -0500 Subject: [PATCH 007/115] parse 'any' as VersionConstraint.any --- pkgs/pub_semver/lib/src/version_constraint.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index f67375fbc5..ab035ff219 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -46,7 +46,7 @@ abstract class VersionConstraint { /// >2.0.4 <= 2.4.6 factory VersionConstraint.parse(String text) { // Handle the "any" constraint. - if (text.trim() == "any") return new VersionRange(); + if (text.trim() == "any") return any; var originalText = text; var constraints = []; From 97b3ab283f7bb53fe86ec4086b88dd3e57eb0925 Mon Sep 17 00:00:00 2001 From: Sean Eagan Date: Tue, 28 Oct 2014 09:02:45 -0500 Subject: [PATCH 008/115] Move matchCompatibleWith() out of while loop --- .../lib/src/version_constraint.dart | 27 +++++++++---------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index ab035ff219..38864aa208 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -45,16 +45,17 @@ abstract class VersionConstraint { /// <=5.1.4 /// >2.0.4 <= 2.4.6 factory VersionConstraint.parse(String text) { - // Handle the "any" constraint. - if (text.trim() == "any") return any; - var originalText = text; - var constraints = []; skipWhitespace() { text = text.trim(); } + skipWhitespace(); + + // Handle the "any" constraint. + if (text == "any") return any; + // Try to parse and consume a version number. matchVersion() { var version = START_VERSION.firstMatch(text); @@ -103,18 +104,19 @@ abstract class VersionConstraint { '"$originalText", got "$text".'); } - getCurrentTextIndex() => originalText.length - text.length; - var startTextIndex = getCurrentTextIndex(); - if (constraints.isNotEmpty || text.isNotEmpty) { - var constraint = op + originalText.substring(startTextIndex, - getCurrentTextIndex()); + if (text.isNotEmpty) { throw new FormatException('Cannot include other constraints with ' - '"^" constraint "$constraint" in "$originalText".'); + '"^" constraint in "$originalText".'); } return new VersionConstraint.compatibleWith(version); } + var compatibleWith = matchCompatibleWith(); + if (compatibleWith != null) return compatibleWith; + + var constraints = []; + while (true) { skipWhitespace(); @@ -132,11 +134,6 @@ abstract class VersionConstraint { continue; } - var compatibleWith = matchCompatibleWith(); - if (compatibleWith != null) { - return compatibleWith; - } - // If we got here, we couldn't parse the remaining string. throw new FormatException('Could not parse version "$originalText". ' 'Unknown text at "$text".'); From 02f1b5b68f52234beb823260e0faea391fbfdedd Mon Sep 17 00:00:00 2001 From: Sean Eagan Date: Tue, 28 Oct 2014 09:31:57 -0500 Subject: [PATCH 009/115] Don't use regex to parse ^ --- pkgs/pub_semver/lib/src/patterns.dart | 4 ++-- pkgs/pub_semver/lib/src/version_constraint.dart | 12 +++++------- 2 files changed, 7 insertions(+), 9 deletions(-) diff --git a/pkgs/pub_semver/lib/src/patterns.dart b/pkgs/pub_semver/lib/src/patterns.dart index 59b0c091a2..8b32900954 100644 --- a/pkgs/pub_semver/lib/src/patterns.dart +++ b/pkgs/pub_semver/lib/src/patterns.dart @@ -18,5 +18,5 @@ final COMPLETE_VERSION = new RegExp(START_VERSION.pattern + r'$'); /// a string. final START_COMPARISON = new RegExp(r"^[<>]=?"); -/// Parses the "compatible with" operator ("^") at the beginning of a string. -final START_COMPATIBLE_WITH = new RegExp(r"^\^"); +/// The "compatible with" operator. +const COMPATIBLE_WITH = "^"; diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 38864aa208..cb1c64cd4b 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -91,22 +91,20 @@ abstract class VersionConstraint { // Try to parse the "^" operator followed by a version. matchCompatibleWith() { - var compatibleWith = START_COMPATIBLE_WITH.firstMatch(text); - if (compatibleWith == null) return null; + if (!text.startsWith(COMPATIBLE_WITH)) return null; - var op = compatibleWith[0]; - text = text.substring(compatibleWith.end); + text = text.substring(COMPATIBLE_WITH.length); skipWhitespace(); var version = matchVersion(); if (version == null) { - throw new FormatException('Expected version number after "$op" in ' - '"$originalText", got "$text".'); + throw new FormatException('Expected version number after ' + '"$COMPATIBLE_WITH" in "$originalText", got "$text".'); } if (text.isNotEmpty) { throw new FormatException('Cannot include other constraints with ' - '"^" constraint in "$originalText".'); + '"$COMPATIBLE_WITH" constraint in "$originalText".'); } return new VersionConstraint.compatibleWith(version); From b541708df38d6e3db26bc6c1edab192a76b1a042 Mon Sep 17 00:00:00 2001 From: Sean Eagan Date: Tue, 28 Oct 2014 10:45:52 -0500 Subject: [PATCH 010/115] Don't special case 0.0.x for ^ --- pkgs/pub_semver/README.md | 11 +++--- pkgs/pub_semver/lib/src/version.dart | 11 ++---- pkgs/pub_semver/test/utils.dart | 2 +- .../test/version_constraint_test.dart | 37 +++++++++---------- pkgs/pub_semver/test/version_test.dart | 2 +- 5 files changed, 28 insertions(+), 35 deletions(-) diff --git a/pkgs/pub_semver/README.md b/pkgs/pub_semver/README.md index 3bc37c53e5..3f9558f422 100644 --- a/pkgs/pub_semver/README.md +++ b/pkgs/pub_semver/README.md @@ -78,12 +78,13 @@ spec. It differs from semver in a few corner cases: way to ensure compatibility when depending on a pre-1.0.0 package is to pin the dependency to an exact version. Pinned version constraints prevent automatic patch and pre-release updates. To avoid this situation, pub - defines the "next breaking" version to be the version with the left-most - non-zero digit in [major, minor, patch] incremented, and the subsequent - digits reset to zero. For example, here are some versions along with their - next breaking ones: + defines the "next breaking" version as the version which increments the + major version if it's greater than zero, and the minor version otherwise, + resets subsequent digits to zero, and strips any pre-release or build + suffix. For example, here are some versions along with their next breaking + ones: - `0.0.3` -> `0.0.4` + `0.0.3` -> `0.1.0` `0.7.2-alpha` -> `0.8.0` `1.2.3` -> `2.0.0` diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index d980514f48..0eb96c7246 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -219,16 +219,11 @@ class Version implements Comparable, VersionConstraint { /// Gets the next breaking version number that follows this one. /// - /// Increments the left-most non-zero digit in ([major], [minor], [patch]). - /// In other words, if [major] and [minor] are zero (e.g. 0.0.3), then it - /// increments [patch]. If [major] is zero and [minor] is not (e.g. 0.7.2), - /// then it increments [minor]. Otherwise, it increments [major]. + /// Increments [major] if it's greater than zero, otherwise [minor], resets + /// subsequent digits to zero, and strips any [preRelease] or [build] + /// suffix. Version get nextBreaking { if (major == 0) { - if (minor == 0) { - return _incrementPatch(); - } - return _incrementMinor(); } diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart index 0cc0f6582d..d918422c6d 100644 --- a/pkgs/pub_semver/test/utils.dart +++ b/pkgs/pub_semver/test/utils.dart @@ -10,7 +10,7 @@ import 'package:pub_semver/pub_semver.dart'; /// Some stock example versions to use in tests. final v003 = new Version.parse('0.0.3'); -final v004 = new Version.parse('0.0.4'); +final v010 = new Version.parse('0.1.0'); final v072 = new Version.parse('0.7.2'); final v080 = new Version.parse('0.8.0'); final v114 = new Version.parse('1.1.4'); diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index 9ba69053f6..ee10a89d32 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -106,7 +106,7 @@ main() { new Version.parse('3.4.5'))); }); - test('ignores whitespace around operators', () { + test('ignores whitespace around comparison operators', () { var constraint = new VersionConstraint.parse(' >1.0.0>=1.2.3 < 1.3.0'); expect(constraint, allows( @@ -123,29 +123,19 @@ main() { throwsFormatException); }); - test('parses a "^" post-1.0.0 version', () { - var constraint = new VersionConstraint.parse('^1.2.3'); + test('parses a "^" version', () { + expect(new VersionConstraint.parse('^0.0.3'), equals( + new VersionConstraint.compatibleWith(v003))); - expect(constraint, equals(new VersionConstraint.compatibleWith(v123))); - }); - - test('parses a "^" pre-1.0.0, post-0.1.0 version', () { - var constraint = new VersionConstraint.parse('^0.7.2'); - - expect(constraint, equals(new VersionConstraint.compatibleWith(v072))); - }); - - test('parses a "^" pre-0.1.0 version', () { - var constraint = new VersionConstraint.parse('^0.0.3'); + expect(new VersionConstraint.parse('^0.7.2'), equals( + new VersionConstraint.compatibleWith(v072))); - expect(constraint, equals(new VersionConstraint.compatibleWith(v003))); - }); - - test('parses a "^" pre-release version', () { - var constraint = new VersionConstraint.parse('^0.7.2-pre+1'); + expect(new VersionConstraint.parse('^1.2.3'), equals( + new VersionConstraint.compatibleWith(v123))); var min = new Version.parse('0.7.2-pre+1'); - expect(constraint, equals(new VersionConstraint.compatibleWith(min))); + expect(new VersionConstraint.parse('^0.7.2-pre+1'), equals( + new VersionConstraint.compatibleWith(min))); }); test('does not allow "^" to be mixed with other constraints', () { @@ -155,6 +145,13 @@ main() { throwsFormatException); }); + test('ignores whitespace around "^"', () { + var constraint = new VersionConstraint.parse(' ^ 1.2.3 '); + + expect(constraint, equals( + new VersionConstraint.compatibleWith(v123))); + }); + test('throws FormatException on a bad string', () { var bad = [ "", " ", // Empty string. diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index 527db2942a..3c652ac2c9 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -201,7 +201,7 @@ main() { test('nextBreaking', () { expect(v123.nextBreaking, equals(v200)); expect(v072.nextBreaking, equals(v080)); - expect(v003.nextBreaking, equals(v004)); + expect(v003.nextBreaking, equals(v010)); // Removes pre-release version if present. expect(new Version.parse('1.2.3-dev').nextBreaking, equals(v200)); From 0a919331dcc837c11a190e03543bc742dc9c46bd Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Wed, 29 Oct 2014 14:11:28 -0700 Subject: [PATCH 011/115] Update the pubspec and changelog. --- pkgs/pub_semver/CHANGELOG.md | 12 ++++++++++++ pkgs/pub_semver/pubspec.yaml | 2 +- 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index bf0e1f93f4..5a89ebd4a9 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,15 @@ +# 1.1.0 + +* Add support for the `^` operator for compatible versions according to pub's + notion of compatibility. `^1.2.3` is equivalent to `>=1.2.3 <2.0.0`; `^0.1.2` + is equivalent to `>=0.1.2 <0.2.0`. + +* Add `Version.nextBreaking`, which returns the next version that introduces + breaking changes after a given version. + +* Add `new VersionConstraint.compatibleWith()`, which returns a range covering + all versions compatible with a given version. + # 1.0.0 * Initial release. diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 63b09e1299..b42206490f 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.0.0 +version: 1.1.0-dev author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From 3fa75ba02d1682bd9a13dcf132d23f5e0384cd00 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Wed, 29 Oct 2014 15:49:54 -0700 Subject: [PATCH 012/115] Add VersionRange.hashCode. Closes dart-lang/pub_semver#4 R=rnystrom@google.com Review URL: https://codereview.chromium.org/687973004 --- pkgs/pub_semver/CHANGELOG.md | 2 ++ pkgs/pub_semver/lib/src/version_range.dart | 3 +++ pkgs/pub_semver/pubspec.yaml | 2 +- 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 5a89ebd4a9..1580867ca2 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -10,6 +10,8 @@ * Add `new VersionConstraint.compatibleWith()`, which returns a range covering all versions compatible with a given version. +* Add a custom `VersionRange.hashCode` to make it properly hashable. + # 1.0.0 * Initial release. diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 7020077a7f..faffb47423 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -66,6 +66,9 @@ class VersionRange implements VersionConstraint { includeMax == other.includeMax; } + int get hashCode => min.hashCode ^ (max.hashCode * 3) ^ + (includeMin.hashCode * 5) ^ (includeMax.hashCode * 7); + bool get isEmpty => false; bool get isAny => min == null && max == null; diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index b42206490f..3abc401af3 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.1.0-dev +version: 1.1.0 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From a2de959ea456fb759c139ec31ca86fe4771dc575 Mon Sep 17 00:00:00 2001 From: Kenneth Endfinger Date: Tue, 23 Dec 2014 21:51:34 -0500 Subject: [PATCH 013/115] Fix Typo in Version --- pkgs/pub_semver/lib/src/version.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 0eb96c7246..2821e27e39 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -43,7 +43,7 @@ class Version implements Comparable, VersionConstraint { return a.compareTo(b); } - /// Like [proiritize], but lower version numbers are considered greater than + /// Like [prioritize], but lower version numbers are considered greater than /// higher version numbers. /// /// This still considers prerelease versions to be lower than non-prerelease From a2565ead6ffb7f93a9c2e7616479c7bfcb04ea1e Mon Sep 17 00:00:00 2001 From: Kenneth Endfinger Date: Tue, 30 Dec 2014 19:33:25 -0500 Subject: [PATCH 014/115] Bump version to 1.1.1-dev --- pkgs/pub_semver/pubspec.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 3abc401af3..749bc44bd1 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.1.0 +version: 1.1.1-dev author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From a9328a63c118de5c460e628135e939ffdb8323b7 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Tue, 28 Apr 2015 10:32:04 -0700 Subject: [PATCH 015/115] remove analyzer warnings add code review settings R=nweiz@google.com Review URL: https://codereview.chromium.org//1109053002 --- pkgs/pub_semver/codereview.settings | 3 +++ pkgs/pub_semver/lib/src/version.dart | 4 ++-- 2 files changed, 5 insertions(+), 2 deletions(-) create mode 100644 pkgs/pub_semver/codereview.settings diff --git a/pkgs/pub_semver/codereview.settings b/pkgs/pub_semver/codereview.settings new file mode 100644 index 0000000000..94ddf0ea9f --- /dev/null +++ b/pkgs/pub_semver/codereview.settings @@ -0,0 +1,3 @@ +CODE_REVIEW_SERVER: https://codereview.chromium.org/ +VIEW_VC: https://github.com/dart-lang/pub_semver/commit/ +CC_LIST: reviews@dartlang.org \ No newline at end of file diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 2821e27e39..2bf535fcc9 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -122,7 +122,7 @@ class Version implements Comparable, VersionConstraint { String build = match[8]; return new Version._(major, minor, patch, preRelease, build, text); - } on FormatException catch (ex) { + } on FormatException { throw new FormatException('Could not parse "$text".'); } } @@ -149,7 +149,7 @@ class Version implements Comparable, VersionConstraint { return text.split('.').map((part) { try { return int.parse(part); - } on FormatException catch (ex) { + } on FormatException { // Not a number. return part; } From 37e577006cffd28a85927cbf51abfdcd845873fd Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Tue, 5 May 2015 12:00:34 -0700 Subject: [PATCH 016/115] Use the new test runner. R=rnystrom@google.com Review URL: https://codereview.chromium.org/1121233007 --- pkgs/pub_semver/pubspec.yaml | 2 +- pkgs/pub_semver/test/test_all.dart | 17 ----------------- pkgs/pub_semver/test/utils.dart | 2 +- .../test/version_constraint_test.dart | 2 +- pkgs/pub_semver/test/version_range_test.dart | 2 +- pkgs/pub_semver/test/version_test.dart | 2 +- 6 files changed, 5 insertions(+), 22 deletions(-) delete mode 100644 pkgs/pub_semver/test/test_all.dart diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 749bc44bd1..bfb104cb55 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -8,6 +8,6 @@ homepage: http://github.com/dart-lang/pub_semver dependencies: collection: ">=0.9.0 <2.0.0" dev_dependencies: - unittest: ">=0.9.0 <0.12.0" + test: ">=0.12.0 <0.13.0" environment: sdk: ">=1.0.0 <2.0.0" diff --git a/pkgs/pub_semver/test/test_all.dart b/pkgs/pub_semver/test/test_all.dart deleted file mode 100644 index 533dde82e8..0000000000 --- a/pkgs/pub_semver/test/test_all.dart +++ /dev/null @@ -1,17 +0,0 @@ -// 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.test.test_all; - -import 'package:unittest/unittest.dart'; - -import 'version_constraint_test.dart' as version_constraint_test; -import 'version_range_test.dart' as version_range_test; -import 'version_test.dart' as version_test; - -main() { - group('Version', version_test.main); - group('VersionConstraint', version_constraint_test.main); - group('VersionRange', version_range_test.main); -} diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart index d918422c6d..6fefdae76c 100644 --- a/pkgs/pub_semver/test/utils.dart +++ b/pkgs/pub_semver/test/utils.dart @@ -4,7 +4,7 @@ library pub_semver.test.utils; -import 'package:unittest/unittest.dart'; +import 'package:test/test.dart'; import 'package:pub_semver/pub_semver.dart'; diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index ee10a89d32..b383054989 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -4,7 +4,7 @@ library pub_semver.test.version_constraint_test; -import 'package:unittest/unittest.dart'; +import 'package:test/test.dart'; import 'package:pub_semver/pub_semver.dart'; diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index 388917ff52..e15539bec2 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -4,7 +4,7 @@ library pub_semver.test.version_range_test; -import 'package:unittest/unittest.dart'; +import 'package:test/test.dart'; import 'package:pub_semver/pub_semver.dart'; diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index 3c652ac2c9..8745006058 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -4,7 +4,7 @@ library pub_semver.test.version_test; -import 'package:unittest/unittest.dart'; +import 'package:test/test.dart'; import 'package:pub_semver/pub_semver.dart'; From 92e6f47f6321a0c8924adaa8f809f607bbfee375 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Wed, 6 May 2015 11:19:10 -0700 Subject: [PATCH 017/115] Add more set-like version constraint operations. This adds support for union(), as well as checking if constraints are supersets of or disjoint with one another. These are necessary for some version solver work I'm doing in pub. R=rnystrom@google.com Review URL: https://codereview.chromium.org/1127783002 --- pkgs/pub_semver/CHANGELOG.md | 12 + pkgs/pub_semver/lib/src/utils.dart | 26 ++ pkgs/pub_semver/lib/src/version.dart | 41 +- .../lib/src/version_constraint.dart | 24 ++ pkgs/pub_semver/lib/src/version_range.dart | 134 +++++++ pkgs/pub_semver/lib/src/version_union.dart | 182 +++++++++ pkgs/pub_semver/pubspec.yaml | 2 +- pkgs/pub_semver/test/version_range_test.dart | 236 ++++++++++++ pkgs/pub_semver/test/version_test.dart | 50 +++ pkgs/pub_semver/test/version_union_test.dart | 352 ++++++++++++++++++ 10 files changed, 1046 insertions(+), 13 deletions(-) create mode 100644 pkgs/pub_semver/lib/src/utils.dart create mode 100644 pkgs/pub_semver/lib/src/version_union.dart create mode 100644 pkgs/pub_semver/test/version_union_test.dart diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 1580867ca2..32538cc9cb 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,15 @@ +# 1.2.0 + +* Add a `VersionConstraint.union()` method and a `new + VersionConstraint.unionOf()` constructor. These each return a constraint that + matches multiple existing constraints. + +* Add a `VersionConstraint.allowsAll()` method, which returns whether one + constraint is a superset of another. + +* Add a `VersionConstraint.allowsAny()` method, which returns whether one + constraint overlaps another. + # 1.1.0 * Add support for the `^` operator for compatible versions according to pub's diff --git a/pkgs/pub_semver/lib/src/utils.dart b/pkgs/pub_semver/lib/src/utils.dart new file mode 100644 index 0000000000..2853e5cb45 --- /dev/null +++ b/pkgs/pub_semver/lib/src/utils.dart @@ -0,0 +1,26 @@ +// Copyright (c) 2015, 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.utils; + +import 'version_range.dart'; + +/// Returns whether [range1] is immediately next to, but not overlapping, +/// [range2]. +bool areAdjacent(VersionRange range1, VersionRange range2) { + if (range1.max != range2.min) return false; + + return (range1.includeMax && !range2.includeMin) || + (!range1.includeMax && range2.includeMin); +} + +/// A [Comparator] that compares the maximum versions of [range1] and [range2]. +int compareMax(VersionRange range1, VersionRange range2) { + if (range1.max < range2.max) return -1; + if (range1.max > range2.max) return 1; + + if (!range1.includeMax && range2.includeMax) return -1; + if (range1.includeMax && !range2.includeMax) return 1; + return 0; +} diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 2bf535fcc9..51972f7ddf 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -4,7 +4,7 @@ library pub_semver.src.version; -import 'dart:math'; +import 'dart:math' as math; import 'package:collection/equality.dart'; @@ -16,7 +16,7 @@ import 'version_range.dart'; final _equality = const IterableEquality(); /// A parsed semantic version number. -class Version implements Comparable, VersionConstraint { +class Version implements Comparable, VersionConstraint, VersionRange { /// No released version: i.e. "0.0.0". static Version get none => new Version(0, 0, 0); @@ -85,6 +85,11 @@ class Version implements Comparable, VersionConstraint { /// 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), @@ -237,19 +242,31 @@ class Version implements Comparable, VersionConstraint { /// 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; + + bool allowsAny(VersionConstraint other) => other.allows(this); + + VersionConstraint intersect(VersionConstraint other) => + other.allows(this) ? this : VersionConstraint.empty; - // Intersect a version and a range. - if (other is VersionRange) return other.intersect(this); + VersionConstraint union(VersionConstraint other) { + if (other.allows(this)) return other; - // Intersecting two versions only works if they are the same. - if (other is Version) { - return this == other ? this : VersionConstraint.empty; + 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) { @@ -277,7 +294,7 @@ class Version implements Comparable, VersionConstraint { /// 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; diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index cb1c64cd4b..3f4d5b8c87 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -7,6 +7,7 @@ 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. @@ -168,6 +169,14 @@ abstract class VersionConstraint { 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 constraints) => + VersionUnion.create(constraints); + /// Returns `true` if this constraint allows no versions. bool get isEmpty; @@ -177,9 +186,21 @@ abstract class VersionConstraint { /// 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 { @@ -188,7 +209,10 @@ class _EmptyVersion implements VersionConstraint { 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() => ''; } diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index faffb47423..7a18edf0e8 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -6,6 +6,7 @@ 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. /// @@ -99,8 +100,81 @@ class VersionRange implements VersionConstraint { return true; } + bool allowsAll(VersionConstraint other) { + if (other.isEmpty) return true; + if (other is Version) return allows(other); + + 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 neither range has a minimum, they'll overlap at some point. + // + // ... this ] + // ... other ] + if (min == null && other.min == null) return true; + + // If this range has a lower minimum than the other range, it overlaps as + // long as its maximum is higher than or the same as the other range's + // minimum. + // + // [ this ] [ this ] + // [ other ] [ other ] + if (min == null || (other.min != null && min < other.min)) { + 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 this range has a higher minimum than the other range, it overlaps as + // long as its minimum is lower than or the same as the other range's + // maximum. + // + // [ this ] [ this ] + // [ other ] [ other ] + 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) { @@ -162,6 +236,66 @@ class VersionRange implements VersionConstraint { 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); + } + + return new VersionConstraint.unionOf([this, other]); + } + + 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)) || + (min == other.max && (includeMin || other.includeMax)); + if (!edgesTouch && !allowsAny(other)) { + 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 < min) { + unionMin = other.min; + unionIncludeMin = other.includeMin; + } else if (min == other.min && other.includeMin) { + // 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 > max) { + unionMax = other.max; + unionIncludeMax = other.includeMax; + } else if (max == 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(); diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart new file mode 100644 index 0000000000..ee9f657acf --- /dev/null +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -0,0 +1,182 @@ +// Copyright (c) 2015, 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_union; + +import 'package:collection/collection.dart'; + +import 'utils.dart'; +import 'version.dart'; +import 'version_constraint.dart'; +import 'version_range.dart'; + +/// A (package-private) version constraint representing a union of multiple +/// disjoint version constraints. +/// +/// An instance of this will only be created if the version can't be represented +/// as a non-compound value. +class VersionUnion implements VersionConstraint { + /// The constraints that compose this union. + /// + /// This list has two invariants: + /// + /// * Its contents are sorted from lowest to highest matched versions. + /// * Its contents are disjoint and non-adjacent. In other words, for any two + /// constraints next to each other in the list, there's some version between + /// those constraints that they don't match. + final List constraints; + + bool get isEmpty => false; + + bool get isAny => false; + + /// Returns the union of [constraints]. + /// + /// This ensures that an actual [VersionUnion] is only returned if necessary. + /// It also takes care of sorting and merging the constraints to ensure that + /// they're disjoint. + static VersionConstraint create(Iterable constraints) { + var flattened = constraints.expand((constraint) { + if (constraint.isEmpty) return []; + if (constraint is VersionUnion) return constraint.constraints; + return [constraint]; + }).toList(); + + if (flattened.isEmpty) return VersionConstraint.empty; + + if (flattened.any((constraint) => constraint.isAny)) { + return VersionConstraint.any; + } + + // Only allow Versions and VersionRanges here so we can more easily reason + // about everything in [flattened]. _EmptyVersions and VersionUnions are + // filtered out above. + for (var constraint in flattened) { + if (constraint is VersionRange) continue; + throw new ArgumentError('Unknown VersionConstraint type $constraint.'); + } + + (flattened as List).sort(compareMax); + + var merged = []; + for (var constraint in flattened) { + // Merge this constraint with the previous one, but only if they touch. + if (merged.isEmpty || + (!merged.last.allowsAny(constraint) && + !areAdjacent(merged.last, constraint))) { + merged.add(constraint); + } else { + merged[merged.length - 1] = merged.last.union(constraint); + } + } + + if (merged.length == 1) return merged.single; + return new VersionUnion._(merged); + } + + VersionUnion._(this.constraints); + + bool allows(Version version) => + constraints.any((constraint) => constraint.allows(version)); + + bool allowsAll(VersionConstraint other) { + var ourConstraints = constraints.iterator; + var theirConstraints = _constraintsFor(other).iterator; + + // Because both lists of constraints are ordered by minimum version, we can + // safely move through them linearly here. + ourConstraints.moveNext(); + theirConstraints.moveNext(); + while (ourConstraints.current != null && theirConstraints.current != null) { + if (ourConstraints.current.allowsAll(theirConstraints.current)) { + theirConstraints.moveNext(); + } else { + ourConstraints.moveNext(); + } + } + + // If our constraints have allowed all of their constraints, we'll have + // consumed all of them. + return theirConstraints.current == null; + } + + bool allowsAny(VersionConstraint other) { + var ourConstraints = constraints.iterator; + var theirConstraints = _constraintsFor(other).iterator; + + // Because both lists of constraints are ordered by minimum version, we can + // safely move through them linearly here. + ourConstraints.moveNext(); + theirConstraints.moveNext(); + while (ourConstraints.current != null && theirConstraints.current != null) { + if (ourConstraints.current.allowsAny(theirConstraints.current)) { + return true; + } + + // Move the constraint with the higher max value forward. This ensures + // that we keep both lists in sync as much as possible. + if (compareMax(ourConstraints.current, theirConstraints.current) < 0) { + ourConstraints.moveNext(); + } else { + theirConstraints.moveNext(); + } + } + + return false; + } + + VersionConstraint intersect(VersionConstraint other) { + var ourConstraints = constraints.iterator; + var theirConstraints = _constraintsFor(other).iterator; + + // Because both lists of constraints are ordered by minimum version, we can + // safely move through them linearly here. + var newConstraints = []; + ourConstraints.moveNext(); + theirConstraints.moveNext(); + while (ourConstraints.current != null && theirConstraints.current != null) { + var intersection = ourConstraints.current + .intersect(theirConstraints.current); + + if (!intersection.isEmpty) newConstraints.add(intersection); + + // Move the constraint with the higher max value forward. This ensures + // that we keep both lists in sync as much as possible, and that large + // constraints have a chance to match multiple small constraints that they + // contain. + if (compareMax(ourConstraints.current, theirConstraints.current) < 0) { + ourConstraints.moveNext(); + } else { + theirConstraints.moveNext(); + } + } + + if (newConstraints.isEmpty) return VersionConstraint.empty; + if (newConstraints.length == 1) return newConstraints.single; + + return new VersionUnion._(newConstraints); + } + + /// Returns [constraint] as a list of constraints. + /// + /// This is used to normalize constraints of various types. + List _constraintsFor(VersionConstraint constraint) { + if (constraint.isEmpty) return []; + if (constraint is VersionUnion) return constraint.constraints; + if (constraint is VersionRange) return [constraint]; + throw new ArgumentError('Unknown VersionConstraint type $constraint.'); + } + + VersionConstraint union(VersionConstraint other) => + new VersionConstraint.unionOf([this, other]); + + bool operator ==(other) { + if (other is! VersionUnion) return false; + return const ListEquality().equals(constraints, other.constraints); + } + + int get hashCode => const ListEquality().hash(constraints); + + String toString() => constraints.join(" or "); +} diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index bfb104cb55..26be2808bf 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.1.1-dev +version: 1.2.0 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index e15539bec2..ef35d80223 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -151,6 +151,167 @@ main() { }); }); + group('allowsAll()', () { + test('allows an empty constraint', () { + expect( + new VersionRange(min: v123, max: v250) + .allowsAll(VersionConstraint.empty), + isTrue); + }); + + test('allows allowed versions', () { + var range = new VersionRange(min: v123, max: v250, includeMax: true); + expect(range.allowsAll(v123), isFalse); + expect(range.allowsAll(v124), isTrue); + expect(range.allowsAll(v250), isTrue); + expect(range.allowsAll(v300), isFalse); + }); + + test('with no min', () { + var range = new VersionRange(max: v250); + expect(range.allowsAll(new VersionRange(min: v080, max: v140)), isTrue); + expect(range.allowsAll(new VersionRange(min: v080, max: v300)), isFalse); + expect(range.allowsAll(new VersionRange(max: v140)), isTrue); + expect(range.allowsAll(new VersionRange(max: v300)), isFalse); + expect(range.allowsAll(range), isTrue); + expect(range.allowsAll(VersionConstraint.any), isFalse); + }); + + test('with no max', () { + var range = new VersionRange(min: v010); + expect(range.allowsAll(new VersionRange(min: v080, max: v140)), isTrue); + expect(range.allowsAll(new VersionRange(min: v003, max: v140)), isFalse); + expect(range.allowsAll(new VersionRange(min: v080)), isTrue); + expect(range.allowsAll(new VersionRange(min: v003)), isFalse); + expect(range.allowsAll(range), isTrue); + expect(range.allowsAll(VersionConstraint.any), isFalse); + }); + + test('with a min and max', () { + var range = new VersionRange(min: v010, max: v250); + expect(range.allowsAll(new VersionRange(min: v080, max: v140)), isTrue); + expect(range.allowsAll(new VersionRange(min: v080, max: v300)), isFalse); + expect(range.allowsAll(new VersionRange(min: v003, max: v140)), isFalse); + expect(range.allowsAll(new VersionRange(min: v080)), isFalse); + expect(range.allowsAll(new VersionRange(max: v140)), isFalse); + expect(range.allowsAll(range), isTrue); + }); + + test("allows a bordering range that's not more inclusive", () { + var exclusive = new VersionRange(min: v010, max: v250); + var inclusive = new VersionRange( + min: v010, includeMin: true, max: v250, includeMax: true); + expect(inclusive.allowsAll(exclusive), isTrue); + expect(inclusive.allowsAll(inclusive), isTrue); + expect(exclusive.allowsAll(inclusive), isFalse); + expect(exclusive.allowsAll(exclusive), isTrue); + }); + + test('allows unions that are completely contained', () { + var range = new VersionRange(min: v114, max: v200); + expect( + range.allowsAll(new VersionRange(min: v123, max: v124).union(v140)), + isTrue); + expect( + range.allowsAll(new VersionRange(min: v010, max: v124).union(v140)), + isFalse); + expect( + range.allowsAll(new VersionRange(min: v123, max: v234).union(v140)), + isFalse); + }); + }); + + group('allowsAny()', () { + test('disallows an empty constraint', () { + expect( + new VersionRange(min: v123, max: v250) + .allowsAny(VersionConstraint.empty), + isFalse); + }); + + test('allows allowed versions', () { + var range = new VersionRange(min: v123, max: v250, includeMax: true); + expect(range.allowsAny(v123), isFalse); + expect(range.allowsAny(v124), isTrue); + expect(range.allowsAny(v250), isTrue); + expect(range.allowsAny(v300), isFalse); + }); + + test('with no min', () { + var range = new VersionRange(max: v200); + expect(range.allowsAny(new VersionRange(min: v140, max: v300)), isTrue); + expect(range.allowsAny(new VersionRange(min: v234, max: v300)), isFalse); + expect(range.allowsAny(new VersionRange(min: v140)), isTrue); + expect(range.allowsAny(new VersionRange(min: v234)), isFalse); + expect(range.allowsAny(range), isTrue); + }); + + test('with no max', () { + var range = new VersionRange(min: v072); + expect(range.allowsAny(new VersionRange(min: v003, max: v140)), isTrue); + expect(range.allowsAny(new VersionRange(min: v003, max: v010)), isFalse); + expect(range.allowsAny(new VersionRange(max: v080)), isTrue); + expect(range.allowsAny(new VersionRange(max: v003)), isFalse); + expect(range.allowsAny(range), isTrue); + }); + + test('with a min and max', () { + var range = new VersionRange(min: v072, max: v200); + expect(range.allowsAny(new VersionRange(min: v003, max: v140)), isTrue); + expect(range.allowsAny(new VersionRange(min: v140, max: v300)), isTrue); + expect(range.allowsAny(new VersionRange(min: v003, max: v010)), isFalse); + expect(range.allowsAny(new VersionRange(min: v234, max: v300)), isFalse); + expect(range.allowsAny(new VersionRange(max: v010)), isFalse); + expect(range.allowsAny(new VersionRange(min: v234)), isFalse); + expect(range.allowsAny(range), isTrue); + }); + + test('allows a bordering range when both are inclusive', () { + expect(new VersionRange(max: v250).allowsAny(new VersionRange(min: v250)), + isFalse); + + expect(new VersionRange(max: v250, includeMax: true) + .allowsAny(new VersionRange(min: v250)), + isFalse); + + expect(new VersionRange(max: v250) + .allowsAny(new VersionRange(min: v250, includeMin: true)), + isFalse); + + expect(new VersionRange(max: v250, includeMax: true) + .allowsAny(new VersionRange(min: v250, includeMin: true)), + isTrue); + + expect(new VersionRange(min: v250).allowsAny(new VersionRange(max: v250)), + isFalse); + + expect(new VersionRange(min: v250, includeMin: true) + .allowsAny(new VersionRange(max: v250)), + isFalse); + + expect(new VersionRange(min: v250) + .allowsAny(new VersionRange(max: v250, includeMax: true)), + isFalse); + + expect(new VersionRange(min: v250, includeMin: true) + .allowsAny(new VersionRange(max: v250, includeMax: true)), + isTrue); + }); + + test('allows unions that are partially contained', () { + var range = new VersionRange(min: v114, max: v200); + expect( + range.allowsAny(new VersionRange(min: v010, max: v080).union(v140)), + isTrue); + expect( + range.allowsAny(new VersionRange(min: v123, max: v234).union(v300)), + isTrue); + expect( + range.allowsAny(new VersionRange(min: v234, max: v300).union(v010)), + isFalse); + }); + }); + group('intersect()', () { test('two overlapping ranges', () { var a = new VersionRange(min: v123, max: v250); @@ -195,6 +356,81 @@ main() { }); }); + group('union()', () { + test("with a version returns the range if it contains the version", () { + var range = new VersionRange(min: v114, max: v124); + expect(range.union(v123), equals(range)); + }); + + test("with a version on the edge of the range, expands the range", () { + expect(new VersionRange(min: v114, max: v124).union(v124), + equals(new VersionRange(min: v114, max: v124, includeMax: true))); + expect(new VersionRange(min: v114, max: v124).union(v114), + equals(new VersionRange(min: v114, max: v124, includeMin: true))); + }); + + test("with a version allows both the range and the version if the range " + "doesn't contain the version", () { + var result = new VersionRange(min: v003, max: v114).union(v124); + expect(result, allows(v010)); + expect(result, doesNotAllow(v123)); + expect(result, allows(v124)); + }); + + test("returns a VersionUnion for a disjoint range", () { + var result = new VersionRange(min: v003, max: v114) + .union(new VersionRange(min: v130, max: v200)); + expect(result, allows(v080)); + expect(result, doesNotAllow(v123)); + expect(result, allows(v140)); + }); + + test("considers open ranges disjoint", () { + var result = new VersionRange(min: v003, max: v114) + .union(new VersionRange(min: v114, max: v200)); + expect(result, allows(v080)); + expect(result, doesNotAllow(v114)); + expect(result, allows(v140)); + + result = new VersionRange(min: v114, max: v200) + .union(new VersionRange(min: v003, max: v114)); + expect(result, allows(v080)); + expect(result, doesNotAllow(v114)); + expect(result, allows(v140)); + }); + + test("returns a merged range for an overlapping range", () { + var result = new VersionRange(min: v003, max: v114) + .union(new VersionRange(min: v080, max: v200)); + expect(result, equals(new VersionRange(min: v003, max: v200))); + }); + + test("considers closed ranges overlapping", () { + var result = new VersionRange(min: v003, max: v114, includeMax: true) + .union(new VersionRange(min: v114, max: v200)); + expect(result, equals(new VersionRange(min: v003, max: v200))); + + result = new VersionRange(min: v003, max: v114) + .union(new VersionRange(min: v114, max: v200, includeMin: true)); + expect(result, equals(new VersionRange(min: v003, max: v200))); + + result = new VersionRange(min: v114, max: v200) + .union(new VersionRange(min: v003, max: v114, includeMax: true)); + expect(result, equals(new VersionRange(min: v003, max: v200))); + + result = new VersionRange(min: v114, max: v200, includeMin: true) + .union(new VersionRange(min: v003, max: v114)); + expect(result, equals(new VersionRange(min: v003, max: v200))); + }); + + test("includes edges if either range does", () { + var result = new VersionRange(min: v003, max: v114, includeMin: true) + .union(new VersionRange(min: v003, max: v114, includeMax: true)); + expect(result, equals(new VersionRange( + min: v003, max: v114, includeMin: true, includeMax: true))); + }); + }); + test('isEmpty', () { expect(new VersionRange().isEmpty, isFalse); expect(new VersionRange(min: v123, max: v124).isEmpty, isFalse); diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index 8745006058..e3d1b49a9d 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -138,6 +138,22 @@ main() { new Version.parse('1.2.3+build'))); }); + test('allowsAll()', () { + expect(v123.allowsAll(v123), isTrue); + expect(v123.allowsAll(v003), isFalse); + expect(v123.allowsAll(new VersionRange(min: v114, max: v124)), isFalse); + expect(v123.allowsAll(VersionConstraint.any), isFalse); + expect(v123.allowsAll(VersionConstraint.empty), isTrue); + }); + + test('allowsAny()', () { + expect(v123.allowsAny(v123), isTrue); + expect(v123.allowsAny(v003), isFalse); + expect(v123.allowsAny(new VersionRange(min: v114, max: v124)), isTrue); + expect(v123.allowsAny(VersionConstraint.any), isTrue); + expect(v123.allowsAny(VersionConstraint.empty), isFalse); + }); + test('intersect()', () { // Intersecting the same version returns the version. expect(v123.intersect(v123), equals(v123)); @@ -154,6 +170,40 @@ main() { isTrue); }); + group('union()', () { + test("with the same version returns the version", () { + expect(v123.union(v123), equals(v123)); + }); + + test("with a different version returns a version that matches both", () { + var result = v123.union(v080); + expect(result, allows(v123)); + expect(result, allows(v080)); + + // Nothing in between should match. + expect(result, doesNotAllow(v114)); + }); + + test("with a range returns the range if it contains the version", () { + var range = new VersionRange(min: v114, max: v124); + expect(v123.union(range), equals(range)); + }); + + test("with a range with the version on the edge, expands the range", () { + expect(v124.union(new VersionRange(min: v114, max: v124)), + equals(new VersionRange(min: v114, max: v124, includeMax: true))); + expect(v114.union(new VersionRange(min: v114, max: v124)), + equals(new VersionRange(min: v114, max: v124, includeMin: true))); + }); + + test("with a range allows both the range and the version if the range " + "doesn't contain the version", () { + var result = v123.union(new VersionRange(min: v003, max: v114)); + expect(result, allows(v123)); + expect(result, allows(v010)); + }); + }); + test('isEmpty', () { expect(v123.isEmpty, isFalse); }); diff --git a/pkgs/pub_semver/test/version_union_test.dart b/pkgs/pub_semver/test/version_union_test.dart new file mode 100644 index 0000000000..f3518a06ae --- /dev/null +++ b/pkgs/pub_semver/test/version_union_test.dart @@ -0,0 +1,352 @@ +// Copyright (c) 2015, 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. + +import 'package:test/test.dart'; + +import 'package:pub_semver/pub_semver.dart'; + +import 'utils.dart'; + +main() { + group('factory', () { + test('ignores empty constraints', () { + expect(new VersionConstraint.unionOf([ + VersionConstraint.empty, + VersionConstraint.empty, + v123, + VersionConstraint.empty + ]), equals(v123)); + + expect(new VersionConstraint.unionOf([ + VersionConstraint.empty, + VersionConstraint.empty + ]), isEmpty); + }); + + test('returns an empty constraint for an empty list', () { + expect(new VersionConstraint.unionOf([]), isEmpty); + }); + + test('any constraints override everything', () { + expect(new VersionConstraint.unionOf([ + v123, + VersionConstraint.any, + v200, + new VersionRange(min: v234, max: v250) + ]), equals(VersionConstraint.any)); + }); + + test('flattens other unions', () { + expect(new VersionConstraint.unionOf([ + v072, + new VersionConstraint.unionOf([v123, v124]), + v250 + ]), equals(new VersionConstraint.unionOf([v072, v123, v124, v250]))); + }); + + test('returns a single merged range as-is', () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v080, max: v140), + new VersionRange(min: v123, max: v200) + ]), equals(new VersionRange(min: v080, max: v200))); + }); + }); + + group('equality', () { + test("doesn't depend on original order", () { + expect(new VersionConstraint.unionOf([ + v250, + new VersionRange(min: v201, max: v234), + v124, + v072, + new VersionRange(min: v080, max: v114), + v123 + ]), equals(new VersionConstraint.unionOf([ + v072, + new VersionRange(min: v080, max: v114), + v123, + v124, + new VersionRange(min: v201, max: v234), + v250 + ]))); + }); + + test("merges overlapping ranges", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + new VersionRange(min: v010, max: v080), + new VersionRange(min: v114, max: v124), + new VersionRange(min: v123, max: v130) + ]), equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v114, max: v130) + ]))); + }); + + test("merges adjacent ranges", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072, includeMax: true), + new VersionRange(min: v072, max: v080), + new VersionRange(min: v114, max: v124), + new VersionRange(min: v124, max: v130, includeMin: true) + ]), equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v114, max: v130) + ]))); + }); + + test("doesn't merge not-quite-adjacent ranges", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + new VersionRange(min: v072, max: v080) + ]), equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + new VersionRange(min: v072, max: v080) + ]))); + }); + + test("merges version numbers into ranges", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + v010, + new VersionRange(min: v114, max: v124), + v123 + ]), equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + new VersionRange(min: v114, max: v124) + ]))); + }); + + test("merges adjacent version numbers into ranges", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + v072, + v114, + new VersionRange(min: v114, max: v124) + ]), equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072, includeMax: true), + new VersionRange(min: v114, max: v124, includeMin: true) + ]))); + }); + }); + + test('isEmpty returns false', () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v123, max: v130), + ]), isNot(isEmpty)); + }); + + test('isAny returns false', () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v123, max: v130), + ]).isAny, isFalse); + }); + + test('allows() allows anything the components allow', () { + var union = new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v123, max: v130), + v200 + ]); + + expect(union, allows(v010)); + expect(union, doesNotAllow(v080)); + expect(union, allows(v124)); + expect(union, doesNotAllow(v140)); + expect(union, allows(v200)); + }); + + group('allowsAll()', () { + test('for a version, returns true if any component allows the version', () { + var union = new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v123, max: v130), + v200 + ]); + + expect(union.allowsAll(v010), isTrue); + expect(union.allowsAll(v080), isFalse); + expect(union.allowsAll(v124), isTrue); + expect(union.allowsAll(v140), isFalse); + expect(union.allowsAll(v200), isTrue); + }); + + test('for a version range, returns true if any component allows the whole ' + 'range', () { + var union = new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v123, max: v130) + ]); + + expect(union.allowsAll(new VersionRange(min: v003, max: v080)), isTrue); + expect(union.allowsAll(new VersionRange(min: v010, max: v072)), isTrue); + expect(union.allowsAll(new VersionRange(min: v010, max: v124)), isFalse); + }); + + group('for a union,', () { + var union = new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v123, max: v130) + ]); + + test('returns true if every constraint matches a different constraint', + () { + expect(union.allowsAll(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v072), + new VersionRange(min: v124, max: v130) + ])), isTrue); + }); + + test('returns true if every constraint matches the same constraint', () { + expect(union.allowsAll(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v010), + new VersionRange(min: v072, max: v080) + ])), isTrue); + }); + + test("returns false if there's an unmatched constraint", () { + expect(union.allowsAll(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v072), + new VersionRange(min: v124, max: v130), + new VersionRange(min: v140, max: v200) + ])), isFalse); + }); + + test("returns false if a constraint isn't fully matched", () { + expect(union.allowsAll(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v114), + new VersionRange(min: v124, max: v130) + ])), isFalse); + }); + }); + }); + + group('allowsAny()', () { + test('for a version, returns true if any component allows the version', () { + var union = new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v123, max: v130), + v200 + ]); + + expect(union.allowsAny(v010), isTrue); + expect(union.allowsAny(v080), isFalse); + expect(union.allowsAny(v124), isTrue); + expect(union.allowsAny(v140), isFalse); + expect(union.allowsAny(v200), isTrue); + }); + + test('for a version range, returns true if any component allows part of ' + 'the range', () { + var union = new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + v123 + ]); + + expect(union.allowsAny(new VersionRange(min: v010, max: v114)), isTrue); + expect(union.allowsAny(new VersionRange(min: v114, max: v124)), isTrue); + expect(union.allowsAny(new VersionRange(min: v124, max: v130)), isFalse); + }); + + group('for a union,', () { + var union = new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v130) + ]); + + test('returns true if any constraint matches', () { + expect(union.allowsAny(new VersionConstraint.unionOf([ + v072, + new VersionRange(min: v200, max: v300) + ])), isTrue); + + expect(union.allowsAny(new VersionConstraint.unionOf([ + v003, + new VersionRange(min: v124, max: v300) + ])), isTrue); + }); + + test("returns false if no constraint matches", () { + expect(union.allowsAny(new VersionConstraint.unionOf([ + v003, + new VersionRange(min: v130, max: v140), + new VersionRange(min: v140, max: v200) + ])), isFalse); + }); + }); + }); + + group("intersect()", () { + test("with an overlapping version, returns that version", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v140) + ]).intersect(v072), equals(v072)); + }); + + test("with a non-overlapping version, returns an empty constraint", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v140) + ]).intersect(v300), isEmpty); + }); + + test("with an overlapping range, returns that range", () { + var range = new VersionRange(min: v072, max: v080); + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v140) + ]).intersect(range), equals(range)); + }); + + test("with a non-overlapping range, returns an empty constraint", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v140) + ]).intersect(new VersionRange(min: v080, max: v123)), isEmpty); + }); + + test("with a parially-overlapping range, returns the overlapping parts", + () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v140) + ]).intersect(new VersionRange(min: v072, max: v130)), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v072, max: v080), + new VersionRange(min: v123, max: v130) + ]))); + }); + + group("for a union,", () { + var union = new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v123, max: v130) + ]); + + test("returns the overlapping parts", () { + expect(union.intersect(new VersionConstraint.unionOf([ + v010, + new VersionRange(min: v072, max: v124), + new VersionRange(min: v124, max: v130) + ])), equals(new VersionConstraint.unionOf([ + v010, + new VersionRange(min: v072, max: v080), + new VersionRange(min: v123, max: v124), + new VersionRange(min: v124, max: v130) + ]))); + }); + + test("drops parts that don't match", () { + expect(union.intersect(new VersionConstraint.unionOf([ + v003, + new VersionRange(min: v072, max: v080), + new VersionRange(min: v080, max: v123) + ])), equals(new VersionRange(min: v072, max: v080))); + }); + }); + }); +} \ No newline at end of file From 45c6965b7356d39ef46a473dea06db7b41b542a0 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Wed, 6 May 2015 13:24:21 -0700 Subject: [PATCH 018/115] Mention that Version implements VersionConstraint in the changelog. R=rnystrom@google.com Review URL: https://codereview.chromium.org//1123313003 --- pkgs/pub_semver/CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 32538cc9cb..06f7caa400 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -10,6 +10,8 @@ * Add a `VersionConstraint.allowsAny()` method, which returns whether one constraint overlaps another. +* `Version` now implements `VersionRange`. + # 1.1.0 * Add support for the `^` operator for compatible versions according to pub's From d56ecf203d81206f6b3cbee87a2d73dcdf8c5a21 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Wed, 20 May 2015 16:48:05 -0700 Subject: [PATCH 019/115] Change the pre-release range semantics. This allows ">=1.2.3-dev <1.2.3" to work how it looks like it should work, as opposed to matching no versions at all. R=rnystrom@google.com Review URL: https://codereview.chromium.org//1149543002 --- pkgs/pub_semver/CHANGELOG.md | 8 +++++ pkgs/pub_semver/README.md | 10 +++--- pkgs/pub_semver/lib/src/version_range.dart | 37 +++++++++++++++----- pkgs/pub_semver/test/version_range_test.dart | 12 +++++++ 4 files changed, 55 insertions(+), 12 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 06f7caa400..58190a8a6b 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,11 @@ +# 1.2.1 + +* Allow version ranges like `>=1.2.3-dev.1 <1.2.3` to match pre-release versions + of `1.2.3`. Previously, these didn't match, since the pre-release versions had + the same major, minor, and patch numbers as the max; now an exception has been + added if they also have the same major, minor, and patch numbers as the min + *and* the min is also a pre-release version. + # 1.2.0 * Add a `VersionConstraint.union()` method and a `new diff --git a/pkgs/pub_semver/README.md b/pkgs/pub_semver/README.md index 3f9558f422..b359754077 100644 --- a/pkgs/pub_semver/README.md +++ b/pkgs/pub_semver/README.md @@ -33,10 +33,12 @@ spec. It differs from semver in a few corner cases: unstable versions of `2.0.0`'s API, which is what pre-release versions represent. - To handle that, `<` version ranges to not allow pre-release versions of the - maximum unless the max is itself a pre-release. In other words, a `<2.0.0` - constraint will prohibit not just `2.0.0` but any pre-release of `2.0.0`. - However, `<2.0.0-beta` will exclude `2.0.0-beta` but allow `2.0.0-alpha`. + To handle that, `<` version ranges don't allow pre-release versions of the + maximum unless the max is itself a pre-release, or the min is a pre-release + of the same version. In other words, a `<2.0.0` constraint will prohibit not + just `2.0.0` but any pre-release of `2.0.0`. However, `<2.0.0-beta` will + exclude `2.0.0-beta` but allow `2.0.0-alpha`. Likewise, `>2.0.0-alpha + <2.0.0` will exclude `2.0.0-alpha` but allow `2.0.0-beta`. * **Pre-release versions are avoided when possible.** The above case handles pre-release versions at the top of the range, but what about in diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 7a18edf0e8..5c53834c67 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -85,21 +85,42 @@ class VersionRange implements VersionConstraint { if (other > max) return false; if (!includeMax && other == max) return false; - // If the max isn't itself a pre-release, don't allow any pre-release - // versions of the max. + + // Disallow pre-release versions that have the same major, minor, and + // patch version as the max, but only if neither the max nor the min is a + // pre-release of that version. This ensures that "^1.2.3" doesn't include + // "2.0.0-pre", while also allowing both ">=2.0.0-pre.2 <2.0.0" and + // ">=1.2.3 <2.0.0-pre.7" to match "2.0.0-pre.5". + // + // It's worth noting that this is different than [NPM's semantics][]. NPM + // disallows **all** pre-release versions unless their major, minor, and + // patch numbers match those of a prerelease min or max. This ensures that + // no prerelease versions will ever be selected if the user doesn't + // explicitly allow them. + // + // [NPM's semantics]: https://www.npmjs.org/doc/misc/semver.html#prerelease-tags // - // See: https://www.npmjs.org/doc/misc/semver.html - if (!includeMax && + // Instead, we ensure that release versions will always be preferred over + // prerelease versions by ordering the release versions first in + // [Version.prioritize]. This means that constraints like "any" or + // ">1.2.3" can still match prerelease versions if they're the only things + // available. + var maxIsReleaseOfOther = !includeMax && !max.isPreRelease && other.isPreRelease && - other.major == max.major && other.minor == max.minor && - other.patch == max.patch) { - return false; - } + _equalsWithoutPreRelease(other, max); + var minIsPreReleaseOfOther = min != null && min.isPreRelease && + _equalsWithoutPreRelease(other, min); + if (maxIsReleaseOfOther && !minIsPreReleaseOfOther) return false; } return true; } + bool _equalsWithoutPreRelease(Version version1, Version version2) => + version1.major == version2.major && + version1.minor == version2.minor && + version1.patch == version2.patch; + bool allowsAll(VersionConstraint other) { if (other.isEmpty) return true; if (other is Version) return allows(other); diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index ef35d80223..6df6b310ad 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -105,6 +105,18 @@ main() { new Version.parse('2.3.4'))); }); + test('pre-release versions of non-pre-release max are included if min is a ' + 'pre-release of the same version', () { + var range = new VersionRange( + min: new Version.parse('2.3.4-dev.0'), max: v234); + + expect(range, allows(new Version.parse('2.3.4-dev.1'))); + expect(range, doesNotAllow( + new Version.parse('2.3.3'), + new Version.parse('2.3.4-dev'), + new Version.parse('2.3.4'))); + }); + test('pre-release versions of pre-release max are included', () { var range = new VersionRange(max: new Version.parse('2.3.4-dev.2')); From f57d158ac181a468b3742405fb39515db0fbfb3e Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Wed, 20 May 2015 17:49:03 -0700 Subject: [PATCH 020/115] Update the pubspec for 1.2.1. R=rnystrom@google.com Review URL: https://codereview.chromium.org//1143063003 --- pkgs/pub_semver/pubspec.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 26be2808bf..33545a37ba 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.2.0 +version: 1.2.1 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From 5cedf8e1431947e4284a31562813e789c9b38f68 Mon Sep 17 00:00:00 2001 From: Devon Carew Date: Sat, 19 Sep 2015 17:40:05 -0700 Subject: [PATCH 021/115] fix param types on methods in _EmptyVersion --- pkgs/pub_semver/.gitignore | 1 + pkgs/pub_semver/CHANGELOG.md | 6 ++++++ pkgs/pub_semver/lib/src/version_constraint.dart | 4 ++-- pkgs/pub_semver/pubspec.yaml | 2 +- 4 files changed, 10 insertions(+), 3 deletions(-) diff --git a/pkgs/pub_semver/.gitignore b/pkgs/pub_semver/.gitignore index 7178642c22..98fed01aaf 100644 --- a/pkgs/pub_semver/.gitignore +++ b/pkgs/pub_semver/.gitignore @@ -1,3 +1,4 @@ +.packages packages pubspec.lock diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 58190a8a6b..7dca24ce3a 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,9 @@ +# 1.2.2 + +* Make the package analyze under strong mode and compile with the DDC (Dart Dev + Compiler). Fix two issues with a private subclass of `VersionConstraint` + having different types for overridden methods. + # 1.2.1 * Allow version ranges like `>=1.2.3-dev.1 <1.2.3` to match pre-release versions diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 3f4d5b8c87..dbd0aa5ad3 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -209,8 +209,8 @@ class _EmptyVersion implements VersionConstraint { bool get isEmpty => true; bool get isAny => false; bool allows(Version other) => false; - bool allowsAll(Version other) => other.isEmpty; - bool allowsAny(Version other) => false; + bool allowsAll(VersionConstraint other) => other.isEmpty; + bool allowsAny(VersionConstraint other) => false; VersionConstraint intersect(VersionConstraint other) => this; VersionConstraint union(VersionConstraint other) => other; String toString() => ''; diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 33545a37ba..530a4cea88 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.2.1 +version: 1.2.2 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From 245e70cade2a7db29f605c828a12cb63437d2b7d Mon Sep 17 00:00:00 2001 From: Devon Carew Date: Fri, 30 Oct 2015 15:43:12 -0700 Subject: [PATCH 022/115] Fix three strong mode analysis issues. BUG=https://github.com/dart-lang/pub_semver/issues/10 R=nweiz@google.com Review URL: https://codereview.chromium.org//1417163006 . --- pkgs/pub_semver/CHANGELOG.md | 4 ++++ pkgs/pub_semver/lib/src/version_constraint.dart | 2 +- pkgs/pub_semver/lib/src/version_union.dart | 4 ++-- pkgs/pub_semver/pubspec.yaml | 2 +- 4 files changed, 8 insertions(+), 4 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 7dca24ce3a..b505230e7a 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,7 @@ +# 1.2.3 + +* Addressed three strong mode warnings. + # 1.2.2 * Make the package analyze under strong mode and compile with the DDC (Dart Dev diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index dbd0aa5ad3..f84d8820e7 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -114,7 +114,7 @@ abstract class VersionConstraint { var compatibleWith = matchCompatibleWith(); if (compatibleWith != null) return compatibleWith; - var constraints = []; + var constraints = []; while (true) { skipWhitespace(); diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index ee9f657acf..a6715145a8 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -59,7 +59,7 @@ class VersionUnion implements VersionConstraint { (flattened as List).sort(compareMax); - var merged = []; + var merged = []; for (var constraint in flattened) { // Merge this constraint with the previous one, but only if they touch. if (merged.isEmpty || @@ -132,7 +132,7 @@ class VersionUnion implements VersionConstraint { // Because both lists of constraints are ordered by minimum version, we can // safely move through them linearly here. - var newConstraints = []; + var newConstraints = []; ourConstraints.moveNext(); theirConstraints.moveNext(); while (ourConstraints.current != null && theirConstraints.current != null) { diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 530a4cea88..0ed3e3bfce 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.2.2 +version: 1.2.3 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From 150736782a2154b2a1875c9f55d2130951e303ed Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Tue, 12 Jan 2016 17:22:29 -0800 Subject: [PATCH 023/115] Get rid of all the library tags. R=rnystrom@google.com Review URL: https://codereview.chromium.org//1581853003 . --- pkgs/pub_semver/lib/pub_semver.dart | 2 -- pkgs/pub_semver/lib/src/patterns.dart | 2 -- pkgs/pub_semver/lib/src/utils.dart | 2 -- pkgs/pub_semver/lib/src/version.dart | 2 -- pkgs/pub_semver/lib/src/version_constraint.dart | 2 -- pkgs/pub_semver/lib/src/version_range.dart | 2 -- pkgs/pub_semver/lib/src/version_union.dart | 2 -- pkgs/pub_semver/test/utils.dart | 2 -- pkgs/pub_semver/test/version_constraint_test.dart | 2 -- pkgs/pub_semver/test/version_range_test.dart | 2 -- pkgs/pub_semver/test/version_test.dart | 2 -- 11 files changed, 22 deletions(-) diff --git a/pkgs/pub_semver/lib/pub_semver.dart b/pkgs/pub_semver/lib/pub_semver.dart index 436e226005..fd2320e1cf 100644 --- a/pkgs/pub_semver/lib/pub_semver.dart +++ b/pkgs/pub_semver/lib/pub_semver.dart @@ -2,8 +2,6 @@ // 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; - export 'src/version.dart'; export 'src/version_constraint.dart'; export 'src/version_range.dart'; diff --git a/pkgs/pub_semver/lib/src/patterns.dart b/pkgs/pub_semver/lib/src/patterns.dart index 8b32900954..4e57ec908e 100644 --- a/pkgs/pub_semver/lib/src/patterns.dart +++ b/pkgs/pub_semver/lib/src/patterns.dart @@ -2,8 +2,6 @@ // 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.patterns; - /// Regex that matches a version number at the beginning of a string. final START_VERSION = new RegExp( r'^' // Start at beginning. diff --git a/pkgs/pub_semver/lib/src/utils.dart b/pkgs/pub_semver/lib/src/utils.dart index 2853e5cb45..74d015ac1f 100644 --- a/pkgs/pub_semver/lib/src/utils.dart +++ b/pkgs/pub_semver/lib/src/utils.dart @@ -2,8 +2,6 @@ // 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.utils; - import 'version_range.dart'; /// Returns whether [range1] is immediately next to, but not overlapping, diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 51972f7ddf..528c3a2016 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -2,8 +2,6 @@ // 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' as math; import 'package:collection/equality.dart'; diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index f84d8820e7..f222b51991 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -2,8 +2,6 @@ // 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'; diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 5c53834c67..668b9b28ee 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -2,8 +2,6 @@ // 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'; diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index a6715145a8..27993416c1 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -2,8 +2,6 @@ // 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_union; - import 'package:collection/collection.dart'; import 'utils.dart'; diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart index 6fefdae76c..e1d7446ccf 100644 --- a/pkgs/pub_semver/test/utils.dart +++ b/pkgs/pub_semver/test/utils.dart @@ -2,8 +2,6 @@ // 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.test.utils; - import 'package:test/test.dart'; import 'package:pub_semver/pub_semver.dart'; diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index b383054989..bd6bf75cf0 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -2,8 +2,6 @@ // 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.test.version_constraint_test; - import 'package:test/test.dart'; import 'package:pub_semver/pub_semver.dart'; diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index 6df6b310ad..9eaa980464 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -2,8 +2,6 @@ // 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.test.version_range_test; - import 'package:test/test.dart'; import 'package:pub_semver/pub_semver.dart'; diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index e3d1b49a9d..ddc6c94b5a 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -2,8 +2,6 @@ // 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.test.version_test; - import 'package:test/test.dart'; import 'package:pub_semver/pub_semver.dart'; From cc6ce78eafd3d3d19f526cf5cc574c66945af40b Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Thu, 31 Mar 2016 17:23:22 -0700 Subject: [PATCH 024/115] Fix all strong mode warnings. R=rnystrom@google.com Review URL: https://codereview.chromium.org//1843133004 . --- pkgs/pub_semver/.analysis_options | 2 ++ pkgs/pub_semver/CHANGELOG.md | 4 ++++ pkgs/pub_semver/lib/src/version.dart | 2 +- pkgs/pub_semver/lib/src/version_union.dart | 2 +- pkgs/pub_semver/pubspec.yaml | 2 +- 5 files changed, 9 insertions(+), 3 deletions(-) create mode 100644 pkgs/pub_semver/.analysis_options diff --git a/pkgs/pub_semver/.analysis_options b/pkgs/pub_semver/.analysis_options new file mode 100644 index 0000000000..a10d4c5a05 --- /dev/null +++ b/pkgs/pub_semver/.analysis_options @@ -0,0 +1,2 @@ +analyzer: + strong-mode: true diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index b505230e7a..78c85e723e 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,7 @@ +# 1.2.4 + +* Fix all remaining strong mode warnings. + # 1.2.3 * Addressed three strong mode warnings. diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 528c3a2016..98722897cb 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -4,7 +4,7 @@ import 'dart:math' as math; -import 'package:collection/equality.dart'; +import 'package:collection/collection.dart'; import 'patterns.dart'; import 'version_constraint.dart'; diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index 27993416c1..5d525647ef 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -55,7 +55,7 @@ class VersionUnion implements VersionConstraint { throw new ArgumentError('Unknown VersionConstraint type $constraint.'); } - (flattened as List).sort(compareMax); + flattened.sort(compareMax); var merged = []; for (var constraint in flattened) { diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 0ed3e3bfce..a026e25c73 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.2.3 +version: 1.2.4 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From 351e57c662610d9f33a7aa99b2053ca66d727e58 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Wed, 1 Jun 2016 17:56:00 -0700 Subject: [PATCH 025/115] Make the VersionUnion class public. This is the first of several pub_semver changes to support my solver work. R=rnystrom@google.com Review URL: https://codereview.chromium.org//2029263003 . --- pkgs/pub_semver/CHANGELOG.md | 6 + pkgs/pub_semver/lib/pub_semver.dart | 1 + .../lib/src/version_constraint.dart | 41 ++++- pkgs/pub_semver/lib/src/version_range.dart | 4 +- pkgs/pub_semver/lib/src/version_union.dart | 151 +++++++----------- pkgs/pub_semver/pubspec.yaml | 2 +- 6 files changed, 105 insertions(+), 100 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 78c85e723e..dc169fbe86 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,9 @@ +# 1.3.0 + +* Make the `VersionUnion` class public. This was previously used internally to + implement `new VersionConstraint.unionOf()` and `VersionConstraint.union()`. + Now it's public so you can use it too. + # 1.2.4 * Fix all remaining strong mode warnings. diff --git a/pkgs/pub_semver/lib/pub_semver.dart b/pkgs/pub_semver/lib/pub_semver.dart index fd2320e1cf..bfb7d8b704 100644 --- a/pkgs/pub_semver/lib/pub_semver.dart +++ b/pkgs/pub_semver/lib/pub_semver.dart @@ -5,3 +5,4 @@ export 'src/version.dart'; export 'src/version_constraint.dart'; export 'src/version_range.dart'; +export 'src/version_union.dart'; diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index f222b51991..9f55da0250 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -6,6 +6,7 @@ import 'patterns.dart'; import 'version.dart'; import 'version_range.dart'; import 'version_union.dart'; +import 'utils.dart'; /// A [VersionConstraint] is a predicate that can determine whether a given /// version is valid or not. @@ -172,8 +173,44 @@ abstract class VersionConstraint { /// 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 constraints) => - VersionUnion.create(constraints); + Iterable constraints) { + var flattened = constraints.expand((constraint) { + if (constraint.isEmpty) return []; + if (constraint is VersionUnion) return constraint.ranges; + return [constraint]; + }).toList(); + + if (flattened.isEmpty) return VersionConstraint.empty; + + if (flattened.any((constraint) => constraint.isAny)) { + return VersionConstraint.any; + } + + // Only allow Versions and VersionRanges here so we can more easily reason + // about everything in [flattened]. _EmptyVersions and VersionUnions are + // filtered out above. + for (var constraint in flattened) { + if (constraint is VersionRange) continue; + throw new ArgumentError('Unknown VersionConstraint type $constraint.'); + } + + flattened.sort(compareMax); + + var merged = []; + for (var constraint in flattened) { + // Merge this constraint with the previous one, but only if they touch. + if (merged.isEmpty || + (!merged.last.allowsAny(constraint) && + !areAdjacent(merged.last, constraint))) { + merged.add(constraint); + } else { + merged[merged.length - 1] = merged.last.union(constraint); + } + } + + if (merged.length == 1) return merged.single; + return new VersionUnion.fromRanges(merged); + } /// Returns `true` if this constraint allows no versions. bool get isEmpty; diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 668b9b28ee..145151f0af 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -124,7 +124,7 @@ class VersionRange implements VersionConstraint { if (other is Version) return allows(other); if (other is VersionUnion) { - return other.constraints.every((constraint) => allowsAll(constraint)); + return other.ranges.every((constraint) => allowsAll(constraint)); } if (other is VersionRange) { @@ -151,7 +151,7 @@ class VersionRange implements VersionConstraint { if (other is Version) return allows(other); if (other is VersionUnion) { - return other.constraints.any((constraint) => allowsAny(constraint)); + return other.ranges.any((constraint) => allowsAny(constraint)); } if (other is VersionRange) { diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index 5d525647ef..dbdadcf0d6 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -9,8 +9,8 @@ import 'version.dart'; import 'version_constraint.dart'; import 'version_range.dart'; -/// A (package-private) version constraint representing a union of multiple -/// disjoint version constraints. +/// A version constraint representing a union of multiple disjoint version +/// ranges. /// /// An instance of this will only be created if the version can't be represented /// as a non-compound value. @@ -23,101 +23,63 @@ class VersionUnion implements VersionConstraint { /// * Its contents are disjoint and non-adjacent. In other words, for any two /// constraints next to each other in the list, there's some version between /// those constraints that they don't match. - final List constraints; + final List ranges; bool get isEmpty => false; bool get isAny => false; - /// Returns the union of [constraints]. + /// Creates a union from a list of ranges with no pre-processing. /// - /// This ensures that an actual [VersionUnion] is only returned if necessary. - /// It also takes care of sorting and merging the constraints to ensure that - /// they're disjoint. - static VersionConstraint create(Iterable constraints) { - var flattened = constraints.expand((constraint) { - if (constraint.isEmpty) return []; - if (constraint is VersionUnion) return constraint.constraints; - return [constraint]; - }).toList(); - - if (flattened.isEmpty) return VersionConstraint.empty; - - if (flattened.any((constraint) => constraint.isAny)) { - return VersionConstraint.any; - } - - // Only allow Versions and VersionRanges here so we can more easily reason - // about everything in [flattened]. _EmptyVersions and VersionUnions are - // filtered out above. - for (var constraint in flattened) { - if (constraint is VersionRange) continue; - throw new ArgumentError('Unknown VersionConstraint type $constraint.'); - } - - flattened.sort(compareMax); - - var merged = []; - for (var constraint in flattened) { - // Merge this constraint with the previous one, but only if they touch. - if (merged.isEmpty || - (!merged.last.allowsAny(constraint) && - !areAdjacent(merged.last, constraint))) { - merged.add(constraint); - } else { - merged[merged.length - 1] = merged.last.union(constraint); - } - } - - if (merged.length == 1) return merged.single; - return new VersionUnion._(merged); - } - - VersionUnion._(this.constraints); + /// It's up to the caller to ensure that the invariants described in [ranges] + /// are maintained. They are not verified by this constructor. To + /// automatically ensure that they're maintained, use [new + /// VersionConstraint.unionOf] instead. + VersionUnion.fromRanges(this.ranges); bool allows(Version version) => - constraints.any((constraint) => constraint.allows(version)); + ranges.any((constraint) => constraint.allows(version)); bool allowsAll(VersionConstraint other) { - var ourConstraints = constraints.iterator; - var theirConstraints = _constraintsFor(other).iterator; + var ourRanges = ranges.iterator; + var theirRanges = _rangesFor(other).iterator; - // Because both lists of constraints are ordered by minimum version, we can + // Because both lists of ranges are ordered by minimum version, we can // safely move through them linearly here. - ourConstraints.moveNext(); - theirConstraints.moveNext(); - while (ourConstraints.current != null && theirConstraints.current != null) { - if (ourConstraints.current.allowsAll(theirConstraints.current)) { - theirConstraints.moveNext(); + ourRanges.moveNext(); + theirRanges.moveNext(); + while (ourRanges.current != null && theirRanges.current != null) { + if (ourRanges.current.allowsAll(theirRanges.current)) { + theirRanges.moveNext(); } else { - ourConstraints.moveNext(); + ourRanges.moveNext(); } } - // If our constraints have allowed all of their constraints, we'll have - // consumed all of them. - return theirConstraints.current == null; + // If our ranges have allowed all of their ranges, we'll have consumed all + // of them. + return theirRanges.current == null; } bool allowsAny(VersionConstraint other) { - var ourConstraints = constraints.iterator; - var theirConstraints = _constraintsFor(other).iterator; + var ourRanges = ranges.iterator; + var theirRanges = _rangesFor(other).iterator; - // Because both lists of constraints are ordered by minimum version, we can + // Because both lists of ranges are ordered by minimum version, we can // safely move through them linearly here. - ourConstraints.moveNext(); - theirConstraints.moveNext(); - while (ourConstraints.current != null && theirConstraints.current != null) { - if (ourConstraints.current.allowsAny(theirConstraints.current)) { + ourRanges.moveNext(); + theirRanges.moveNext(); + while (ourRanges.current != null && theirRanges.current != null) { + if (ourRanges.current.allowsAny(theirRanges.current)) { return true; } // Move the constraint with the higher max value forward. This ensures // that we keep both lists in sync as much as possible. - if (compareMax(ourConstraints.current, theirConstraints.current) < 0) { - ourConstraints.moveNext(); + if (compareMax(ourRanges.current, theirRanges.current) < 0) { + ourRanges.moveNext(); } else { - theirConstraints.moveNext(); + theirRanges.moveNext(); } } @@ -125,43 +87,42 @@ class VersionUnion implements VersionConstraint { } VersionConstraint intersect(VersionConstraint other) { - var ourConstraints = constraints.iterator; - var theirConstraints = _constraintsFor(other).iterator; + var ourRanges = ranges.iterator; + var theirRanges = _rangesFor(other).iterator; - // Because both lists of constraints are ordered by minimum version, we can + // Because both lists of ranges are ordered by minimum version, we can // safely move through them linearly here. - var newConstraints = []; - ourConstraints.moveNext(); - theirConstraints.moveNext(); - while (ourConstraints.current != null && theirConstraints.current != null) { - var intersection = ourConstraints.current - .intersect(theirConstraints.current); + var newRanges = []; + ourRanges.moveNext(); + theirRanges.moveNext(); + while (ourRanges.current != null && theirRanges.current != null) { + var intersection = ourRanges.current + .intersect(theirRanges.current); - if (!intersection.isEmpty) newConstraints.add(intersection); + if (!intersection.isEmpty) newRanges.add(intersection); // Move the constraint with the higher max value forward. This ensures // that we keep both lists in sync as much as possible, and that large - // constraints have a chance to match multiple small constraints that they - // contain. - if (compareMax(ourConstraints.current, theirConstraints.current) < 0) { - ourConstraints.moveNext(); + // ranges have a chance to match multiple small ranges that they contain. + if (compareMax(ourRanges.current, theirRanges.current) < 0) { + ourRanges.moveNext(); } else { - theirConstraints.moveNext(); + theirRanges.moveNext(); } } - if (newConstraints.isEmpty) return VersionConstraint.empty; - if (newConstraints.length == 1) return newConstraints.single; + if (newRanges.isEmpty) return VersionConstraint.empty; + if (newRanges.length == 1) return newRanges.single; - return new VersionUnion._(newConstraints); + return new VersionUnion.fromRanges(newRanges); } - /// Returns [constraint] as a list of constraints. + /// Returns [constraint] as a list of ranges. /// - /// This is used to normalize constraints of various types. - List _constraintsFor(VersionConstraint constraint) { + /// This is used to normalize ranges of various types. + List _rangesFor(VersionConstraint constraint) { if (constraint.isEmpty) return []; - if (constraint is VersionUnion) return constraint.constraints; + if (constraint is VersionUnion) return constraint.ranges; if (constraint is VersionRange) return [constraint]; throw new ArgumentError('Unknown VersionConstraint type $constraint.'); } @@ -171,10 +132,10 @@ class VersionUnion implements VersionConstraint { bool operator ==(other) { if (other is! VersionUnion) return false; - return const ListEquality().equals(constraints, other.constraints); + return const ListEquality().equals(ranges, other.ranges); } - int get hashCode => const ListEquality().hash(constraints); + int get hashCode => const ListEquality().hash(ranges); - String toString() => constraints.join(" or "); + String toString() => ranges.join(" or "); } diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index a026e25c73..53ef4d3970 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.2.4 +version: 1.3.0-dev author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From 7038accb8748853222c5700aa01364bbf5461c13 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Mon, 6 Jun 2016 15:59:04 -0700 Subject: [PATCH 026/115] Make VersionRange implement Comparable. This changes the ordering of ranges in a VersionUnion. It used to order solely by the upper bound; it now orders by lower bound, then upper bound. In addition to being a more intuitive ordering, this is easier to programatically work with, because iterating through the ranges reaches each one in the order of the versions it contains. R=rnystrom@google.com Review URL: https://codereview.chromium.org//2035983002 . --- pkgs/pub_semver/CHANGELOG.md | 3 + pkgs/pub_semver/lib/src/utils.dart | 13 +++-- pkgs/pub_semver/lib/src/version.dart | 38 +++++++------ .../lib/src/version_constraint.dart | 2 +- pkgs/pub_semver/lib/src/version_range.dart | 22 ++++++- pkgs/pub_semver/lib/src/version_union.dart | 12 ++-- pkgs/pub_semver/test/version_range_test.dart | 57 +++++++++++++++++++ 7 files changed, 118 insertions(+), 29 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index dc169fbe86..cf95427103 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -4,6 +4,9 @@ implement `new VersionConstraint.unionOf()` and `VersionConstraint.union()`. Now it's public so you can use it too. +* Make `VersionRange` implement `Comparable`. Ranges are ordered + first by lower bound, then by upper bound. + # 1.2.4 * Fix all remaining strong mode warnings. diff --git a/pkgs/pub_semver/lib/src/utils.dart b/pkgs/pub_semver/lib/src/utils.dart index 74d015ac1f..6493ddac51 100644 --- a/pkgs/pub_semver/lib/src/utils.dart +++ b/pkgs/pub_semver/lib/src/utils.dart @@ -15,10 +15,15 @@ bool areAdjacent(VersionRange range1, VersionRange range2) { /// A [Comparator] that compares the maximum versions of [range1] and [range2]. int compareMax(VersionRange range1, VersionRange range2) { - if (range1.max < range2.max) return -1; - if (range1.max > range2.max) return 1; + if (range1.max == null) { + if (range2.max == null) return 0; + return 1; + } else if (range2.max == null) { + return -1; + } - if (!range1.includeMax && range2.includeMax) return -1; - if (range1.includeMax && !range2.includeMax) return 1; + var result = range1.max.compareTo(range2.max); + if (result != 0) return result; + if (range1.includeMax != range2.includeMax) return range1.includeMax ? 1 : -1; return 0; } diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 98722897cb..f2662b9aaa 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -14,7 +14,7 @@ import 'version_range.dart'; final _equality = const IterableEquality(); /// A parsed semantic version number. -class Version implements Comparable, VersionConstraint, VersionRange { +class Version implements VersionConstraint, VersionRange { /// No released version: i.e. "0.0.0". static Version get none => new Version(0, 0, 0); @@ -267,22 +267,26 @@ class Version implements Comparable, VersionConstraint, VersionRange { 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); + int compareTo(VersionRange other) { + if (other is Version) { + 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); + } else { + return -other.compareTo(this); + } } String toString() => _text; diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 9f55da0250..68827a40c4 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -194,7 +194,7 @@ abstract class VersionConstraint { throw new ArgumentError('Unknown VersionConstraint type $constraint.'); } - flattened.sort(compareMax); + flattened.sort(); var merged = []; for (var constraint in flattened) { diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 145151f0af..a8d60698f8 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -2,6 +2,7 @@ // 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. +import 'utils.dart'; import 'version.dart'; import 'version_constraint.dart'; import 'version_union.dart'; @@ -11,7 +12,11 @@ import 'version_union.dart'; /// 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 { +/// +/// Version ranges are ordered first by their lower bounds, then by their upper +/// bounds. For example, `>=1.0.0 <2.0.0` is before `>=1.5.0 <2.0.0` is before +/// `>=1.5.0 <3.0.0`. +class VersionRange implements Comparable, VersionConstraint { /// The minimum end of the range. /// /// If [includeMin] is `true`, this will be the minimum allowed version. @@ -315,6 +320,21 @@ class VersionRange implements VersionConstraint { return new VersionConstraint.unionOf([this, other]); } + int compareTo(VersionRange other) { + if (min == null) { + if (other.min == null) return compareMax(this, other); + return -1; + } else if (other.min == null) { + return 1; + } + + var result = min.compareTo(other.min); + if (result != 0) return result; + if (includeMin != other.includeMin) return includeMin ? -1 : 1; + + return compareMax(this, other); + } + String toString() { var buffer = new StringBuffer(); diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index dbdadcf0d6..d0e1e2bf46 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -19,7 +19,7 @@ class VersionUnion implements VersionConstraint { /// /// This list has two invariants: /// - /// * Its contents are sorted from lowest to highest matched versions. + /// * Its contents are sorted using the standard ordering of [VersionRange]s. /// * Its contents are disjoint and non-adjacent. In other words, for any two /// constraints next to each other in the list, there's some version between /// those constraints that they don't match. @@ -74,8 +74,8 @@ class VersionUnion implements VersionConstraint { return true; } - // Move the constraint with the higher max value forward. This ensures - // that we keep both lists in sync as much as possible. + // Move the constraint with the lower max value forward. This ensures that + // we keep both lists in sync as much as possible. if (compareMax(ourRanges.current, theirRanges.current) < 0) { ourRanges.moveNext(); } else { @@ -101,9 +101,9 @@ class VersionUnion implements VersionConstraint { if (!intersection.isEmpty) newRanges.add(intersection); - // Move the constraint with the higher max value forward. This ensures - // that we keep both lists in sync as much as possible, and that large - // ranges have a chance to match multiple small ranges that they contain. + // Move the constraint with the lower max value forward. This ensures that + // we keep both lists in sync as much as possible, and that large ranges + // have a chance to match multiple small ranges that they contain. if (compareMax(ourRanges.current, theirRanges.current) < 0) { ourRanges.moveNext(); } else { diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index 9eaa980464..eaa473f033 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -445,4 +445,61 @@ main() { expect(new VersionRange().isEmpty, isFalse); expect(new VersionRange(min: v123, max: v124).isEmpty, isFalse); }); + + group('compareTo()', () { + test("orders by minimum first", () { + _expectComparesSmaller( + new VersionRange(min: v003, max: v080), + new VersionRange(min: v010, max: v072)); + _expectComparesSmaller( + new VersionRange(min: v003, max: v080), + new VersionRange(min: v010, max: v080)); + _expectComparesSmaller( + new VersionRange(min: v003, max: v080), + new VersionRange(min: v010, max: v114)); + }); + + test("orders by maximum second", () { + _expectComparesSmaller( + new VersionRange(min: v003, max: v010), + new VersionRange(min: v003, max: v072)); + }); + + test("includeMin comes before !includeMin", () { + _expectComparesSmaller( + new VersionRange(min: v003, max: v080, includeMin: true), + new VersionRange(min: v003, max: v080, includeMin: false)); + }); + + test("includeMax comes after !includeMax", () { + _expectComparesSmaller( + new VersionRange(min: v003, max: v080, includeMax: false), + new VersionRange(min: v003, max: v080, includeMax: true)); + }); + + test("no minimum comes before small minimum", () { + _expectComparesSmaller( + new VersionRange(max: v010), + new VersionRange(min: v003, max: v010)); + _expectComparesSmaller( + new VersionRange(max: v010, includeMin: true), + new VersionRange(min: v003, max: v010)); + }); + + test("no maximium comes after large maximum", () { + _expectComparesSmaller( + new VersionRange(min: v003, max: v300), + new VersionRange(min: v003)); + _expectComparesSmaller( + new VersionRange(min: v003, max: v300), + new VersionRange(min: v003, includeMax: true)); + }); + }); +} + +void _expectComparesSmaller(VersionRange smaller, VersionRange larger) { + expect(smaller.compareTo(larger), lessThan(0), + reason: "expected $smaller to sort below $larger"); + expect(larger.compareTo(smaller), greaterThan(0), + reason: "expected $larger to sort above $smaller"); } From bf1cbd980563fe38a2e7289c1e5631a8eee80bcd Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Wed, 8 Jun 2016 16:41:52 -0700 Subject: [PATCH 027/115] Add VersionConstraint.difference(). See dart-lang/pubdart-lang/pub_semver#912 R=rnystrom@google.com Review URL: https://codereview.chromium.org//2045803002 . --- pkgs/pub_semver/CHANGELOG.md | 3 + pkgs/pub_semver/lib/src/utils.dart | 55 ++++-- pkgs/pub_semver/lib/src/version.dart | 3 + .../lib/src/version_constraint.dart | 13 +- pkgs/pub_semver/lib/src/version_range.dart | 142 +++++++++++---- pkgs/pub_semver/lib/src/version_union.dart | 78 ++++++++- pkgs/pub_semver/pubspec.yaml | 2 +- pkgs/pub_semver/test/version_range_test.dart | 162 +++++++++++++++++- pkgs/pub_semver/test/version_test.dart | 21 +++ pkgs/pub_semver/test/version_union_test.dart | 58 +++++++ 10 files changed, 482 insertions(+), 55 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index cf95427103..db3d320ff4 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -4,6 +4,9 @@ implement `new VersionConstraint.unionOf()` and `VersionConstraint.union()`. Now it's public so you can use it too. +* Added `VersionConstraint.difference()`. This returns a constraint matching all + versions matched by one constraint but not another. + * Make `VersionRange` implement `Comparable`. Ranges are ordered first by lower bound, then by upper bound. diff --git a/pkgs/pub_semver/lib/src/utils.dart b/pkgs/pub_semver/lib/src/utils.dart index 6493ddac51..efe105abed 100644 --- a/pkgs/pub_semver/lib/src/utils.dart +++ b/pkgs/pub_semver/lib/src/utils.dart @@ -13,17 +13,46 @@ bool areAdjacent(VersionRange range1, VersionRange range2) { (!range1.includeMax && range2.includeMin); } -/// A [Comparator] that compares the maximum versions of [range1] and [range2]. -int compareMax(VersionRange range1, VersionRange range2) { - if (range1.max == null) { - if (range2.max == null) return 0; - return 1; - } else if (range2.max == null) { - return -1; - } - - var result = range1.max.compareTo(range2.max); - if (result != 0) return result; - if (range1.includeMax != range2.includeMax) return range1.includeMax ? 1 : -1; - return 0; +/// Returns whether [range1] allows lower versions than [range2]. +bool allowsLower(VersionRange range1, VersionRange range2) { + if (range1.min == null) return range2.min != null; + if (range2.min == null) return false; + + var comparison = range1.min.compareTo(range2.min); + if (comparison == -1) return true; + if (comparison == 1) return false; + return range1.includeMin && !range2.includeMin; +} + +/// Returns whether [range1] allows higher versions than [range2]. +bool allowsHigher(VersionRange range1, VersionRange range2) { + if (range1.max == null) return range2.max != null; + if (range2.max == null) return false; + + var comparison = range1.max.compareTo(range2.max); + if (comparison == 1) return true; + if (comparison == -1) return false; + return range1.includeMax && !range2.includeMax; +} + +/// Returns whether [range1] allows only versions lower than those allowed by +/// [range2]. +bool strictlyLower(VersionRange range1, VersionRange range2) { + if (range1.max == null || range2.min == null) return false; + + var comparison = range1.max.compareTo(range2.min); + if (comparison == -1) return true; + if (comparison == 1) return false; + return !range1.includeMax || !range2.includeMin; +} + +/// Returns whether [range1] allows only versions higher than those allowed by +/// [range2]. +bool strictlyHigher(VersionRange range1, VersionRange range2) { + if (range1.min == null || range2.max == null) return false; + + var comparison = range1.min.compareTo(range2.max); + if (comparison == 1) return true; + if (comparison == -1) return false; + return !range1.includeMin || !range2.includeMax; } diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index f2662b9aaa..2d43a1aa81 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -267,6 +267,9 @@ class Version implements VersionConstraint, VersionRange { return new VersionConstraint.unionOf([this, other]); } + VersionConstraint difference(VersionConstraint other) => + other.allows(this) ? VersionConstraint.empty : this; + int compareTo(VersionRange other) { if (other is Version) { if (major != other.major) return major.compareTo(other.major); diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 68827a40c4..edd8abd072 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -229,13 +229,17 @@ abstract class VersionConstraint { /// allows. bool allowsAny(VersionConstraint other); - /// Creates a new [VersionConstraint] that only allows [Version]s allowed by - /// both this and [other]. + /// Returns a [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]. + /// Returns a [VersionConstraint] that allows [Versions]s allowed by either + /// this or [other]. VersionConstraint union(VersionConstraint other); + + /// Returns a [VersionConstraint] that allows [Version]s allowed by this but + /// not [other]. + VersionConstraint difference(VersionConstraint other); } class _EmptyVersion implements VersionConstraint { @@ -248,6 +252,7 @@ class _EmptyVersion implements VersionConstraint { bool allowsAny(VersionConstraint other) => false; VersionConstraint intersect(VersionConstraint other) => this; VersionConstraint union(VersionConstraint other) => other; + VersionConstraint difference(VersionConstraint other) => this; String toString() => ''; } diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index a8d60698f8..ffa50ab6b7 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -160,37 +160,7 @@ class VersionRange implements Comparable, VersionConstraint { } if (other is VersionRange) { - // If neither range has a minimum, they'll overlap at some point. - // - // ... this ] - // ... other ] - if (min == null && other.min == null) return true; - - // If this range has a lower minimum than the other range, it overlaps as - // long as its maximum is higher than or the same as the other range's - // minimum. - // - // [ this ] [ this ] - // [ other ] [ other ] - if (min == null || (other.min != null && min < other.min)) { - 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 this range has a higher minimum than the other range, it overlaps as - // long as its minimum is lower than or the same as the other range's - // maximum. - // - // [ this ] [ this ] - // [ other ] [ other ] - 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; + return !strictlyLower(other, this) && !strictlyHigher(other, this); } throw new ArgumentError('Unknown VersionConstraint type $other.'); @@ -320,9 +290,100 @@ class VersionRange implements Comparable, VersionConstraint { return new VersionConstraint.unionOf([this, other]); } + VersionConstraint difference(VersionConstraint other) { + if (other.isEmpty) return this; + + if (other is Version) { + if (!allows(other)) return this; + + if (other == min) { + if (!includeMin) return this; + return new VersionRange( + min: min, max: max, + includeMin: false, includeMax: includeMax); + } + + if (other == max) { + if (!includeMax) return this; + return new VersionRange( + min: min, max: max, + includeMin: includeMin, includeMax: false); + } + + return new VersionUnion.fromRanges([ + new VersionRange( + min: min, max: other, + includeMin: includeMin, includeMax: false), + new VersionRange( + min: other, max: max, + includeMin: false, includeMax: includeMax) + ]); + } else if (other is VersionRange) { + if (!allowsAny(other)) return this; + + VersionConstraint before; + if (!allowsLower(this, other)) { + before = VersionConstraint.empty; + } else if (min == other.min) { + assert(includeMin && !other.includeMin); + assert(min != null); + before = min; + } else { + before = new VersionRange( + min: min, max: other.min, + includeMin: includeMin, includeMax: !other.includeMin); + } + + VersionConstraint after; + if (!allowsHigher(this, other)) { + after = VersionConstraint.empty; + } else if (max == other.max) { + assert(includeMax && !other.includeMax); + assert(max != null); + after = max; + } else { + after = new VersionRange( + min: other.max, max: max, + includeMin: !other.includeMax, includeMax: includeMax); + } + + if (before == VersionConstraint.empty) return after; + if (after == VersionConstraint.empty) return before; + return new VersionUnion.fromRanges([before, after]); + } else if (other is VersionUnion) { + var ranges = []; + var current = this; + + for (var range in other.ranges) { + // Skip any ranges that are strictly lower than [current]. + if (strictlyLower(range, current)) continue; + + // If we reach a range strictly higher than [current], no more ranges + // will be relevant so we can bail early. + if (strictlyHigher(range, current)) break; + + var difference = current.difference(range); + if (difference is VersionUnion) { + // If [range] split [current] in half, we only need to continue + // checking future ranges against the latter half. + assert(difference.ranges.length == 2); + ranges.add(difference.ranges.first); + current = difference.ranges.last; + } else { + current = difference as VersionRange; + } + } + + if (ranges.isEmpty) return current; + return new VersionUnion.fromRanges(ranges..add(current)); + } + + throw new ArgumentError('Unknown VersionConstraint type $other.'); + } + int compareTo(VersionRange other) { if (min == null) { - if (other.min == null) return compareMax(this, other); + if (other.min == null) return _compareMax(other); return -1; } else if (other.min == null) { return 1; @@ -332,7 +393,22 @@ class VersionRange implements Comparable, VersionConstraint { if (result != 0) return result; if (includeMin != other.includeMin) return includeMin ? -1 : 1; - return compareMax(this, other); + return _compareMax(other); + } + + /// Compares the maximum values of [this] and [other]. + int _compareMax(VersionRange other) { + if (max == null) { + if (other.max == null) return 0; + return 1; + } else if (other.max == null) { + return -1; + } + + var result = max.compareTo(other.max); + if (result != 0) return result; + if (includeMax != other.includeMax) return includeMax ? 1 : -1; + return 0; } String toString() { diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index d0e1e2bf46..a26cb528d8 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -76,7 +76,7 @@ class VersionUnion implements VersionConstraint { // Move the constraint with the lower max value forward. This ensures that // we keep both lists in sync as much as possible. - if (compareMax(ourRanges.current, theirRanges.current) < 0) { + if (allowsHigher(theirRanges.current, ourRanges.current)) { ourRanges.moveNext(); } else { theirRanges.moveNext(); @@ -104,7 +104,7 @@ class VersionUnion implements VersionConstraint { // Move the constraint with the lower max value forward. This ensures that // we keep both lists in sync as much as possible, and that large ranges // have a chance to match multiple small ranges that they contain. - if (compareMax(ourRanges.current, theirRanges.current) < 0) { + if (allowsHigher(theirRanges.current, ourRanges.current)) { ourRanges.moveNext(); } else { theirRanges.moveNext(); @@ -117,6 +117,80 @@ class VersionUnion implements VersionConstraint { return new VersionUnion.fromRanges(newRanges); } + VersionConstraint difference(VersionConstraint other) { + var ourRanges = ranges.iterator; + var theirRanges = _rangesFor(other).iterator; + + var newRanges = []; + ourRanges.moveNext(); + theirRanges.moveNext(); + var current = ourRanges.current; + + theirNextRange() { + if (theirRanges.moveNext()) return true; + + // If there are no more of their ranges, none of the rest of our ranges + // need to be subtracted so we can add them as-is. + newRanges.add(current); + while (ourRanges.moveNext()) { + newRanges.add(ourRanges.current); + } + return false; + } + + ourNextRange({bool includeCurrent: true}) { + if (includeCurrent) newRanges.add(current); + if (!ourRanges.moveNext()) return false; + current = ourRanges.current; + return true; + } + + while (true) { + // If the current ranges are disjoint, move the lowest one forward. + if (strictlyLower(theirRanges.current, current)) { + if (!theirNextRange()) break; + continue; + } + + if (strictlyHigher(theirRanges.current, current)) { + if (!ourNextRange()) break; + continue; + } + + // If we're here, we know [theirRanges.current] overlaps [current]. + var difference = current.difference(theirRanges.current); + if (difference is VersionUnion) { + // If their range split [current] in half, we only need to continue + // checking future ranges against the latter half. + assert(difference.ranges.length == 2); + newRanges.add(difference.ranges.first); + current = difference.ranges.last; + + // Since their range split [current], it definitely doesn't allow higher + // versions, so we should move their ranges forward. + if (!theirNextRange()) break; + } else if (difference.isEmpty) { + if (!ourNextRange(includeCurrent: false)) break; + } else { + current = difference as VersionRange; + + // Move the constraint with the lower max value forward. This ensures + // that we keep both lists in sync as much as possible, and that large + // ranges have a chance to subtract or be subtracted by multiple small + // ranges that they contain. + if (allowsHigher(current, theirRanges.current)) { + if (!theirNextRange()) break; + } else { + if (!ourNextRange()) break; + } + } + } + + if (newRanges.isEmpty) return VersionConstraint.empty; + if (newRanges.length == 1) return newRanges.single; + return new VersionUnion.fromRanges(newRanges); + } + /// Returns [constraint] as a list of ranges. /// /// This is used to normalize ranges of various types. diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 53ef4d3970..531ace6ba8 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.3.0-dev +version: 1.3.0 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index eaa473f033..a2dbf98108 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -340,8 +340,8 @@ main() { }); test('adjacent ranges allow no versions if exclusive', () { - var a = new VersionRange(min: v114, max: v124, includeMax: false); - var b = new VersionRange(min: v124, max: v200, includeMin: true); + var a = new VersionRange(min: v114, max: v124); + var b = new VersionRange(min: v124, max: v200); expect(a.intersect(b).isEmpty, isTrue); }); @@ -441,6 +441,164 @@ main() { }); }); + group('difference()', () { + test("with an empty range returns the original range", () { + expect( + new VersionRange(min: v003, max: v114) + .difference(VersionConstraint.empty), + equals(new VersionRange(min: v003, max: v114))); + }); + + test("with a version outside the range returns the original range", () { + expect( + new VersionRange(min: v003, max: v114).difference(v200), + equals(new VersionRange(min: v003, max: v114))); + }); + + test("with a version in the range splits the range", () { + expect( + new VersionRange(min: v003, max: v114).difference(v072), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + new VersionRange(min: v072, max: v114) + ]))); + }); + + test("with the max version makes the max exclusive", () { + expect( + new VersionRange(min: v003, max: v114, includeMax: true) + .difference(v114), + equals(new VersionRange(min: v003, max: v114))); + }); + + test("with the min version makes the min exclusive", () { + expect( + new VersionRange(min: v003, max: v114, includeMin: true) + .difference(v003), + equals(new VersionRange(min: v003, max: v114))); + }); + + test("with a disjoint range returns the original", () { + expect( + new VersionRange(min: v003, max: v114) + .difference(new VersionRange(min: v123, max: v140)), + equals(new VersionRange(min: v003, max: v114))); + }); + + test("with an adjacent range returns the original", () { + expect( + new VersionRange(min: v003, max: v114, includeMax: true) + .difference(new VersionRange(min: v114, max: v140)), + equals(new VersionRange(min: v003, max: v114, includeMax: true))); + }); + + test("with a range at the beginning cuts off the beginning of the range", + () { + expect( + new VersionRange(min: v080, max: v130) + .difference(new VersionRange(min: v010, max: v114)), + equals(new VersionRange(min: v114, max: v130, includeMin: true))); + expect( + new VersionRange(min: v080, max: v130) + .difference(new VersionRange(max: v114)), + equals(new VersionRange(min: v114, max: v130, includeMin: true))); + expect( + new VersionRange(min: v080, max: v130).difference( + new VersionRange(min: v010, max: v114, includeMax: true)), + equals(new VersionRange(min: v114, max: v130))); + expect( + new VersionRange(min: v080, max: v130, includeMin: true).difference( + new VersionRange(min: v010, max: v080, includeMax: true)), + equals(new VersionRange(min: v080, max: v130))); + expect( + new VersionRange(min: v080, max: v130, includeMax: true) + .difference(new VersionRange(min: v080, max: v130)), + equals(v130)); + }); + + test("with a range at the end cuts off the end of the range", + () { + expect( + new VersionRange(min: v080, max: v130) + .difference(new VersionRange(min: v114, max: v140)), + equals(new VersionRange(min: v080, max: v114, includeMax: true))); + expect( + new VersionRange(min: v080, max: v130) + .difference(new VersionRange(min: v114)), + equals(new VersionRange(min: v080, max: v114, includeMax: true))); + expect( + new VersionRange(min: v080, max: v130).difference( + new VersionRange(min: v114, max: v140, includeMin: true)), + equals(new VersionRange(min: v080, max: v114))); + expect( + new VersionRange(min: v080, max: v130, includeMax: true).difference( + new VersionRange(min: v130, max: v140, includeMin: true)), + equals(new VersionRange(min: v080, max: v130))); + expect( + new VersionRange(min: v080, max: v130, includeMin: true) + .difference(new VersionRange(min: v080, max: v130)), + equals(v080)); + }); + + test("with a range in the middle cuts the range in half", () { + expect( + new VersionRange(min: v003, max: v130) + .difference(new VersionRange(min: v072, max: v114)), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072, includeMax: true), + new VersionRange(min: v114, max: v130, includeMin: true) + ]))); + }); + + test("with a totally covering range returns empty", () { + expect( + new VersionRange(min: v114, max: v200) + .difference(new VersionRange(min: v072, max: v300)), + isEmpty); + expect( + new VersionRange(min: v003, max: v114) + .difference(new VersionRange(min: v003, max: v114)), + isEmpty); + expect( + new VersionRange( + min: v003, max: v114, includeMin: true, includeMax: true) + .difference(new VersionRange( + min: v003, max: v114, includeMin: true, includeMax: true)), + isEmpty); + }); + + test("with a version union that doesn't cover the range, returns the " + "original", () { + expect( + new VersionRange(min: v114, max: v140) + .difference(new VersionConstraint.unionOf([v010, v200])), + equals(new VersionRange(min: v114, max: v140))); + }); + + test("with a version union that intersects the ends, chops them off", () { + expect( + new VersionRange(min: v114, max: v140) + .difference(new VersionConstraint.unionOf([ + new VersionRange(min: v080, max: v123), + new VersionRange(min: v130, max: v200) + ])), + equals(new VersionRange( + min: v123, max: v130, includeMin: true, includeMax: true))); + }); + + test("with a version union that intersects the middle, chops it up", () { + expect( + new VersionRange(min: v114, max: v140) + .difference(new VersionConstraint.unionOf([v123, v124, v130])), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v114, max: v123), + new VersionRange(min: v123, max: v124), + new VersionRange(min: v124, max: v130), + new VersionRange(min: v130, max: v140) + ]))); + }); + }); + test('isEmpty', () { expect(new VersionRange().isEmpty, isFalse); expect(new VersionRange(min: v123, max: v124).isEmpty, isFalse); diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index ddc6c94b5a..b278d4c611 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -202,6 +202,27 @@ main() { }); }); + group('difference()', () { + test("with the same version returns an empty constraint", () { + expect(v123.difference(v123), isEmpty); + }); + + test("with a different version returns the original version", () { + expect(v123.difference(v080), equals(v123)); + }); + + test("returns an empty constraint with a range that contains the version", + () { + expect(v123.difference(new VersionRange(min: v114, max: v124)), isEmpty); + }); + + test("returns the version constraint with a range that doesn't contain it", + () { + expect(v123.difference(new VersionRange(min: v140, max: v300)), + equals(v123)); + }); + }); + test('isEmpty', () { expect(v123.isEmpty, isFalse); }); diff --git a/pkgs/pub_semver/test/version_union_test.dart b/pkgs/pub_semver/test/version_union_test.dart index f3518a06ae..06a427dd99 100644 --- a/pkgs/pub_semver/test/version_union_test.dart +++ b/pkgs/pub_semver/test/version_union_test.dart @@ -349,4 +349,62 @@ main() { }); }); }); + + group("difference()", () { + test("ignores ranges that don't intersect", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v072, max: v080), + new VersionRange(min: v123, max: v130) + ]).difference(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v010), + new VersionRange(min: v080, max: v123), + new VersionRange(min: v140) + ])), equals(new VersionConstraint.unionOf([ + new VersionRange(min: v072, max: v080), + new VersionRange(min: v123, max: v130) + ]))); + }); + + test("removes overlapping portions", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v130) + ]).difference(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + new VersionRange(min: v124) + ])), equals(new VersionConstraint.unionOf([ + new VersionRange(min: v072, max: v080, includeMin: true), + new VersionRange(min: v123, max: v124, includeMax: true) + ]))); + }); + + test("removes multiple portions from the same range", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v114), + new VersionRange(min: v130, max: v200) + ]).difference(new VersionConstraint.unionOf([v072, v080])), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v072), + new VersionRange(min: v072, max: v080), + new VersionRange(min: v080, max: v114), + new VersionRange(min: v130, max: v200) + ]))); + }); + + test("removes the same range from multiple ranges", () { + expect(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v072), + new VersionRange(min: v080, max: v123), + new VersionRange(min: v124, max: v130), + new VersionRange(min: v200, max: v234), + new VersionRange(min: v250, max: v300) + ]).difference(new VersionRange(min: v114, max: v201)), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v072), + new VersionRange(min: v080, max: v114, includeMax: true), + new VersionRange(min: v201, max: v234, includeMin: true), + new VersionRange(min: v250, max: v300) + ]))); + }); + }); } \ No newline at end of file From 049f31212fb58e5fbc8e6204dce74d20a5191c9b Mon Sep 17 00:00:00 2001 From: William Hesse Date: Thu, 7 Jul 2016 10:01:30 +0200 Subject: [PATCH 028/115] Use the test runner on the test bots for this package BUG= R=nweiz@google.com Review URL: https://codereview.chromium.org//2123933002 . --- pkgs/pub_semver/.test_config | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 pkgs/pub_semver/.test_config diff --git a/pkgs/pub_semver/.test_config b/pkgs/pub_semver/.test_config new file mode 100644 index 0000000000..25355634fc --- /dev/null +++ b/pkgs/pub_semver/.test_config @@ -0,0 +1,3 @@ +{ + "test_package": true +} From a9d721a5a1225b6ed9a8ca2d5d9f49f8f0c98e93 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Wed, 16 Nov 2016 12:25:51 -0800 Subject: [PATCH 029/115] Fix a new strong mode error. (dart-lang/pub_semver#13) Closes dart-lang/pub_semver#12 --- pkgs/pub_semver/CHANGELOG.md | 4 ++++ pkgs/pub_semver/lib/src/version_range.dart | 4 ++-- pkgs/pub_semver/pubspec.yaml | 2 +- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index db3d320ff4..3ba6f6ea1d 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,7 @@ +# 1.3.1 + +* Fix a new strong mode error. + # 1.3.0 * Make the `VersionUnion` class public. This was previously used internally to diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index ffa50ab6b7..861ae46dbf 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -321,7 +321,7 @@ class VersionRange implements Comparable, VersionConstraint { } else if (other is VersionRange) { if (!allowsAny(other)) return this; - VersionConstraint before; + VersionRange before; if (!allowsLower(this, other)) { before = VersionConstraint.empty; } else if (min == other.min) { @@ -334,7 +334,7 @@ class VersionRange implements Comparable, VersionConstraint { includeMin: includeMin, includeMax: !other.includeMin); } - VersionConstraint after; + VersionRange after; if (!allowsHigher(this, other)) { after = VersionConstraint.empty; } else if (max == other.max) { diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 531ace6ba8..1712f6eb72 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.3.0 +version: 1.3.1 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From a0429ed8d8be51af36d1785fa7eb61352014849c Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Mon, 21 Nov 2016 14:33:37 -0800 Subject: [PATCH 030/115] Fix a checked mode bug. (dart-lang/pub_semver#14) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit I missed this because I was running a version of test that relied on pub to turn on checked mode 😩. --- pkgs/pub_semver/CHANGELOG.md | 4 ++++ pkgs/pub_semver/lib/src/version_range.dart | 9 +++++---- pkgs/pub_semver/pubspec.yaml | 2 +- 3 files changed, 10 insertions(+), 5 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 3ba6f6ea1d..6d54692d96 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,7 @@ +# 1.3.2 + +* Fix a checked-mode error in `VersionRange.difference()`. + # 1.3.1 * Fix a new strong mode error. diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 861ae46dbf..580f3febab 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -323,7 +323,7 @@ class VersionRange implements Comparable, VersionConstraint { VersionRange before; if (!allowsLower(this, other)) { - before = VersionConstraint.empty; + before = null; } else if (min == other.min) { assert(includeMin && !other.includeMin); assert(min != null); @@ -336,7 +336,7 @@ class VersionRange implements Comparable, VersionConstraint { VersionRange after; if (!allowsHigher(this, other)) { - after = VersionConstraint.empty; + after = null; } else if (max == other.max) { assert(includeMax && !other.includeMax); assert(max != null); @@ -347,8 +347,9 @@ class VersionRange implements Comparable, VersionConstraint { includeMin: !other.includeMax, includeMax: includeMax); } - if (before == VersionConstraint.empty) return after; - if (after == VersionConstraint.empty) return before; + if (before == null && after == null) return VersionConstraint.empty; + if (before == null) return after; + if (after == null) return before; return new VersionUnion.fromRanges([before, after]); } else if (other is VersionUnion) { var ranges = []; diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 1712f6eb72..2fe68a1f44 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.3.1 +version: 1.3.2 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From 11c2f1cc946f9b2b1598e566c5049826cb02b4f9 Mon Sep 17 00:00:00 2001 From: Sam Rawlins Date: Thu, 26 Jan 2017 08:48:14 -0800 Subject: [PATCH 031/115] Fix strong mode error in test (dart-lang/pub_semver#15) --- pkgs/pub_semver/test/version_range_test.dart | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index a2dbf98108..23d771049d 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -327,10 +327,12 @@ main() { var a = new VersionRange(min: v123, max: v250); var b = new VersionRange(min: v200, max: v300); var intersect = a.intersect(b); - expect(intersect.min, equals(v200)); - expect(intersect.max, equals(v250)); - expect(intersect.includeMin, isFalse); - expect(intersect.includeMax, isFalse); + expect(intersect, new isInstanceOf()); + var intersectRange = intersect as VersionRange; + expect(intersectRange.min, equals(v200)); + expect(intersectRange.max, equals(v250)); + expect(intersectRange.includeMin, isFalse); + expect(intersectRange.includeMax, isFalse); }); test('a non-overlapping range allows no versions', () { From c8859a59688e71fb9d3a2a966340fbfaf45f6239 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Wed, 30 Aug 2017 13:55:49 -0700 Subject: [PATCH 032/115] Add Travis CI support --- pkgs/pub_semver/.travis.yml | 19 +++++++++++++++++++ pkgs/pub_semver/pubspec.yaml | 2 +- 2 files changed, 20 insertions(+), 1 deletion(-) create mode 100644 pkgs/pub_semver/.travis.yml diff --git a/pkgs/pub_semver/.travis.yml b/pkgs/pub_semver/.travis.yml new file mode 100644 index 0000000000..6788deead4 --- /dev/null +++ b/pkgs/pub_semver/.travis.yml @@ -0,0 +1,19 @@ +language: dart +sudo: false +dart: + - dev + - stable + - 1.21.1 + +dart_task: + - test + - dartfmt + - dartanalyzer + +# Only building master means that we don't run two builds for each pull request. +branches: + only: [master] + +cache: + directories: + - $HOME/.pub-cache diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 2fe68a1f44..93fb03555d 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.3.2 +version: 1.3.3-dev author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From 24ee102718bfbad41dcc37e1667ac7f8c0eab003 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Wed, 30 Aug 2017 13:56:17 -0700 Subject: [PATCH 033/115] Rename analysis_options --- pkgs/pub_semver/{.analysis_options => analysis_options.yaml} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename pkgs/pub_semver/{.analysis_options => analysis_options.yaml} (100%) diff --git a/pkgs/pub_semver/.analysis_options b/pkgs/pub_semver/analysis_options.yaml similarity index 100% rename from pkgs/pub_semver/.analysis_options rename to pkgs/pub_semver/analysis_options.yaml From 9a0299ed5f12eb481a8c3722e65c01e0b0c8f463 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Wed, 30 Aug 2017 13:58:28 -0700 Subject: [PATCH 034/115] Sort directives --- pkgs/pub_semver/lib/src/version_constraint.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index edd8abd072..6fd4384470 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -3,10 +3,10 @@ // BSD-style license that can be found in the LICENSE file. import 'patterns.dart'; +import 'utils.dart'; import 'version.dart'; import 'version_range.dart'; import 'version_union.dart'; -import 'utils.dart'; /// A [VersionConstraint] is a predicate that can determine whether a given /// version is valid or not. From 3779e27aa162f351523bf3c7ddc93fef9436b3d2 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Wed, 30 Aug 2017 14:06:14 -0700 Subject: [PATCH 035/115] dartfmt --- pkgs/pub_semver/lib/src/patterns.dart | 7 +- pkgs/pub_semver/lib/src/version.dart | 38 +- .../lib/src/version_constraint.dart | 24 +- pkgs/pub_semver/lib/src/version_range.dart | 81 +-- pkgs/pub_semver/lib/src/version_union.dart | 3 +- pkgs/pub_semver/test/utils.dart | 39 +- .../test/version_constraint_test.dart | 150 +++--- pkgs/pub_semver/test/version_range_test.dart | 151 +++--- pkgs/pub_semver/test/version_test.dart | 33 +- pkgs/pub_semver/test/version_union_test.dart | 481 ++++++++++-------- 10 files changed, 554 insertions(+), 453 deletions(-) diff --git a/pkgs/pub_semver/lib/src/patterns.dart b/pkgs/pub_semver/lib/src/patterns.dart index 4e57ec908e..c4d75d4b76 100644 --- a/pkgs/pub_semver/lib/src/patterns.dart +++ b/pkgs/pub_semver/lib/src/patterns.dart @@ -3,10 +3,9 @@ // BSD-style license that can be found in the LICENSE file. /// Regex that matches a version number at the beginning of a string. -final START_VERSION = new RegExp( - r'^' // Start at beginning. - r'(\d+).(\d+).(\d+)' // Version number. - r'(-([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?' // Pre-release. +final START_VERSION = new RegExp(r'^' // Start at beginning. + r'(\d+).(\d+).(\d+)' // Version number. + r'(-([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?' // Pre-release. r'(\+([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?'); // Build. /// Like [START_VERSION] but matches the entire string. diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 2d43a1aa81..6665873de0 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -89,15 +89,15 @@ class Version implements VersionConstraint, VersionRange { bool get includeMax => true; Version._(this.major, this.minor, this.patch, String preRelease, String build, - this._text) + 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.'); + 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.'); } /// Creates a new [Version] object. @@ -137,7 +137,8 @@ class Version implements VersionConstraint, VersionRange { static Version primary(List versions) { var primary; for (var version in versions) { - if (primary == null || (!version.isPreRelease && primary.isPreRelease) || + if (primary == null || + (!version.isPreRelease && primary.isPreRelease) || (version.isPreRelease == primary.isPreRelease && version > primary)) { primary = version; } @@ -161,13 +162,18 @@ class Version implements VersionConstraint, VersionRange { bool operator ==(other) { if (other is! Version) return false; - return major == other.major && minor == other.minor && + return major == other.major && + minor == other.minor && patch == other.patch && _equality.equals(preRelease, other.preRelease) && _equality.equals(build, other.build); } - int get hashCode => major ^ minor ^ patch ^ _equality.hash(preRelease) ^ + int get hashCode => + major ^ + minor ^ + patch ^ + _equality.hash(preRelease) ^ _equality.hash(build); bool operator <(Version other) => compareTo(other) < 0; @@ -253,14 +259,18 @@ class Version implements VersionConstraint, VersionRange { if (other is VersionRange) { if (other.min == this) { return new VersionRange( - min: other.min, max: other.max, - includeMin: true, includeMax: other.includeMax); + 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); + min: other.min, + max: other.max, + includeMin: other.includeMin, + includeMax: true); } } diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 6fd4384470..36bbd9aba0 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -81,10 +81,14 @@ abstract class VersionConstraint { } switch (op) { - case '<=': return new VersionRange(max: version, includeMax: true); - case '<': return new VersionRange(max: version, includeMax: false); - case '>=': return new VersionRange(min: version, includeMin: true); - case '>': return new VersionRange(min: version, includeMin: false); + case '<=': + return new VersionRange(max: version, includeMax: true); + case '<': + return new VersionRange(max: version, includeMax: false); + case '>=': + return new VersionRange(min: version, includeMin: true); + case '>': + return new VersionRange(min: version, includeMin: false); } throw "Unreachable."; } @@ -172,8 +176,7 @@ abstract class VersionConstraint { /// /// 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 constraints) { + factory VersionConstraint.unionOf(Iterable constraints) { var flattened = constraints.expand((constraint) { if (constraint.isEmpty) return []; if (constraint is VersionUnion) return constraint.ranges; @@ -257,9 +260,12 @@ class _EmptyVersion implements VersionConstraint { } class _CompatibleWithVersionRange extends VersionRange { - _CompatibleWithVersionRange(Version version) : super( - min: version, includeMin: true, - max: version.nextBreaking, includeMax: false); + _CompatibleWithVersionRange(Version version) + : super( + min: version, + includeMin: true, + max: version.nextBreaking, + includeMax: false); String toString() => '^$min'; } diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 580f3febab..99f2924263 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -53,8 +53,8 @@ class VersionRange implements Comparable, VersionConstraint { /// /// If [includeMin] is `true`, then the minimum end of the range is inclusive. /// Likewise, passing [includeMax] as `true` makes the upper end inclusive. - VersionRange({this.min, this.max, - this.includeMin: false, this.includeMax: false}) { + VersionRange( + {this.min, this.max, this.includeMin: false, this.includeMax: false}) { if (min != null && max != null && min > max) { throw new ArgumentError( 'Minimum version ("$min") must be less than maximum ("$max").'); @@ -65,13 +65,16 @@ class VersionRange implements Comparable, VersionConstraint { if (other is! VersionRange) return false; return min == other.min && - max == other.max && - includeMin == other.includeMin && - includeMax == other.includeMax; + max == other.max && + includeMin == other.includeMin && + includeMax == other.includeMax; } - int get hashCode => min.hashCode ^ (max.hashCode * 3) ^ - (includeMin.hashCode * 5) ^ (includeMax.hashCode * 7); + int get hashCode => + min.hashCode ^ + (max.hashCode * 3) ^ + (includeMin.hashCode * 5) ^ + (includeMax.hashCode * 7); bool get isEmpty => false; @@ -88,7 +91,6 @@ class VersionRange implements Comparable, VersionConstraint { if (other > max) return false; if (!includeMax && other == max) return false; - // Disallow pre-release versions that have the same major, minor, and // patch version as the max, but only if neither the max nor the min is a // pre-release of that version. This ensures that "^1.2.3" doesn't include @@ -109,9 +111,11 @@ class VersionRange implements Comparable, VersionConstraint { // ">1.2.3" can still match prerelease versions if they're the only things // available. var maxIsReleaseOfOther = !includeMax && - !max.isPreRelease && other.isPreRelease && + !max.isPreRelease && + other.isPreRelease && _equalsWithoutPreRelease(other, max); - var minIsPreReleaseOfOther = min != null && min.isPreRelease && + var minIsPreReleaseOfOther = min != null && + min.isPreRelease && _equalsWithoutPreRelease(other, min); if (maxIsReleaseOfOther && !minIsPreReleaseOfOther) return false; } @@ -121,8 +125,8 @@ class VersionRange implements Comparable, VersionConstraint { bool _equalsWithoutPreRelease(Version version1, Version version2) => version1.major == version2.major && - version1.minor == version2.minor && - version1.patch == version2.patch; + version1.minor == version2.minor && + version1.patch == version2.patch; bool allowsAll(VersionConstraint other) { if (other.isEmpty) return true; @@ -216,15 +220,19 @@ class VersionRange implements Comparable, VersionConstraint { return VersionConstraint.empty; } - if (intersectMin != null && intersectMax != null && + if (intersectMin != null && + intersectMax != null && intersectMin > intersectMax) { // Non-overlapping ranges, so empty. return VersionConstraint.empty; } // If we got here, there is an actual range. - return new VersionRange(min: intersectMin, max: intersectMax, - includeMin: intersectIncludeMin, includeMax: intersectIncludeMax); + return new VersionRange( + min: intersectMin, + max: intersectMax, + includeMin: intersectIncludeMin, + includeMax: intersectIncludeMax); } throw new ArgumentError('Unknown VersionConstraint type $other.'); @@ -236,14 +244,18 @@ class VersionRange implements Comparable, VersionConstraint { if (other == min) { return new VersionRange( - min: this.min, max: this.max, - includeMin: true, includeMax: this.includeMax); + 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); + min: this.min, + max: this.max, + includeMin: this.includeMin, + includeMax: true); } return new VersionConstraint.unionOf([this, other]); @@ -283,8 +295,11 @@ class VersionRange implements Comparable, VersionConstraint { unionIncludeMax = true; } - return new VersionRange(min: unionMin, max: unionMax, - includeMin: unionIncludeMin, includeMax: unionIncludeMax); + return new VersionRange( + min: unionMin, + max: unionMax, + includeMin: unionIncludeMin, + includeMax: unionIncludeMax); } return new VersionConstraint.unionOf([this, other]); @@ -299,24 +314,20 @@ class VersionRange implements Comparable, VersionConstraint { if (other == min) { if (!includeMin) return this; return new VersionRange( - min: min, max: max, - includeMin: false, includeMax: includeMax); + min: min, max: max, includeMin: false, includeMax: includeMax); } if (other == max) { if (!includeMax) return this; return new VersionRange( - min: min, max: max, - includeMin: includeMin, includeMax: false); + min: min, max: max, includeMin: includeMin, includeMax: false); } return new VersionUnion.fromRanges([ new VersionRange( - min: min, max: other, - includeMin: includeMin, includeMax: false), + min: min, max: other, includeMin: includeMin, includeMax: false), new VersionRange( - min: other, max: max, - includeMin: false, includeMax: includeMax) + min: other, max: max, includeMin: false, includeMax: includeMax) ]); } else if (other is VersionRange) { if (!allowsAny(other)) return this; @@ -330,8 +341,10 @@ class VersionRange implements Comparable, VersionConstraint { before = min; } else { before = new VersionRange( - min: min, max: other.min, - includeMin: includeMin, includeMax: !other.includeMin); + min: min, + max: other.min, + includeMin: includeMin, + includeMax: !other.includeMin); } VersionRange after; @@ -343,8 +356,10 @@ class VersionRange implements Comparable, VersionConstraint { after = max; } else { after = new VersionRange( - min: other.max, max: max, - includeMin: !other.includeMax, includeMax: includeMax); + min: other.max, + max: max, + includeMin: !other.includeMax, + includeMax: includeMax); } if (before == null && after == null) return VersionConstraint.empty; diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index a26cb528d8..9324d3fb7a 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -96,8 +96,7 @@ class VersionUnion implements VersionConstraint { ourRanges.moveNext(); theirRanges.moveNext(); while (ourRanges.current != null && theirRanges.current != null) { - var intersection = ourRanges.current - .intersect(theirRanges.current); + var intersection = ourRanges.current.intersect(theirRanges.current); if (!intersection.isEmpty) newRanges.add(intersection); diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart index e1d7446ccf..9b28c6a224 100644 --- a/pkgs/pub_semver/test/utils.dart +++ b/pkgs/pub_semver/test/utils.dart @@ -30,7 +30,8 @@ class _VersionConstraintMatcher implements Matcher { _VersionConstraintMatcher(this._expected, this._allow); - bool matches(item, Map matchState) => (item is VersionConstraint) && + bool matches(item, Map matchState) => + (item is VersionConstraint) && _expected.every((version) => item.allows(version) == _allow); Description describe(Description description) { @@ -39,8 +40,8 @@ class _VersionConstraintMatcher implements Matcher { return description; } - Description describeMismatch(item, Description mismatchDescription, - Map matchState, bool verbose) { + Description describeMismatch( + item, Description mismatchDescription, Map matchState, bool verbose) { if (item is! VersionConstraint) { mismatchDescription.add('was not a VersionConstraint'); return mismatchDescription; @@ -70,22 +71,40 @@ class _VersionConstraintMatcher implements Matcher { /// Gets a [Matcher] that validates that a [VersionConstraint] allows all /// given versions. -Matcher allows(Version v1, [Version v2, Version v3, Version v4, - Version v5, Version v6, Version v7, Version v8]) { +Matcher allows(Version v1, + [Version v2, + Version v3, + Version v4, + Version v5, + Version v6, + Version v7, + Version v8]) { var versions = _makeVersionList(v1, v2, v3, v4, v5, v6, v7, v8); return new _VersionConstraintMatcher(versions, true); } /// Gets a [Matcher] that validates that a [VersionConstraint] allows none of /// the given versions. -Matcher doesNotAllow(Version v1, [Version v2, Version v3, Version v4, - Version v5, Version v6, Version v7, Version v8]) { +Matcher doesNotAllow(Version v1, + [Version v2, + Version v3, + Version v4, + Version v5, + Version v6, + Version v7, + Version v8]) { var versions = _makeVersionList(v1, v2, v3, v4, v5, v6, v7, v8); return new _VersionConstraintMatcher(versions, false); } -List _makeVersionList(Version v1, [Version v2, Version v3, Version v4, - Version v5, Version v6, Version v7, Version v8]) { +List _makeVersionList(Version v1, + [Version v2, + Version v3, + Version v4, + Version v5, + Version v6, + Version v7, + Version v8]) { var versions = [v1]; if (v2 != null) versions.add(v2); if (v3 != null) versions.add(v3); @@ -95,4 +114,4 @@ List _makeVersionList(Version v1, [Version v2, Version v3, Version v4, if (v7 != null) versions.add(v7); if (v8 != null) versions.add(v8); return versions; -} \ No newline at end of file +} diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index bd6bf75cf0..bc378325ef 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -11,19 +11,19 @@ import 'utils.dart'; main() { test('any', () { expect(VersionConstraint.any.isAny, isTrue); - expect(VersionConstraint.any, allows( - new Version.parse('0.0.0-blah'), - new Version.parse('1.2.3'), - new Version.parse('12345.678.90'))); + expect( + VersionConstraint.any, + allows(new Version.parse('0.0.0-blah'), new Version.parse('1.2.3'), + new Version.parse('12345.678.90'))); }); test('empty', () { expect(VersionConstraint.empty.isEmpty, isTrue); expect(VersionConstraint.empty.isAny, isFalse); - expect(VersionConstraint.empty, doesNotAllow( - new Version.parse('0.0.0-blah'), - new Version.parse('1.2.3'), - new Version.parse('12345.678.90'))); + expect( + VersionConstraint.empty, + doesNotAllow(new Version.parse('0.0.0-blah'), + new Version.parse('1.2.3'), new Version.parse('12345.678.90'))); }); group('parse()', () { @@ -38,82 +38,80 @@ main() { var constraint = new VersionConstraint.parse('any'); expect(constraint is VersionConstraint, isTrue); - expect(constraint, allows( - new Version.parse('0.0.0'), - new Version.parse('1.2.3'), - new Version.parse('12345.678.90'))); + expect( + constraint, + allows(new Version.parse('0.0.0'), new Version.parse('1.2.3'), + new Version.parse('12345.678.90'))); }); test('parses a ">" minimum version', () { var constraint = new VersionConstraint.parse('>1.2.3'); - expect(constraint, allows( - new Version.parse('1.2.3+foo'), - new Version.parse('1.2.4'))); - expect(constraint, doesNotAllow( - new Version.parse('1.2.1'), - new Version.parse('1.2.3-build'), - new Version.parse('1.2.3'))); + expect(constraint, + allows(new Version.parse('1.2.3+foo'), new Version.parse('1.2.4'))); + expect( + constraint, + doesNotAllow(new Version.parse('1.2.1'), + new Version.parse('1.2.3-build'), new Version.parse('1.2.3'))); }); test('parses a ">=" minimum version', () { var constraint = new VersionConstraint.parse('>=1.2.3'); - expect(constraint, allows( - new Version.parse('1.2.3'), - new Version.parse('1.2.3+foo'), - new Version.parse('1.2.4'))); - expect(constraint, doesNotAllow( - new Version.parse('1.2.1'), - new Version.parse('1.2.3-build'))); + expect( + constraint, + allows(new Version.parse('1.2.3'), new Version.parse('1.2.3+foo'), + new Version.parse('1.2.4'))); + expect( + constraint, + doesNotAllow( + new Version.parse('1.2.1'), new Version.parse('1.2.3-build'))); }); test('parses a "<" maximum version', () { var constraint = new VersionConstraint.parse('<1.2.3'); - expect(constraint, allows( - new Version.parse('1.2.1'), - new Version.parse('1.2.2+foo'))); - expect(constraint, doesNotAllow( - new Version.parse('1.2.3'), - new Version.parse('1.2.3+foo'), - new Version.parse('1.2.4'))); + expect(constraint, + allows(new Version.parse('1.2.1'), new Version.parse('1.2.2+foo'))); + expect( + constraint, + doesNotAllow(new Version.parse('1.2.3'), + new Version.parse('1.2.3+foo'), new Version.parse('1.2.4'))); }); test('parses a "<=" maximum version', () { var constraint = new VersionConstraint.parse('<=1.2.3'); - expect(constraint, allows( - new Version.parse('1.2.1'), - new Version.parse('1.2.3-build'), - new Version.parse('1.2.3'))); - expect(constraint, doesNotAllow( - new Version.parse('1.2.3+foo'), - new Version.parse('1.2.4'))); + expect( + constraint, + allows(new Version.parse('1.2.1'), new Version.parse('1.2.3-build'), + new Version.parse('1.2.3'))); + expect( + constraint, + doesNotAllow( + new Version.parse('1.2.3+foo'), new Version.parse('1.2.4'))); }); test('parses a series of space-separated constraints', () { var constraint = new VersionConstraint.parse('>1.0.0 >=1.2.3 <1.3.0'); - expect(constraint, allows( - new Version.parse('1.2.3'), - new Version.parse('1.2.5'))); - expect(constraint, doesNotAllow( - new Version.parse('1.2.3-pre'), - new Version.parse('1.3.0'), - new Version.parse('3.4.5'))); + expect(constraint, + allows(new Version.parse('1.2.3'), new Version.parse('1.2.5'))); + expect( + constraint, + doesNotAllow(new Version.parse('1.2.3-pre'), + new Version.parse('1.3.0'), new Version.parse('3.4.5'))); }); test('ignores whitespace around comparison operators', () { var constraint = new VersionConstraint.parse(' >1.0.0>=1.2.3 < 1.3.0'); - expect(constraint, allows( - new Version.parse('1.2.3'), - new Version.parse('1.2.5'))); - expect(constraint, doesNotAllow( - new Version.parse('1.2.3-pre'), - new Version.parse('1.3.0'), - new Version.parse('3.4.5'))); + expect(constraint, + allows(new Version.parse('1.2.3'), new Version.parse('1.2.5'))); + expect( + constraint, + doesNotAllow(new Version.parse('1.2.3-pre'), + new Version.parse('1.3.0'), new Version.parse('3.4.5'))); }); test('does not allow "any" to be mixed with other constraints', () { @@ -122,18 +120,18 @@ main() { }); test('parses a "^" version', () { - expect(new VersionConstraint.parse('^0.0.3'), equals( - new VersionConstraint.compatibleWith(v003))); + expect(new VersionConstraint.parse('^0.0.3'), + equals(new VersionConstraint.compatibleWith(v003))); - expect(new VersionConstraint.parse('^0.7.2'), equals( - new VersionConstraint.compatibleWith(v072))); + expect(new VersionConstraint.parse('^0.7.2'), + equals(new VersionConstraint.compatibleWith(v072))); - expect(new VersionConstraint.parse('^1.2.3'), equals( - new VersionConstraint.compatibleWith(v123))); + expect(new VersionConstraint.parse('^1.2.3'), + equals(new VersionConstraint.compatibleWith(v123))); var min = new Version.parse('0.7.2-pre+1'); - expect(new VersionConstraint.parse('^0.7.2-pre+1'), equals( - new VersionConstraint.compatibleWith(min))); + expect(new VersionConstraint.parse('^0.7.2-pre+1'), + equals(new VersionConstraint.compatibleWith(min))); }); test('does not allow "^" to be mixed with other constraints', () { @@ -146,25 +144,23 @@ main() { test('ignores whitespace around "^"', () { var constraint = new VersionConstraint.parse(' ^ 1.2.3 '); - expect(constraint, equals( - new VersionConstraint.compatibleWith(v123))); + expect(constraint, equals(new VersionConstraint.compatibleWith(v123))); }); test('throws FormatException on a bad string', () { var bad = [ - "", " ", // Empty string. - "foo", // Bad text. - ">foo", // Bad text after operator. - "^foo", // Bad text after "^". - "1.0.0 foo", "1.0.0foo", // Bad text after version. - "anything", // Bad text after "any". - "<>1.0.0", // Multiple operators. - "1.0.0<" // Trailing operator. + "", " ", // Empty string. + "foo", // Bad text. + ">foo", // Bad text after operator. + "^foo", // Bad text after "^". + "1.0.0 foo", "1.0.0foo", // Bad text after version. + "anything", // Bad text after "any". + "<>1.0.0", // Multiple operators. + "1.0.0<" // Trailing operator. ]; for (var text in bad) { - expect(() => new VersionConstraint.parse(text), - throwsFormatException); + expect(() => new VersionConstraint.parse(text), throwsFormatException); } }); }); @@ -173,8 +169,10 @@ main() { test('returns the range of compatible versions', () { var constraint = new VersionConstraint.compatibleWith(v072); - expect(constraint, equals(new VersionRange(min: v072, includeMin: true, - max: v072.nextBreaking))); + expect( + constraint, + equals(new VersionRange( + min: v072, includeMin: true, max: v072.nextBreaking))); }); test('toString() uses "^"', () { diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index 23d771049d..e95b3d697a 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -60,21 +60,19 @@ main() { test('version must be greater than min', () { var range = new VersionRange(min: v123); - expect(range, allows( - new Version.parse('1.3.3'), - new Version.parse('2.3.3'))); - expect(range, doesNotAllow( - new Version.parse('1.2.2'), - new Version.parse('1.2.3'))); + expect(range, + allows(new Version.parse('1.3.3'), new Version.parse('2.3.3'))); + expect(range, + doesNotAllow(new Version.parse('1.2.2'), new Version.parse('1.2.3'))); }); test('version must be min or greater if includeMin', () { var range = new VersionRange(min: v123, includeMin: true); - expect(range, allows( - new Version.parse('1.2.3'), - new Version.parse('1.3.3'), - new Version.parse('2.3.3'))); + expect( + range, + allows(new Version.parse('1.2.3'), new Version.parse('1.3.3'), + new Version.parse('2.3.3'))); expect(range, doesNotAllow(new Version.parse('1.2.2'))); }); @@ -89,50 +87,53 @@ main() { var range = new VersionRange(max: v234); expect(range, allows(new Version.parse('2.3.3'))); - expect(range, doesNotAllow( - new Version.parse('2.3.4'), - new Version.parse('2.4.3'))); + expect(range, + doesNotAllow(new Version.parse('2.3.4'), new Version.parse('2.4.3'))); }); test('pre-release versions of non-pre-release max are excluded', () { var range = new VersionRange(max: v234); expect(range, allows(new Version.parse('2.3.3'))); - expect(range, doesNotAllow( - new Version.parse('2.3.4-dev'), - new Version.parse('2.3.4'))); + expect( + range, + doesNotAllow( + new Version.parse('2.3.4-dev'), new Version.parse('2.3.4'))); }); - test('pre-release versions of non-pre-release max are included if min is a ' + test( + 'pre-release versions of non-pre-release max are included if min is a ' 'pre-release of the same version', () { - var range = new VersionRange( - min: new Version.parse('2.3.4-dev.0'), max: v234); + var range = + new VersionRange(min: new Version.parse('2.3.4-dev.0'), max: v234); expect(range, allows(new Version.parse('2.3.4-dev.1'))); - expect(range, doesNotAllow( - new Version.parse('2.3.3'), - new Version.parse('2.3.4-dev'), - new Version.parse('2.3.4'))); + expect( + range, + doesNotAllow(new Version.parse('2.3.3'), + new Version.parse('2.3.4-dev'), new Version.parse('2.3.4'))); }); test('pre-release versions of pre-release max are included', () { var range = new VersionRange(max: new Version.parse('2.3.4-dev.2')); - expect(range, allows( - new Version.parse('2.3.4-dev.1'))); - expect(range, doesNotAllow( - new Version.parse('2.3.4-dev.2'), - new Version.parse('2.3.4-dev.3'))); + expect(range, allows(new Version.parse('2.3.4-dev.1'))); + expect( + range, + doesNotAllow(new Version.parse('2.3.4-dev.2'), + new Version.parse('2.3.4-dev.3'))); }); test('version must be max or less if includeMax', () { var range = new VersionRange(min: v123, max: v234, includeMax: true); - expect(range, allows( - new Version.parse('2.3.3'), - new Version.parse('2.3.4'), - // Pre-releases of the max are allowed. - new Version.parse('2.3.4-dev'))); + expect( + range, + allows( + new Version.parse('2.3.3'), + new Version.parse('2.3.4'), + // Pre-releases of the max are allowed. + new Version.parse('2.3.4-dev'))); expect(range, doesNotAllow(new Version.parse('2.4.3'))); }); @@ -146,18 +147,16 @@ main() { test('has no max if one was not set', () { var range = new VersionRange(min: v123); - expect(range, allows( - new Version.parse('1.3.3'), - new Version.parse('999.3.3'))); + expect(range, + allows(new Version.parse('1.3.3'), new Version.parse('999.3.3'))); expect(range, doesNotAllow(new Version.parse('1.2.3'))); }); test('allows any version if there is no min or max', () { var range = new VersionRange(); - expect(range, allows( - new Version.parse('0.0.0'), - new Version.parse('999.99.9'))); + expect(range, + allows(new Version.parse('0.0.0'), new Version.parse('999.99.9'))); }); }); @@ -280,30 +279,36 @@ main() { expect(new VersionRange(max: v250).allowsAny(new VersionRange(min: v250)), isFalse); - expect(new VersionRange(max: v250, includeMax: true) + expect( + new VersionRange(max: v250, includeMax: true) .allowsAny(new VersionRange(min: v250)), isFalse); - expect(new VersionRange(max: v250) + expect( + new VersionRange(max: v250) .allowsAny(new VersionRange(min: v250, includeMin: true)), isFalse); - expect(new VersionRange(max: v250, includeMax: true) + expect( + new VersionRange(max: v250, includeMax: true) .allowsAny(new VersionRange(min: v250, includeMin: true)), isTrue); expect(new VersionRange(min: v250).allowsAny(new VersionRange(max: v250)), isFalse); - expect(new VersionRange(min: v250, includeMin: true) + expect( + new VersionRange(min: v250, includeMin: true) .allowsAny(new VersionRange(max: v250)), isFalse); - expect(new VersionRange(min: v250) + expect( + new VersionRange(min: v250) .allowsAny(new VersionRange(max: v250, includeMax: true)), isFalse); - expect(new VersionRange(min: v250, includeMin: true) + expect( + new VersionRange(min: v250, includeMin: true) .allowsAny(new VersionRange(max: v250, includeMax: true)), isTrue); }); @@ -361,8 +366,8 @@ main() { }); test('returns the version if the range allows it', () { - expect(new VersionRange(min: v114, max: v124).intersect(v123), - equals(v123)); + expect( + new VersionRange(min: v114, max: v124).intersect(v123), equals(v123)); expect(new VersionRange(min: v123, max: v124).intersect(v114).isEmpty, isTrue); }); @@ -381,7 +386,8 @@ main() { equals(new VersionRange(min: v114, max: v124, includeMin: true))); }); - test("with a version allows both the range and the version if the range " + test( + "with a version allows both the range and the version if the range " "doesn't contain the version", () { var result = new VersionRange(min: v003, max: v114).union(v124); expect(result, allows(v010)); @@ -438,8 +444,10 @@ main() { test("includes edges if either range does", () { var result = new VersionRange(min: v003, max: v114, includeMin: true) .union(new VersionRange(min: v003, max: v114, includeMax: true)); - expect(result, equals(new VersionRange( - min: v003, max: v114, includeMin: true, includeMax: true))); + expect( + result, + equals(new VersionRange( + min: v003, max: v114, includeMin: true, includeMax: true))); }); }); @@ -452,8 +460,7 @@ main() { }); test("with a version outside the range returns the original range", () { - expect( - new VersionRange(min: v003, max: v114).difference(v200), + expect(new VersionRange(min: v003, max: v114).difference(v200), equals(new VersionRange(min: v003, max: v114))); }); @@ -518,8 +525,7 @@ main() { equals(v130)); }); - test("with a range at the end cuts off the end of the range", - () { + test("with a range at the end cuts off the end of the range", () { expect( new VersionRange(min: v080, max: v130) .difference(new VersionRange(min: v114, max: v140)), @@ -569,7 +575,8 @@ main() { isEmpty); }); - test("with a version union that doesn't cover the range, returns the " + test( + "with a version union that doesn't cover the range, returns the " "original", () { expect( new VersionRange(min: v114, max: v140) @@ -579,11 +586,11 @@ main() { test("with a version union that intersects the ends, chops them off", () { expect( - new VersionRange(min: v114, max: v140) - .difference(new VersionConstraint.unionOf([ - new VersionRange(min: v080, max: v123), - new VersionRange(min: v130, max: v200) - ])), + new VersionRange(min: v114, max: v140).difference( + new VersionConstraint.unionOf([ + new VersionRange(min: v080, max: v123), + new VersionRange(min: v130, max: v200) + ])), equals(new VersionRange( min: v123, max: v130, includeMin: true, includeMax: true))); }); @@ -608,20 +615,16 @@ main() { group('compareTo()', () { test("orders by minimum first", () { - _expectComparesSmaller( - new VersionRange(min: v003, max: v080), + _expectComparesSmaller(new VersionRange(min: v003, max: v080), new VersionRange(min: v010, max: v072)); - _expectComparesSmaller( - new VersionRange(min: v003, max: v080), + _expectComparesSmaller(new VersionRange(min: v003, max: v080), new VersionRange(min: v010, max: v080)); - _expectComparesSmaller( - new VersionRange(min: v003, max: v080), + _expectComparesSmaller(new VersionRange(min: v003, max: v080), new VersionRange(min: v010, max: v114)); }); test("orders by maximum second", () { - _expectComparesSmaller( - new VersionRange(min: v003, max: v010), + _expectComparesSmaller(new VersionRange(min: v003, max: v010), new VersionRange(min: v003, max: v072)); }); @@ -639,19 +642,15 @@ main() { test("no minimum comes before small minimum", () { _expectComparesSmaller( - new VersionRange(max: v010), - new VersionRange(min: v003, max: v010)); - _expectComparesSmaller( - new VersionRange(max: v010, includeMin: true), + new VersionRange(max: v010), new VersionRange(min: v003, max: v010)); + _expectComparesSmaller(new VersionRange(max: v010, includeMin: true), new VersionRange(min: v003, max: v010)); }); test("no maximium comes after large maximum", () { _expectComparesSmaller( - new VersionRange(min: v003, max: v300), - new VersionRange(min: v003)); - _expectComparesSmaller( - new VersionRange(min: v003, max: v300), + new VersionRange(min: v003, max: v300), new VersionRange(min: v003)); + _expectComparesSmaller(new VersionRange(min: v003, max: v300), new VersionRange(min: v003, includeMax: true)); }); }); diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index b278d4c611..fc6dfef339 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -119,21 +119,23 @@ main() { expect(new Version.parse('01.2.3'), equals(new Version.parse('1.2.3'))); expect(new Version.parse('1.02.3'), equals(new Version.parse('1.2.3'))); expect(new Version.parse('1.2.03'), equals(new Version.parse('1.2.3'))); - expect(new Version.parse('1.2.3-01'), - equals(new Version.parse('1.2.3-1'))); - expect(new Version.parse('1.2.3+01'), - equals(new Version.parse('1.2.3+1'))); + expect( + new Version.parse('1.2.3-01'), equals(new Version.parse('1.2.3-1'))); + expect( + new Version.parse('1.2.3+01'), equals(new Version.parse('1.2.3+1'))); }); }); test('allows()', () { expect(v123, allows(v123)); - expect(v123, doesNotAllow( - new Version.parse('2.2.3'), - new Version.parse('1.3.3'), - new Version.parse('1.2.4'), - new Version.parse('1.2.3-dev'), - new Version.parse('1.2.3+build'))); + expect( + v123, + doesNotAllow( + new Version.parse('2.2.3'), + new Version.parse('1.3.3'), + new Version.parse('1.2.4'), + new Version.parse('1.2.3-dev'), + new Version.parse('1.2.3+build'))); }); test('allowsAll()', () { @@ -160,12 +162,12 @@ main() { expect(v123.intersect(v114).isEmpty, isTrue); // Intersecting a range returns the version if the range allows it. - expect(v123.intersect(new VersionRange(min: v114, max: v124)), - equals(v123)); + expect( + v123.intersect(new VersionRange(min: v114, max: v124)), equals(v123)); // Intersecting a range allows no versions if the range doesn't allow it. - expect(v114.intersect(new VersionRange(min: v123, max: v124)).isEmpty, - isTrue); + expect( + v114.intersect(new VersionRange(min: v123, max: v124)).isEmpty, isTrue); }); group('union()', () { @@ -194,7 +196,8 @@ main() { equals(new VersionRange(min: v114, max: v124, includeMin: true))); }); - test("with a range allows both the range and the version if the range " + test( + "with a range allows both the range and the version if the range " "doesn't contain the version", () { var result = v123.union(new VersionRange(min: v003, max: v114)); expect(result, allows(v123)); diff --git a/pkgs/pub_semver/test/version_union_test.dart b/pkgs/pub_semver/test/version_union_test.dart index 06a427dd99..f948832947 100644 --- a/pkgs/pub_semver/test/version_union_test.dart +++ b/pkgs/pub_semver/test/version_union_test.dart @@ -11,17 +11,19 @@ import 'utils.dart'; main() { group('factory', () { test('ignores empty constraints', () { - expect(new VersionConstraint.unionOf([ - VersionConstraint.empty, - VersionConstraint.empty, - v123, - VersionConstraint.empty - ]), equals(v123)); - - expect(new VersionConstraint.unionOf([ - VersionConstraint.empty, - VersionConstraint.empty - ]), isEmpty); + expect( + new VersionConstraint.unionOf([ + VersionConstraint.empty, + VersionConstraint.empty, + v123, + VersionConstraint.empty + ]), + equals(v123)); + + expect( + new VersionConstraint.unionOf( + [VersionConstraint.empty, VersionConstraint.empty]), + isEmpty); }); test('returns an empty constraint for an empty list', () { @@ -29,120 +31,142 @@ main() { }); test('any constraints override everything', () { - expect(new VersionConstraint.unionOf([ - v123, - VersionConstraint.any, - v200, - new VersionRange(min: v234, max: v250) - ]), equals(VersionConstraint.any)); + expect( + new VersionConstraint.unionOf([ + v123, + VersionConstraint.any, + v200, + new VersionRange(min: v234, max: v250) + ]), + equals(VersionConstraint.any)); }); test('flattens other unions', () { - expect(new VersionConstraint.unionOf([ - v072, - new VersionConstraint.unionOf([v123, v124]), - v250 - ]), equals(new VersionConstraint.unionOf([v072, v123, v124, v250]))); + expect( + new VersionConstraint.unionOf([ + v072, + new VersionConstraint.unionOf([v123, v124]), + v250 + ]), + equals(new VersionConstraint.unionOf([v072, v123, v124, v250]))); }); test('returns a single merged range as-is', () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v080, max: v140), - new VersionRange(min: v123, max: v200) - ]), equals(new VersionRange(min: v080, max: v200))); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v080, max: v140), + new VersionRange(min: v123, max: v200) + ]), + equals(new VersionRange(min: v080, max: v200))); }); }); group('equality', () { test("doesn't depend on original order", () { - expect(new VersionConstraint.unionOf([ - v250, - new VersionRange(min: v201, max: v234), - v124, - v072, - new VersionRange(min: v080, max: v114), - v123 - ]), equals(new VersionConstraint.unionOf([ - v072, - new VersionRange(min: v080, max: v114), - v123, - v124, - new VersionRange(min: v201, max: v234), - v250 - ]))); + expect( + new VersionConstraint.unionOf([ + v250, + new VersionRange(min: v201, max: v234), + v124, + v072, + new VersionRange(min: v080, max: v114), + v123 + ]), + equals(new VersionConstraint.unionOf([ + v072, + new VersionRange(min: v080, max: v114), + v123, + v124, + new VersionRange(min: v201, max: v234), + v250 + ]))); }); test("merges overlapping ranges", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - new VersionRange(min: v010, max: v080), - new VersionRange(min: v114, max: v124), - new VersionRange(min: v123, max: v130) - ]), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v114, max: v130) - ]))); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + new VersionRange(min: v010, max: v080), + new VersionRange(min: v114, max: v124), + new VersionRange(min: v123, max: v130) + ]), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v114, max: v130) + ]))); }); test("merges adjacent ranges", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072, includeMax: true), - new VersionRange(min: v072, max: v080), - new VersionRange(min: v114, max: v124), - new VersionRange(min: v124, max: v130, includeMin: true) - ]), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v114, max: v130) - ]))); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072, includeMax: true), + new VersionRange(min: v072, max: v080), + new VersionRange(min: v114, max: v124), + new VersionRange(min: v124, max: v130, includeMin: true) + ]), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v114, max: v130) + ]))); }); test("doesn't merge not-quite-adjacent ranges", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - new VersionRange(min: v072, max: v080) - ]), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - new VersionRange(min: v072, max: v080) - ]))); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + new VersionRange(min: v072, max: v080) + ]), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + new VersionRange(min: v072, max: v080) + ]))); }); - + test("merges version numbers into ranges", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - v010, - new VersionRange(min: v114, max: v124), - v123 - ]), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - new VersionRange(min: v114, max: v124) - ]))); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + v010, + new VersionRange(min: v114, max: v124), + v123 + ]), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + new VersionRange(min: v114, max: v124) + ]))); }); - + test("merges adjacent version numbers into ranges", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - v072, - v114, - new VersionRange(min: v114, max: v124) - ]), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072, includeMax: true), - new VersionRange(min: v114, max: v124, includeMin: true) - ]))); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + v072, + v114, + new VersionRange(min: v114, max: v124) + ]), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072, includeMax: true), + new VersionRange(min: v114, max: v124, includeMin: true) + ]))); }); }); test('isEmpty returns false', () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v123, max: v130), - ]), isNot(isEmpty)); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v123, max: v130), + ]), + isNot(isEmpty)); }); test('isAny returns false', () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v123, max: v130), - ]).isAny, isFalse); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v080), + new VersionRange(min: v123, max: v130), + ]).isAny, + isFalse); }); test('allows() allows anything the components allow', () { @@ -174,7 +198,8 @@ main() { expect(union.allowsAll(v200), isTrue); }); - test('for a version range, returns true if any component allows the whole ' + test( + 'for a version range, returns true if any component allows the whole ' 'range', () { var union = new VersionConstraint.unionOf([ new VersionRange(min: v003, max: v080), @@ -194,32 +219,40 @@ main() { test('returns true if every constraint matches a different constraint', () { - expect(union.allowsAll(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v072), - new VersionRange(min: v124, max: v130) - ])), isTrue); + expect( + union.allowsAll(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v072), + new VersionRange(min: v124, max: v130) + ])), + isTrue); }); test('returns true if every constraint matches the same constraint', () { - expect(union.allowsAll(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v010), - new VersionRange(min: v072, max: v080) - ])), isTrue); + expect( + union.allowsAll(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v010), + new VersionRange(min: v072, max: v080) + ])), + isTrue); }); - + test("returns false if there's an unmatched constraint", () { - expect(union.allowsAll(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v072), - new VersionRange(min: v124, max: v130), - new VersionRange(min: v140, max: v200) - ])), isFalse); + expect( + union.allowsAll(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v072), + new VersionRange(min: v124, max: v130), + new VersionRange(min: v140, max: v200) + ])), + isFalse); }); test("returns false if a constraint isn't fully matched", () { - expect(union.allowsAll(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v114), - new VersionRange(min: v124, max: v130) - ])), isFalse); + expect( + union.allowsAll(new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v114), + new VersionRange(min: v124, max: v130) + ])), + isFalse); }); }); }); @@ -239,12 +272,11 @@ main() { expect(union.allowsAny(v200), isTrue); }); - test('for a version range, returns true if any component allows part of ' + test( + 'for a version range, returns true if any component allows part of ' 'the range', () { - var union = new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - v123 - ]); + var union = new VersionConstraint.unionOf( + [new VersionRange(min: v003, max: v080), v123]); expect(union.allowsAny(new VersionRange(min: v010, max: v114)), isTrue); expect(union.allowsAny(new VersionRange(min: v114, max: v124)), isTrue); @@ -258,67 +290,78 @@ main() { ]); test('returns true if any constraint matches', () { - expect(union.allowsAny(new VersionConstraint.unionOf([ - v072, - new VersionRange(min: v200, max: v300) - ])), isTrue); - - expect(union.allowsAny(new VersionConstraint.unionOf([ - v003, - new VersionRange(min: v124, max: v300) - ])), isTrue); + expect( + union.allowsAny(new VersionConstraint.unionOf( + [v072, new VersionRange(min: v200, max: v300)])), + isTrue); + + expect( + union.allowsAny(new VersionConstraint.unionOf( + [v003, new VersionRange(min: v124, max: v300)])), + isTrue); }); - + test("returns false if no constraint matches", () { - expect(union.allowsAny(new VersionConstraint.unionOf([ - v003, - new VersionRange(min: v130, max: v140), - new VersionRange(min: v140, max: v200) - ])), isFalse); + expect( + union.allowsAny(new VersionConstraint.unionOf([ + v003, + new VersionRange(min: v130, max: v140), + new VersionRange(min: v140, max: v200) + ])), + isFalse); }); }); }); group("intersect()", () { test("with an overlapping version, returns that version", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v140) - ]).intersect(v072), equals(v072)); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v140) + ]).intersect(v072), + equals(v072)); }); test("with a non-overlapping version, returns an empty constraint", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v140) - ]).intersect(v300), isEmpty); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v140) + ]).intersect(v300), + isEmpty); }); test("with an overlapping range, returns that range", () { var range = new VersionRange(min: v072, max: v080); - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v140) - ]).intersect(range), equals(range)); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v140) + ]).intersect(range), + equals(range)); }); test("with a non-overlapping range, returns an empty constraint", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v140) - ]).intersect(new VersionRange(min: v080, max: v123)), isEmpty); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v140) + ]).intersect(new VersionRange(min: v080, max: v123)), + isEmpty); }); test("with a parially-overlapping range, returns the overlapping parts", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v140) - ]).intersect(new VersionRange(min: v072, max: v130)), + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v140) + ]).intersect(new VersionRange(min: v072, max: v130)), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v072, max: v080), - new VersionRange(min: v123, max: v130) - ]))); + new VersionRange(min: v072, max: v080), + new VersionRange(min: v123, max: v130) + ]))); }); group("for a union,", () { @@ -328,83 +371,93 @@ main() { ]); test("returns the overlapping parts", () { - expect(union.intersect(new VersionConstraint.unionOf([ - v010, - new VersionRange(min: v072, max: v124), - new VersionRange(min: v124, max: v130) - ])), equals(new VersionConstraint.unionOf([ - v010, - new VersionRange(min: v072, max: v080), - new VersionRange(min: v123, max: v124), - new VersionRange(min: v124, max: v130) - ]))); + expect( + union.intersect(new VersionConstraint.unionOf([ + v010, + new VersionRange(min: v072, max: v124), + new VersionRange(min: v124, max: v130) + ])), + equals(new VersionConstraint.unionOf([ + v010, + new VersionRange(min: v072, max: v080), + new VersionRange(min: v123, max: v124), + new VersionRange(min: v124, max: v130) + ]))); }); test("drops parts that don't match", () { - expect(union.intersect(new VersionConstraint.unionOf([ - v003, - new VersionRange(min: v072, max: v080), - new VersionRange(min: v080, max: v123) - ])), equals(new VersionRange(min: v072, max: v080))); + expect( + union.intersect(new VersionConstraint.unionOf([ + v003, + new VersionRange(min: v072, max: v080), + new VersionRange(min: v080, max: v123) + ])), + equals(new VersionRange(min: v072, max: v080))); }); }); }); group("difference()", () { test("ignores ranges that don't intersect", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v072, max: v080), - new VersionRange(min: v123, max: v130) - ]).difference(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v010), - new VersionRange(min: v080, max: v123), - new VersionRange(min: v140) - ])), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v072, max: v080), - new VersionRange(min: v123, max: v130) - ]))); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v072, max: v080), + new VersionRange(min: v123, max: v130) + ]).difference(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v010), + new VersionRange(min: v080, max: v123), + new VersionRange(min: v140) + ])), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v072, max: v080), + new VersionRange(min: v123, max: v130) + ]))); }); test("removes overlapping portions", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v130) - ]).difference(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - new VersionRange(min: v124) - ])), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v072, max: v080, includeMin: true), - new VersionRange(min: v123, max: v124, includeMax: true) - ]))); + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v080), + new VersionRange(min: v123, max: v130) + ]).difference(new VersionConstraint.unionOf([ + new VersionRange(min: v003, max: v072), + new VersionRange(min: v124) + ])), + equals(new VersionConstraint.unionOf([ + new VersionRange(min: v072, max: v080, includeMin: true), + new VersionRange(min: v123, max: v124, includeMax: true) + ]))); }); test("removes multiple portions from the same range", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v114), - new VersionRange(min: v130, max: v200) - ]).difference(new VersionConstraint.unionOf([v072, v080])), + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v114), + new VersionRange(min: v130, max: v200) + ]).difference(new VersionConstraint.unionOf([v072, v080])), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v072), - new VersionRange(min: v072, max: v080), - new VersionRange(min: v080, max: v114), - new VersionRange(min: v130, max: v200) - ]))); + new VersionRange(min: v010, max: v072), + new VersionRange(min: v072, max: v080), + new VersionRange(min: v080, max: v114), + new VersionRange(min: v130, max: v200) + ]))); }); test("removes the same range from multiple ranges", () { - expect(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v072), - new VersionRange(min: v080, max: v123), - new VersionRange(min: v124, max: v130), - new VersionRange(min: v200, max: v234), - new VersionRange(min: v250, max: v300) - ]).difference(new VersionRange(min: v114, max: v201)), + expect( + new VersionConstraint.unionOf([ + new VersionRange(min: v010, max: v072), + new VersionRange(min: v080, max: v123), + new VersionRange(min: v124, max: v130), + new VersionRange(min: v200, max: v234), + new VersionRange(min: v250, max: v300) + ]).difference(new VersionRange(min: v114, max: v201)), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v072), - new VersionRange(min: v080, max: v114, includeMax: true), - new VersionRange(min: v201, max: v234, includeMin: true), - new VersionRange(min: v250, max: v300) - ]))); + new VersionRange(min: v010, max: v072), + new VersionRange(min: v080, max: v114, includeMax: true), + new VersionRange(min: v201, max: v234, includeMin: true), + new VersionRange(min: v250, max: v300) + ]))); }); }); -} \ No newline at end of file +} From 9db25860147cb96ab64291b99ea099e9e6504fad Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Fri, 30 Mar 2018 01:05:19 -0700 Subject: [PATCH 036/115] Fix a crashing bug (dart-lang/pub_semver#19) VersionRange.difference() with a VersionUnion didn't expect to get an empty constraint, but it was possible to do so. Closes dart-lang/pub_semver#18 --- pkgs/pub_semver/CHANGELOG.md | 5 +++++ pkgs/pub_semver/lib/src/version_range.dart | 4 +++- pkgs/pub_semver/pubspec.yaml | 2 +- pkgs/pub_semver/test/version_range_test.dart | 8 ++++++++ 4 files changed, 17 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 6d54692d96..d50c76826c 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,8 @@ +# 1.3.3 + +* Fix a bug where `VersionRange.difference()` with a union constraint that + covered the entire range would crash. + # 1.3.2 * Fix a checked-mode error in `VersionRange.difference()`. diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 99f2924263..bce869b485 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -379,7 +379,9 @@ class VersionRange implements Comparable, VersionConstraint { if (strictlyHigher(range, current)) break; var difference = current.difference(range); - if (difference is VersionUnion) { + if (difference.isEmpty) { + return VersionConstraint.empty; + } else if (difference is VersionUnion) { // If [range] split [current] in half, we only need to continue // checking future ranges against the latter half. assert(difference.ranges.length == 2); diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 93fb03555d..eac5cb05e3 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.3.3-dev +version: 1.3.3 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index e95b3d697a..cefd9d370f 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -606,6 +606,14 @@ main() { new VersionRange(min: v130, max: v140) ]))); }); + + test("with a version union that covers the whole range, returns empty", () { + expect( + new VersionRange(min: v114, max: v140).difference( + new VersionConstraint.unionOf( + [v003, new VersionRange(min: v010)])), + equals(VersionConstraint.empty)); + }); }); test('isEmpty', () { From 7186e3f44cc96bab547db53f37f42a49c7d7c0bc Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Tue, 3 Apr 2018 13:59:32 -0700 Subject: [PATCH 037/115] Implement strictlyHigher() in terms of strictlyLower() --- pkgs/pub_semver/lib/src/utils.dart | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/pkgs/pub_semver/lib/src/utils.dart b/pkgs/pub_semver/lib/src/utils.dart index efe105abed..9527d2dbae 100644 --- a/pkgs/pub_semver/lib/src/utils.dart +++ b/pkgs/pub_semver/lib/src/utils.dart @@ -48,11 +48,5 @@ bool strictlyLower(VersionRange range1, VersionRange range2) { /// Returns whether [range1] allows only versions higher than those allowed by /// [range2]. -bool strictlyHigher(VersionRange range1, VersionRange range2) { - if (range1.min == null || range2.max == null) return false; - - var comparison = range1.min.compareTo(range2.max); - if (comparison == 1) return true; - if (comparison == -1) return false; - return !range1.includeMin || !range2.includeMax; -} +bool strictlyHigher(VersionRange range1, VersionRange range2) => + strictlyLower(range2, range1); From 4f7ae4186cb3a0cbdbdb3be98bb792c845b52e5f Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Tue, 3 Apr 2018 14:22:05 -0700 Subject: [PATCH 038/115] Implement VersionRange.allowsAll() in terms of allowsLower/Higher() --- pkgs/pub_semver/lib/src/version_range.dart | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index bce869b485..8e9b4ad13d 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -137,19 +137,7 @@ class VersionRange implements Comparable, VersionConstraint { } 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; + return !allowsLower(other, this) && !allowsHigher(other, this); } throw new ArgumentError('Unknown VersionConstraint type $other.'); From 087550fd40d6e96bfe366ec3df828926dfb661c2 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Tue, 3 Apr 2018 14:28:55 -0700 Subject: [PATCH 039/115] Fix a pre-release-exclusion bug The special logic for excluding 1.0.0-dev from <1.0.0 was only implemented for VersionRange.allows(), not for any other methods. This brings the other methods in line with allows(). Closes dart-lang/pub_semver#20 --- pkgs/pub_semver/CHANGELOG.md | 6 ++ pkgs/pub_semver/lib/src/utils.dart | 46 ++++++++++ pkgs/pub_semver/lib/src/version_range.dart | 34 +------ pkgs/pub_semver/test/version_range_test.dart | 97 ++++++++++++++++++++ 4 files changed, 150 insertions(+), 33 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index d50c76826c..53de84120a 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,9 @@ +# 1.3.4 + +* Fix a bug where `VersionRange.allowsAll()`, `VersionRange.allowsAny()`, and + `VersionRange.difference()` would return incorrect results for pre-release + versions with the same base version number as release versions. + # 1.3.3 * Fix a bug where `VersionRange.difference()` with a union constraint that diff --git a/pkgs/pub_semver/lib/src/utils.dart b/pkgs/pub_semver/lib/src/utils.dart index 9527d2dbae..d793e7a957 100644 --- a/pkgs/pub_semver/lib/src/utils.dart +++ b/pkgs/pub_semver/lib/src/utils.dart @@ -2,6 +2,9 @@ // 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. +import 'package:collection/collection.dart'; + +import 'version.dart'; import 'version_range.dart'; /// Returns whether [range1] is immediately next to, but not overlapping, @@ -29,6 +32,10 @@ bool allowsHigher(VersionRange range1, VersionRange range2) { if (range1.max == null) return range2.max != null; if (range2.max == null) return false; + // `<1.0.0-dev.1` allows `1.0.0-dev.0` which is higher than any versions + // allowed by `<1.0.0`. + if (disallowedByPreRelease(range2, range1.max)) return true; + var comparison = range1.max.compareTo(range2.max); if (comparison == 1) return true; if (comparison == -1) return false; @@ -39,6 +46,7 @@ bool allowsHigher(VersionRange range1, VersionRange range2) { /// [range2]. bool strictlyLower(VersionRange range1, VersionRange range2) { if (range1.max == null || range2.min == null) return false; + if (disallowedByPreRelease(range1, range2.min)) return true; var comparison = range1.max.compareTo(range2.min); if (comparison == -1) return true; @@ -50,3 +58,41 @@ bool strictlyLower(VersionRange range1, VersionRange range2) { /// [range2]. bool strictlyHigher(VersionRange range1, VersionRange range2) => strictlyLower(range2, range1); + +// Returns whether [other] is disallowed by [range] because we disallow +// pre-release versions that have the same major, minor, and patch version as +// the max of a range, but only if neither the max nor the min is a pre-release +// of that version. +// +// This ensures that `^1.2.3` doesn't include `2.0.0-pre`, while also allowing +// both `>=2.0.0-pre.2 <2.0.0` and `>=1.2.3 <2.0.0-pre.7` to match +// `2.0.0-pre.5`. +// +// It's worth noting that this is different than [NPM's semantics][]. NPM +// disallows **all** pre-release versions unless their major, minor, and +// patch numbers match those of a prerelease min or max. This ensures that +// no prerelease versions will ever be selected if the user doesn't +// explicitly allow them. +// +// [NPM's semantics]: https://www.npmjs.org/doc/misc/semver.html#prerelease-tags +// +// Instead, we ensure that release versions will always be preferred over +// prerelease versions by ordering the release versions first in +// [Version.prioritize]. This means that constraints like `any` or +// `>1.2.3` can still match prerelease versions if they're the only things +// available. +bool disallowedByPreRelease(VersionRange range, Version other) { + var maxIsReleaseOfOther = !range.includeMax && + !range.max.isPreRelease && + other.isPreRelease && + _equalsWithoutPreRelease(other, range.max); + var minIsPreReleaseOfOther = range.min != null && + range.min.isPreRelease && + _equalsWithoutPreRelease(other, range.min); + return maxIsReleaseOfOther && !minIsPreReleaseOfOther; +} + +bool _equalsWithoutPreRelease(Version version1, Version version2) => + version1.major == version2.major && + version1.minor == version2.minor && + version1.patch == version2.patch; diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 8e9b4ad13d..b615c6f3db 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -90,44 +90,12 @@ class VersionRange implements Comparable, VersionConstraint { if (max != null) { if (other > max) return false; if (!includeMax && other == max) return false; - - // Disallow pre-release versions that have the same major, minor, and - // patch version as the max, but only if neither the max nor the min is a - // pre-release of that version. This ensures that "^1.2.3" doesn't include - // "2.0.0-pre", while also allowing both ">=2.0.0-pre.2 <2.0.0" and - // ">=1.2.3 <2.0.0-pre.7" to match "2.0.0-pre.5". - // - // It's worth noting that this is different than [NPM's semantics][]. NPM - // disallows **all** pre-release versions unless their major, minor, and - // patch numbers match those of a prerelease min or max. This ensures that - // no prerelease versions will ever be selected if the user doesn't - // explicitly allow them. - // - // [NPM's semantics]: https://www.npmjs.org/doc/misc/semver.html#prerelease-tags - // - // Instead, we ensure that release versions will always be preferred over - // prerelease versions by ordering the release versions first in - // [Version.prioritize]. This means that constraints like "any" or - // ">1.2.3" can still match prerelease versions if they're the only things - // available. - var maxIsReleaseOfOther = !includeMax && - !max.isPreRelease && - other.isPreRelease && - _equalsWithoutPreRelease(other, max); - var minIsPreReleaseOfOther = min != null && - min.isPreRelease && - _equalsWithoutPreRelease(other, min); - if (maxIsReleaseOfOther && !minIsPreReleaseOfOther) return false; + if (disallowedByPreRelease(this, other)) return false; } return true; } - bool _equalsWithoutPreRelease(Version version1, Version version2) => - version1.major == version2.major && - version1.minor == version2.minor && - version1.patch == version2.patch; - bool allowsAll(VersionConstraint other) { if (other.isEmpty) return true; if (other is Version) return allows(other); diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index cefd9d370f..f01101269c 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -228,6 +228,50 @@ main() { range.allowsAll(new VersionRange(min: v123, max: v234).union(v140)), isFalse); }); + + group('pre-release versions', () { + test('of inclusive min are excluded', () { + var range = new VersionRange(min: v123, includeMin: true); + + expect( + range.allowsAll(new VersionConstraint.parse('>1.2.4-dev')), isTrue); + expect(range.allowsAll(new VersionConstraint.parse('>1.2.3-dev')), + isFalse); + }); + + test('of non-pre-release max are excluded', () { + var range = new VersionRange(max: v234); + + expect(range.allowsAll(new VersionConstraint.parse('<2.3.3')), isTrue); + expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev')), + isFalse); + }); + + test( + 'of non-pre-release max are included if min is a pre-release of the ' + 'same version', () { + var range = + new VersionRange(min: new Version.parse('2.3.4-dev.0'), max: v234); + + expect( + range.allowsAll( + new VersionConstraint.parse('>2.3.4-dev.0 <2.3.4-dev.1')), + isTrue); + }); + + test('of pre-release max are included', () { + var range = new VersionRange(max: new Version.parse('2.3.4-dev.2')); + + expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev.1')), + isTrue); + expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev.2')), + isTrue); + expect(range.allowsAll(new VersionConstraint.parse('<=2.3.4-dev.2')), + isFalse); + expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev.3')), + isFalse); + }); + }); }); group('allowsAny()', () { @@ -325,6 +369,52 @@ main() { range.allowsAny(new VersionRange(min: v234, max: v300).union(v010)), isFalse); }); + + group('pre-release versions', () { + test('of inclusive min are excluded', () { + var range = new VersionRange(min: v123, includeMin: true); + + expect( + range.allowsAny(new VersionConstraint.parse('<1.2.4-dev')), isTrue); + expect(range.allowsAny(new VersionConstraint.parse('<1.2.3-dev')), + isFalse); + }); + + test('of non-pre-release max are excluded', () { + var range = new VersionRange(max: v234); + + expect(range.allowsAny(new VersionConstraint.parse('>2.3.3')), isTrue); + expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev')), + isFalse); + }); + + test( + 'of non-pre-release max are included if min is a pre-release of the ' + 'same version', () { + var range = + new VersionRange(min: new Version.parse('2.3.4-dev.0'), max: v234); + + expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.1')), + isTrue); + expect(range.allowsAny(new VersionConstraint.parse('>2.3.4')), isFalse); + + expect(range.allowsAny(new VersionConstraint.parse('<2.3.4-dev.1')), + isTrue); + expect(range.allowsAny(new VersionConstraint.parse('<2.3.4-dev')), + isFalse); + }); + + test('of pre-release max are included', () { + var range = new VersionConstraint.parse('<2.3.4-dev.2'); + + expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.1')), + isTrue); + expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.2')), + isFalse); + expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.3')), + isFalse); + }); + }); }); group('intersect()', () { @@ -614,6 +704,13 @@ main() { [v003, new VersionRange(min: v010)])), equals(VersionConstraint.empty)); }); + + test("with a range with a pre-release min, returns the original", () { + expect( + new VersionRange(max: v200) + .difference(new VersionConstraint.parse(">=2.0.0-dev")), + equals(new VersionRange(max: v200))); + }); }); test('isEmpty', () { From a4536c2c60f2fb25580aadf2fcc9c96c07b85f37 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Tue, 3 Apr 2018 15:56:47 -0700 Subject: [PATCH 040/115] Release 1.3.4 (dart-lang/pub_semver#22) --- pkgs/pub_semver/pubspec.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index eac5cb05e3..7f6dd0c25c 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.3.3 +version: 1.3.4 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From fcf5ca86a422cfcc27c49501e9d7d19ca87a9a6d Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Thu, 5 Apr 2018 16:26:15 -0700 Subject: [PATCH 041/115] Fix another pre-release version bug (dart-lang/pub_semver#24) I think at this point we're testing this edge case in all our public APIs. Closes dart-lang/pub_semver#17 Closes dart-lang/pub_semver#23 --- pkgs/pub_semver/CHANGELOG.md | 5 +++ pkgs/pub_semver/lib/src/version_range.dart | 47 ++++++++------------ pkgs/pub_semver/pubspec.yaml | 2 +- pkgs/pub_semver/test/version_range_test.dart | 19 ++++++++ 4 files changed, 43 insertions(+), 30 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 53de84120a..207ba2922b 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,8 @@ +# 1.3.5 + +* Fix a bug where `VersionRange.intersect()` would return incorrect results for + pre-release versions with the same base version number as release versions. + # 1.3.4 * Fix a bug where `VersionRange.allowsAll()`, `VersionRange.allowsAny()`, and diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index b615c6f3db..ae190029fb 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -137,29 +137,26 @@ class VersionRange implements Comparable, VersionConstraint { if (other is VersionRange) { // Intersect the two ranges. - var intersectMin = min; - var intersectIncludeMin = includeMin; - var intersectMax = max; - var intersectIncludeMax = includeMax; - - if (other.min == null) { - // Do nothing. - } else if (intersectMin == null || intersectMin < other.min) { + Version intersectMin; + bool intersectIncludeMin; + if (allowsLower(this, other)) { + if (strictlyLower(this, other)) return VersionConstraint.empty; intersectMin = other.min; intersectIncludeMin = other.includeMin; - } else if (intersectMin == other.min && !other.includeMin) { - // The edges are the same, but one is exclusive, make it exclusive. - intersectIncludeMin = false; + } else { + if (strictlyLower(other, this)) return VersionConstraint.empty; + intersectMin = this.min; + intersectIncludeMin = this.includeMin; } - if (other.max == null) { - // Do nothing. - } else if (intersectMax == null || intersectMax > other.max) { + Version intersectMax; + bool intersectIncludeMax; + if (allowsHigher(this, other)) { intersectMax = other.max; intersectIncludeMax = other.includeMax; - } else if (intersectMax == other.max && !other.includeMax) { - // The edges are the same, but one is exclusive, make it exclusive. - intersectIncludeMax = false; + } else { + intersectMax = this.max; + intersectIncludeMax = this.includeMax; } if (intersectMin == null && intersectMax == null) { @@ -169,18 +166,10 @@ class VersionRange implements Comparable, VersionConstraint { // If the range is just a single version. if (intersectMin == intersectMax) { - // If both ends are inclusive, allow that version. - if (intersectIncludeMin && intersectIncludeMax) return intersectMin; - - // Otherwise, no versions. - return VersionConstraint.empty; - } - - if (intersectMin != null && - intersectMax != null && - intersectMin > intersectMax) { - // Non-overlapping ranges, so empty. - return VersionConstraint.empty; + // Because we already verified that the lower range isn't strictly + // lower, there must be some overlap. + assert(intersectIncludeMin && intersectIncludeMax); + return intersectMin; } // If we got here, there is an actual range. diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 7f6dd0c25c..4dbabe47fd 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.3.4 +version: 1.3.5 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index f01101269c..2c311f5852 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -461,6 +461,14 @@ main() { expect(new VersionRange(min: v123, max: v124).intersect(v114).isEmpty, isTrue); }); + + test("with a range with a pre-release min, returns an empty constraint", + () { + expect( + new VersionRange(max: v200) + .intersect(new VersionConstraint.parse(">=2.0.0-dev")), + equals(VersionConstraint.empty)); + }); }); group('union()', () { @@ -539,6 +547,17 @@ main() { equals(new VersionRange( min: v003, max: v114, includeMin: true, includeMax: true))); }); + + test("with a range with a pre-release min, returns a constraint with a gap", + () { + var result = new VersionRange(max: v200) + .union(new VersionConstraint.parse(">=2.0.0-dev")); + expect(result, allows(v140)); + expect(result, doesNotAllow(new Version.parse("2.0.0-alpha"))); + expect(result, allows(new Version.parse("2.0.0-dev"))); + expect(result, allows(new Version.parse("2.0.0-dev.1"))); + expect(result, allows(new Version.parse("2.0.0"))); + }); }); group('difference()', () { From 93ec025b06ce2a60b477ffc662ad94c30a39e50b Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Mon, 9 Apr 2018 17:46:57 -0700 Subject: [PATCH 042/115] Fix a bug where we'd parse pre-release constraints as empty (dart-lang/pub_semver#25) --- pkgs/pub_semver/CHANGELOG.md | 5 ++ .../lib/src/version_constraint.dart | 52 +++++++++++++------ pkgs/pub_semver/pubspec.yaml | 2 +- .../test/version_constraint_test.dart | 12 +++++ 4 files changed, 54 insertions(+), 17 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 207ba2922b..0246edd7ae 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,8 @@ +# 1.3.6 + +* Fix a bug where constraints that only allowed pre-release versions would be + parsed as empty constraints. + # 1.3.5 * Fix a bug where `VersionRange.intersect()` would return incorrect results for diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 36bbd9aba0..670a9287d8 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -57,7 +57,7 @@ abstract class VersionConstraint { if (text == "any") return any; // Try to parse and consume a version number. - matchVersion() { + Version matchVersion() { var version = START_VERSION.firstMatch(text); if (version == null) return null; @@ -66,7 +66,7 @@ abstract class VersionConstraint { } // Try to parse and consume a comparison operator followed by a version. - matchComparison() { + VersionRange matchComparison() { var comparison = START_COMPARISON.firstMatch(text); if (comparison == null) return null; @@ -117,35 +117,55 @@ abstract class VersionConstraint { var compatibleWith = matchCompatibleWith(); if (compatibleWith != null) return compatibleWith; - var constraints = []; + Version min; + var includeMin = false; + Version max; + var includeMax = false; while (true) { skipWhitespace(); if (text.isEmpty) break; - var version = matchVersion(); - if (version != null) { - constraints.add(version); - continue; + var newRange = matchVersion() ?? matchComparison(); + if (newRange == null) { + throw new FormatException('Could not parse version "$originalText". ' + 'Unknown text at "$text".'); } - var comparison = matchComparison(); - if (comparison != null) { - constraints.add(comparison); - continue; + if (newRange.min != null) { + if (min == null || newRange.min > min) { + min = newRange.min; + includeMin = newRange.includeMin; + } else if (newRange.min == min && !newRange.includeMin) { + includeMin = false; + } } - // If we got here, we couldn't parse the remaining string. - throw new FormatException('Could not parse version "$originalText". ' - 'Unknown text at "$text".'); + if (newRange.max != null) { + if (max == null || newRange.max < max) { + max = newRange.max; + includeMax = newRange.includeMax; + } else if (newRange.max == max && !newRange.includeMax) { + includeMax = false; + } + } } - if (constraints.isEmpty) { + if (min == null && max == null) { throw new FormatException('Cannot parse an empty string.'); } - return new VersionConstraint.intersection(constraints); + if (min != null && max != null) { + if (min > max) return VersionConstraint.empty; + if (min == max) { + if (includeMin && includeMax) return min; + return VersionConstraint.empty; + } + } + + return new VersionRange( + min: min, includeMin: includeMin, max: max, includeMax: includeMax); } /// Creates a version constraint which allows all versions that are diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 4dbabe47fd..1b0beb8ce5 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.3.5 +version: 1.3.6 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index bc378325ef..bf3a01862b 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -103,6 +103,18 @@ main() { new Version.parse('1.3.0'), new Version.parse('3.4.5'))); }); + test('parses a pre-release-only constraint', () { + var constraint = new VersionConstraint.parse('>=1.0.0-dev.2 <1.0.0'); + expect( + constraint, + allows(new Version.parse('1.0.0-dev.2'), + new Version.parse('1.0.0-dev.3'))); + expect( + constraint, + doesNotAllow( + new Version.parse('1.0.0-dev.1'), new Version.parse('1.0.0'))); + }); + test('ignores whitespace around comparison operators', () { var constraint = new VersionConstraint.parse(' >1.0.0>=1.2.3 < 1.3.0'); From 9612e2cb556c9934c314f257cf7234df1ad9af65 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Fri, 13 Apr 2018 11:46:58 -0700 Subject: [PATCH 043/115] Fix more pre-release constraint bugs (dart-lang/pub_semver#26) I hadn't thought to test version ranges with max pre-release constraints, but they turn out to be relevant in some situations. Closes dart-lang/pub_semver#20 --- pkgs/pub_semver/CHANGELOG.md | 5 ++++ pkgs/pub_semver/lib/src/utils.dart | 10 +++++-- pkgs/pub_semver/lib/src/version_range.dart | 29 ++++++++------------ pkgs/pub_semver/pubspec.yaml | 2 +- pkgs/pub_semver/test/version_range_test.dart | 22 +++++++++++++++ 5 files changed, 48 insertions(+), 20 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 0246edd7ae..f2e5e62e68 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,8 @@ +# 1.3.7 + +* Fix more bugs with `VersionRange.intersect()`, `VersionRange.difference()`, + and `VersionRange.union()` involving version ranges with pre-release maximums. + # 1.3.6 * Fix a bug where constraints that only allowed pre-release versions would be diff --git a/pkgs/pub_semver/lib/src/utils.dart b/pkgs/pub_semver/lib/src/utils.dart index d793e7a957..adc1faee9a 100644 --- a/pkgs/pub_semver/lib/src/utils.dart +++ b/pkgs/pub_semver/lib/src/utils.dart @@ -32,10 +32,12 @@ bool allowsHigher(VersionRange range1, VersionRange range2) { if (range1.max == null) return range2.max != null; if (range2.max == null) return false; - // `<1.0.0-dev.1` allows `1.0.0-dev.0` which is higher than any versions - // allowed by `<1.0.0`. + // `<1.0.0-dev.1` allows higher versions than `<1.0.0`, such as `1.0.0-dev.0`. if (disallowedByPreRelease(range2, range1.max)) return true; + // `<1.0.0` doesn't allow any versions higher than `<1.0.0-dev`. + if (disallowedByPreRelease(range1, range2.max)) return false; + var comparison = range1.max.compareTo(range2.max); if (comparison == 1) return true; if (comparison == -1) return false; @@ -46,8 +48,12 @@ bool allowsHigher(VersionRange range1, VersionRange range2) { /// [range2]. bool strictlyLower(VersionRange range1, VersionRange range2) { if (range1.max == null || range2.min == null) return false; + + // `<1.0.0` doesn't allow any versions allowed by `>=1.0.0-dev.0`. if (disallowedByPreRelease(range1, range2.min)) return true; + //if (disallowedByPreRelease(range2, range1.min)) return true; + var comparison = range1.max.compareTo(range2.min); if (comparison == -1) return true; if (comparison == 1) return false; diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index ae190029fb..ec15de4326 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -215,29 +215,24 @@ class VersionRange implements Comparable, VersionConstraint { 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 < min) { + Version unionMin; + bool unionIncludeMin; + if (allowsLower(this, other)) { + unionMin = this.min; + unionIncludeMin = this.includeMin; + } else { unionMin = other.min; unionIncludeMin = other.includeMin; - } else if (min == other.min && other.includeMin) { - // 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 > max) { + Version unionMax; + bool unionIncludeMax; + if (allowsHigher(this, other)) { + unionMax = this.max; + unionIncludeMax = this.includeMax; + } else { unionMax = other.max; unionIncludeMax = other.includeMax; - } else if (max == other.max && other.includeMax) { - // If the edges are the same but one is inclusive, make it inclusive. - unionIncludeMax = true; } return new VersionRange( diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 1b0beb8ce5..1b738d7554 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.3.6 +version: 1.3.7 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index 2c311f5852..63cf302573 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -469,6 +469,13 @@ main() { .intersect(new VersionConstraint.parse(">=2.0.0-dev")), equals(VersionConstraint.empty)); }); + + test("with a range with a pre-release max, returns the original", () { + expect( + new VersionRange(max: v200) + .intersect(new VersionConstraint.parse("<2.0.0-dev")), + equals(new VersionRange(max: v200))); + }); }); group('union()', () { @@ -558,6 +565,14 @@ main() { expect(result, allows(new Version.parse("2.0.0-dev.1"))); expect(result, allows(new Version.parse("2.0.0"))); }); + + test("with a range with a pre-release max, returns the larger constraint", + () { + expect( + new VersionRange(max: v200) + .union(new VersionConstraint.parse("<2.0.0-dev")), + equals(new VersionConstraint.parse("<2.0.0-dev"))); + }); }); group('difference()', () { @@ -730,6 +745,13 @@ main() { .difference(new VersionConstraint.parse(">=2.0.0-dev")), equals(new VersionRange(max: v200))); }); + + test("with a range with a pre-release max, returns null", () { + expect( + new VersionRange(max: v200) + .difference(new VersionConstraint.parse("<2.0.0-dev")), + equals(VersionConstraint.empty)); + }); }); test('isEmpty', () { From 1595c816dc28891cbfee62246ce3bc89f16206f3 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Mon, 23 Apr 2018 16:43:45 -0700 Subject: [PATCH 044/115] Remove an unused import (dart-lang/pub_semver#27) --- pkgs/pub_semver/lib/src/utils.dart | 2 -- 1 file changed, 2 deletions(-) diff --git a/pkgs/pub_semver/lib/src/utils.dart b/pkgs/pub_semver/lib/src/utils.dart index adc1faee9a..55025a0afd 100644 --- a/pkgs/pub_semver/lib/src/utils.dart +++ b/pkgs/pub_semver/lib/src/utils.dart @@ -2,8 +2,6 @@ // 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. -import 'package:collection/collection.dart'; - import 'version.dart'; import 'version_range.dart'; From 5ae16b9a169b4f35611e9340b3395cb46a93827a Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Tue, 1 May 2018 17:22:15 -0700 Subject: [PATCH 045/115] Handle pre-release semantics by adjusting the max version of ranges (dart-lang/pub_semver#28) Rather than adding special-cases to each operation, we now just modify the upper bound of version ranges when the special pre-release semantics would come into play. Closes dart-lang/pubdart-lang/pub_semver#1885 --- pkgs/pub_semver/CHANGELOG.md | 22 ++ pkgs/pub_semver/lib/pub_semver.dart | 2 +- pkgs/pub_semver/lib/src/utils.dart | 46 +--- pkgs/pub_semver/lib/src/version.dart | 12 +- .../lib/src/version_constraint.dart | 18 +- pkgs/pub_semver/lib/src/version_range.dart | 98 +++++-- pkgs/pub_semver/pubspec.yaml | 2 +- pkgs/pub_semver/test/utils.dart | 4 + pkgs/pub_semver/test/version_range_test.dart | 254 ++++++++++++++++-- pkgs/pub_semver/test/version_test.dart | 8 +- pkgs/pub_semver/test/version_union_test.dart | 53 +++- 11 files changed, 400 insertions(+), 119 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index f2e5e62e68..0efa0ea7bb 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,25 @@ +# 1.4.0 + +* Add a `Version.firstPreRelease` getter that returns the first possible + pre-release of a version. + +* Add a `Version.isFirstPreRelease` getter that returns whether a version is the + first possible pre-release. + +* `new VersionRange()` with an exclusive maximum now replaces the maximum with + its first pre-release version. This matches the existing semantics, where an + exclusive maximum would exclude pre-release versions of that maximum. + + Explicitly representing this by changing the maximum version ensures that all + operations behave correctly with respect to the special pre-release semantics. + In particular, it fixes bugs where, for example, + `(>=1.0.0 <2.0.0-dev).union(>=2.0.0-dev <2.0.0)` and + `(>=1.0.0 <3.0.0).difference(^1.0.0)` wouldn't include `2.0.0-dev`. + +* Add an `alwaysIncludeMaxPreRelease` parameter to `new VersionRange()`, which + disables the replacement described above and allows users to create ranges + that do include the pre-release versions of an exclusive max version. + # 1.3.7 * Fix more bugs with `VersionRange.intersect()`, `VersionRange.difference()`, diff --git a/pkgs/pub_semver/lib/pub_semver.dart b/pkgs/pub_semver/lib/pub_semver.dart index bfb7d8b704..4b6487c9e3 100644 --- a/pkgs/pub_semver/lib/pub_semver.dart +++ b/pkgs/pub_semver/lib/pub_semver.dart @@ -4,5 +4,5 @@ export 'src/version.dart'; export 'src/version_constraint.dart'; -export 'src/version_range.dart'; +export 'src/version_range.dart' hide CompatibleWithVersionRange; export 'src/version_union.dart'; diff --git a/pkgs/pub_semver/lib/src/utils.dart b/pkgs/pub_semver/lib/src/utils.dart index 55025a0afd..60617f22e6 100644 --- a/pkgs/pub_semver/lib/src/utils.dart +++ b/pkgs/pub_semver/lib/src/utils.dart @@ -30,12 +30,6 @@ bool allowsHigher(VersionRange range1, VersionRange range2) { if (range1.max == null) return range2.max != null; if (range2.max == null) return false; - // `<1.0.0-dev.1` allows higher versions than `<1.0.0`, such as `1.0.0-dev.0`. - if (disallowedByPreRelease(range2, range1.max)) return true; - - // `<1.0.0` doesn't allow any versions higher than `<1.0.0-dev`. - if (disallowedByPreRelease(range1, range2.max)) return false; - var comparison = range1.max.compareTo(range2.max); if (comparison == 1) return true; if (comparison == -1) return false; @@ -47,11 +41,6 @@ bool allowsHigher(VersionRange range1, VersionRange range2) { bool strictlyLower(VersionRange range1, VersionRange range2) { if (range1.max == null || range2.min == null) return false; - // `<1.0.0` doesn't allow any versions allowed by `>=1.0.0-dev.0`. - if (disallowedByPreRelease(range1, range2.min)) return true; - - //if (disallowedByPreRelease(range2, range1.min)) return true; - var comparison = range1.max.compareTo(range2.min); if (comparison == -1) return true; if (comparison == 1) return false; @@ -63,40 +52,7 @@ bool strictlyLower(VersionRange range1, VersionRange range2) { bool strictlyHigher(VersionRange range1, VersionRange range2) => strictlyLower(range2, range1); -// Returns whether [other] is disallowed by [range] because we disallow -// pre-release versions that have the same major, minor, and patch version as -// the max of a range, but only if neither the max nor the min is a pre-release -// of that version. -// -// This ensures that `^1.2.3` doesn't include `2.0.0-pre`, while also allowing -// both `>=2.0.0-pre.2 <2.0.0` and `>=1.2.3 <2.0.0-pre.7` to match -// `2.0.0-pre.5`. -// -// It's worth noting that this is different than [NPM's semantics][]. NPM -// disallows **all** pre-release versions unless their major, minor, and -// patch numbers match those of a prerelease min or max. This ensures that -// no prerelease versions will ever be selected if the user doesn't -// explicitly allow them. -// -// [NPM's semantics]: https://www.npmjs.org/doc/misc/semver.html#prerelease-tags -// -// Instead, we ensure that release versions will always be preferred over -// prerelease versions by ordering the release versions first in -// [Version.prioritize]. This means that constraints like `any` or -// `>1.2.3` can still match prerelease versions if they're the only things -// available. -bool disallowedByPreRelease(VersionRange range, Version other) { - var maxIsReleaseOfOther = !range.includeMax && - !range.max.isPreRelease && - other.isPreRelease && - _equalsWithoutPreRelease(other, range.max); - var minIsPreReleaseOfOther = range.min != null && - range.min.isPreRelease && - _equalsWithoutPreRelease(other, range.min); - return maxIsReleaseOfOther && !minIsPreReleaseOfOther; -} - -bool _equalsWithoutPreRelease(Version version1, Version version2) => +bool equalsWithoutPreRelease(Version version1, Version version2) => version1.major == version2.major && version1.minor == version2.minor && version1.patch == version2.patch; diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 6665873de0..19ae962621 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -239,6 +239,12 @@ class Version implements VersionConstraint, VersionRange { return _incrementMajor(); } + /// Returns the first possible pre-release of this version. + Version get firstPreRelease => new Version(major, minor, patch, pre: "0"); + + /// Returns whether this is the first possible pre-release of its version. + bool get isFirstPreRelease => preRelease.length == 1 && preRelease.first == 0; + Version _incrementMajor() => new Version(major + 1, 0, 0); Version _incrementMinor() => new Version(major, minor + 1, 0); Version _incrementPatch() => new Version(major, minor, patch + 1); @@ -262,7 +268,8 @@ class Version implements VersionConstraint, VersionRange { min: other.min, max: other.max, includeMin: true, - includeMax: other.includeMax); + includeMax: other.includeMax, + alwaysIncludeMaxPreRelease: true); } if (other.max == this) { @@ -270,7 +277,8 @@ class Version implements VersionConstraint, VersionRange { min: other.min, max: other.max, includeMin: other.includeMin, - includeMax: true); + includeMax: true, + alwaysIncludeMaxPreRelease: true); } } diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 670a9287d8..67093f701d 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -84,7 +84,10 @@ abstract class VersionConstraint { case '<=': return new VersionRange(max: version, includeMax: true); case '<': - return new VersionRange(max: version, includeMax: false); + return new VersionRange( + max: version, + includeMax: false, + alwaysIncludeMaxPreRelease: true); case '>=': return new VersionRange(min: version, includeMin: true); case '>': @@ -175,7 +178,7 @@ abstract class VersionConstraint { /// are greater than or equal to [version], but less than the next breaking /// version ([Version.nextBreaking]) of [version]. factory VersionConstraint.compatibleWith(Version version) => - new _CompatibleWithVersionRange(version); + new CompatibleWithVersionRange(version); /// Creates a new version constraint that is the intersection of /// [constraints]. @@ -278,14 +281,3 @@ class _EmptyVersion implements VersionConstraint { VersionConstraint difference(VersionConstraint other) => this; String toString() => ''; } - -class _CompatibleWithVersionRange extends VersionRange { - _CompatibleWithVersionRange(Version version) - : super( - min: version, - includeMin: true, - max: version.nextBreaking, - includeMax: false); - - String toString() => '^$min'; -} diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index ec15de4326..99dc7189d7 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -53,14 +53,36 @@ class VersionRange implements Comparable, VersionConstraint { /// /// If [includeMin] is `true`, then the minimum end of the range is inclusive. /// Likewise, passing [includeMax] as `true` makes the upper end inclusive. - VersionRange( - {this.min, this.max, this.includeMin: false, this.includeMax: false}) { + /// + /// If [alwaysIncludeMaxPreRelease] is `true`, this will always include + /// pre-release versions of an exclusive [max]. Otherwise, it will use the + /// default behavior for pre-release versions of [max]. + factory VersionRange( + {Version min, + Version max, + bool includeMin: false, + bool includeMax: false, + bool alwaysIncludeMaxPreRelease: false}) { if (min != null && max != null && min > max) { throw new ArgumentError( 'Minimum version ("$min") must be less than maximum ("$max").'); } + + if (!alwaysIncludeMaxPreRelease && + !includeMax && + max != null && + !max.isPreRelease && + (min == null || + !min.isPreRelease || + !equalsWithoutPreRelease(min, max))) { + max = max.firstPreRelease; + } + + return new VersionRange._(min, max, includeMin, includeMax); } + VersionRange._(this.min, this.max, this.includeMin, this.includeMax); + bool operator ==(other) { if (other is! VersionRange) return false; @@ -90,7 +112,6 @@ class VersionRange implements Comparable, VersionConstraint { if (max != null) { if (other > max) return false; if (!includeMax && other == max) return false; - if (disallowedByPreRelease(this, other)) return false; } return true; @@ -177,7 +198,8 @@ class VersionRange implements Comparable, VersionConstraint { min: intersectMin, max: intersectMax, includeMin: intersectIncludeMin, - includeMax: intersectIncludeMax); + includeMax: intersectIncludeMax, + alwaysIncludeMaxPreRelease: true); } throw new ArgumentError('Unknown VersionConstraint type $other.'); @@ -192,7 +214,8 @@ class VersionRange implements Comparable, VersionConstraint { min: this.min, max: this.max, includeMin: true, - includeMax: this.includeMax); + includeMax: this.includeMax, + alwaysIncludeMaxPreRelease: true); } if (other == max) { @@ -200,7 +223,8 @@ class VersionRange implements Comparable, VersionConstraint { min: this.min, max: this.max, includeMin: this.includeMin, - includeMax: true); + includeMax: true, + alwaysIncludeMaxPreRelease: true); } return new VersionConstraint.unionOf([this, other]); @@ -239,7 +263,8 @@ class VersionRange implements Comparable, VersionConstraint { min: unionMin, max: unionMax, includeMin: unionIncludeMin, - includeMax: unionIncludeMax); + includeMax: unionIncludeMax, + alwaysIncludeMaxPreRelease: true); } return new VersionConstraint.unionOf([this, other]); @@ -254,20 +279,36 @@ class VersionRange implements Comparable, VersionConstraint { if (other == min) { if (!includeMin) return this; return new VersionRange( - min: min, max: max, includeMin: false, includeMax: includeMax); + min: min, + max: max, + includeMin: false, + includeMax: includeMax, + alwaysIncludeMaxPreRelease: true); } if (other == max) { if (!includeMax) return this; return new VersionRange( - min: min, max: max, includeMin: includeMin, includeMax: false); + min: min, + max: max, + includeMin: includeMin, + includeMax: false, + alwaysIncludeMaxPreRelease: true); } return new VersionUnion.fromRanges([ new VersionRange( - min: min, max: other, includeMin: includeMin, includeMax: false), + min: min, + max: other, + includeMin: includeMin, + includeMax: false, + alwaysIncludeMaxPreRelease: true), new VersionRange( - min: other, max: max, includeMin: false, includeMax: includeMax) + min: other, + max: max, + includeMin: false, + includeMax: includeMax, + alwaysIncludeMaxPreRelease: true) ]); } else if (other is VersionRange) { if (!allowsAny(other)) return this; @@ -284,7 +325,8 @@ class VersionRange implements Comparable, VersionConstraint { min: min, max: other.min, includeMin: includeMin, - includeMax: !other.includeMin); + includeMax: !other.includeMin, + alwaysIncludeMaxPreRelease: true); } VersionRange after; @@ -299,7 +341,8 @@ class VersionRange implements Comparable, VersionConstraint { min: other.max, max: max, includeMin: !other.includeMax, - includeMax: includeMax); + includeMax: includeMax, + alwaysIncludeMaxPreRelease: true); } if (before == null && after == null) return VersionConstraint.empty; @@ -379,11 +422,36 @@ class VersionRange implements Comparable, VersionConstraint { if (max != null) { if (min != null) buffer.write(' '); - buffer.write(includeMax ? '<=' : '<'); - buffer.write(max); + if (includeMax) { + buffer.write('<='); + buffer.write(max); + } else { + buffer.write('<'); + if (max.isFirstPreRelease) { + // Since `"<$max"` would parse the same as `"<$max-0"`, we just emit + // `<$max` to avoid confusing "-0" suffixes. + buffer.write("${max.major}.${max.minor}.${max.patch}"); + } else { + buffer.write(max); + + // If `">=$min <$max"` would parse as `">=$min <$max-0"`, add `-*` to + // indicate that actually does allow pre-release versions. + var minIsPreReleaseOfMax = min != null && + min.isPreRelease && + equalsWithoutPreRelease(min, max); + if (!max.isPreRelease && !minIsPreReleaseOfMax) buffer.write("-∞"); + } + } } if (min == null && max == null) buffer.write('any'); return buffer.toString(); } } + +class CompatibleWithVersionRange extends VersionRange { + CompatibleWithVersionRange(Version version) + : super._(version, version.nextBreaking.firstPreRelease, true, false); + + String toString() => '^$min'; +} diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 1b738d7554..a537788f5a 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.3.7 +version: 1.4.0 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart index 9b28c6a224..8ecd8f5d69 100644 --- a/pkgs/pub_semver/test/utils.dart +++ b/pkgs/pub_semver/test/utils.dart @@ -22,6 +22,10 @@ final v234 = new Version.parse('2.3.4'); final v250 = new Version.parse('2.5.0'); final v300 = new Version.parse('3.0.0'); +/// A range that allows pre-release versions of its max version. +final includeMaxPreReleaseRange = + new VersionRange(max: v200, alwaysIncludeMaxPreRelease: true); + /// A [Matcher] that tests if a [VersionConstraint] allows or does not allow a /// given list of [Version]s. class _VersionConstraintMatcher implements Matcher { diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index 63cf302573..4bdc21c92c 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -14,7 +14,25 @@ main() { var range = new VersionRange(min: v123, max: v124); expect(range.isAny, isFalse); expect(range.min, equals(v123)); - expect(range.max, equals(v124)); + expect(range.max, equals(v124.firstPreRelease)); + }); + + group("doesn't make the max a pre-release if", () { + test("it's already a pre-release", () { + expect(new VersionRange(max: new Version.parse("1.2.4-pre")).max, + equals(new Version.parse("1.2.4-pre"))); + }); + + test("includeMax is true", () { + expect(new VersionRange(max: v124, includeMax: true).max, equals(v124)); + }); + + test("min is a prerelease of max", () { + expect( + new VersionRange(min: new Version.parse("1.2.4-pre"), max: v124) + .max, + equals(v124)); + }); }); test('allows omitting max', () { @@ -158,6 +176,10 @@ main() { expect(range, allows(new Version.parse('0.0.0'), new Version.parse('999.99.9'))); }); + + test('allows pre-releases of the max with includeMaxPreRelease', () { + expect(includeMaxPreReleaseRange, allows(new Version.parse('2.0.0-dev'))); + }); }); group('allowsAll()', () { @@ -247,6 +269,13 @@ main() { isFalse); }); + test('of non-pre-release max are included with includeMaxPreRelease', () { + expect( + includeMaxPreReleaseRange + .allowsAll(new VersionConstraint.parse('<2.0.0-dev')), + isTrue); + }); + test( 'of non-pre-release max are included if min is a pre-release of the ' 'same version', () { @@ -388,6 +417,13 @@ main() { isFalse); }); + test('of non-pre-release max are included with includeMaxPreRelease', () { + expect( + includeMaxPreReleaseRange + .allowsAny(new VersionConstraint.parse('>2.0.0-dev')), + isTrue); + }); + test( 'of non-pre-release max are included if min is a pre-release of the ' 'same version', () { @@ -419,15 +455,10 @@ main() { group('intersect()', () { test('two overlapping ranges', () { - var a = new VersionRange(min: v123, max: v250); - var b = new VersionRange(min: v200, max: v300); - var intersect = a.intersect(b); - expect(intersect, new isInstanceOf()); - var intersectRange = intersect as VersionRange; - expect(intersectRange.min, equals(v200)); - expect(intersectRange.max, equals(v250)); - expect(intersectRange.includeMin, isFalse); - expect(intersectRange.includeMax, isFalse); + expect( + new VersionRange(min: v123, max: v250) + .intersect(new VersionRange(min: v200, max: v300)), + equals(new VersionRange(min: v200, max: v250))); }); test('a non-overlapping range allows no versions', () { @@ -476,6 +507,48 @@ main() { .intersect(new VersionConstraint.parse("<2.0.0-dev")), equals(new VersionRange(max: v200))); }); + + group("with includeMaxPreRelease", () { + test('preserves includeMaxPreRelease if the max version is included', () { + expect( + includeMaxPreReleaseRange + .intersect(new VersionConstraint.parse("<1.0.0")), + equals(new VersionConstraint.parse("<1.0.0"))); + expect( + includeMaxPreReleaseRange + .intersect(new VersionConstraint.parse("<2.0.0")), + equals(new VersionConstraint.parse("<2.0.0"))); + expect(includeMaxPreReleaseRange.intersect(includeMaxPreReleaseRange), + equals(includeMaxPreReleaseRange)); + expect( + includeMaxPreReleaseRange + .intersect(new VersionConstraint.parse("<3.0.0")), + equals(includeMaxPreReleaseRange)); + expect( + includeMaxPreReleaseRange + .intersect(new VersionConstraint.parse(">1.1.4")), + equals(new VersionRange( + min: v114, max: v200, alwaysIncludeMaxPreRelease: true))); + }); + + test( + "and a range with a pre-release min, returns " + "an intersection", () { + expect( + includeMaxPreReleaseRange + .intersect(new VersionConstraint.parse(">=2.0.0-dev")), + equals(new VersionConstraint.parse(">=2.0.0-dev <2.0.0"))); + }); + + test( + "and a range with a pre-release max, returns " + "the narrower constraint", () { + expect( + includeMaxPreReleaseRange + .intersect(new VersionConstraint.parse("<2.0.0-dev")), + equals(new VersionConstraint.parse("<2.0.0-dev"))); + }); + }); }); group('union()', () { @@ -485,7 +558,10 @@ main() { }); test("with a version on the edge of the range, expands the range", () { - expect(new VersionRange(min: v114, max: v124).union(v124), + expect( + new VersionRange( + min: v114, max: v124, alwaysIncludeMaxPreRelease: true) + .union(v124), equals(new VersionRange(min: v114, max: v124, includeMax: true))); expect(new VersionRange(min: v114, max: v124).union(v114), equals(new VersionRange(min: v114, max: v124, includeMin: true))); @@ -533,7 +609,8 @@ main() { .union(new VersionRange(min: v114, max: v200)); expect(result, equals(new VersionRange(min: v003, max: v200))); - result = new VersionRange(min: v003, max: v114) + result = new VersionRange( + min: v003, max: v114, alwaysIncludeMaxPreRelease: true) .union(new VersionRange(min: v114, max: v200, includeMin: true)); expect(result, equals(new VersionRange(min: v003, max: v200))); @@ -541,8 +618,9 @@ main() { .union(new VersionRange(min: v003, max: v114, includeMax: true)); expect(result, equals(new VersionRange(min: v003, max: v200))); - result = new VersionRange(min: v114, max: v200, includeMin: true) - .union(new VersionRange(min: v003, max: v114)); + result = new VersionRange(min: v114, max: v200, includeMin: true).union( + new VersionRange( + min: v003, max: v114, alwaysIncludeMaxPreRelease: true)); expect(result, equals(new VersionRange(min: v003, max: v200))); }); @@ -573,6 +651,39 @@ main() { .union(new VersionConstraint.parse("<2.0.0-dev")), equals(new VersionConstraint.parse("<2.0.0-dev"))); }); + + group("with includeMaxPreRelease", () { + test('adds includeMaxPreRelease if the max version is included', () { + expect( + includeMaxPreReleaseRange + .union(new VersionConstraint.parse("<1.0.0")), + equals(includeMaxPreReleaseRange)); + expect(includeMaxPreReleaseRange.union(includeMaxPreReleaseRange), + equals(includeMaxPreReleaseRange)); + expect( + includeMaxPreReleaseRange + .union(new VersionConstraint.parse("<2.0.0")), + equals(includeMaxPreReleaseRange)); + expect( + includeMaxPreReleaseRange + .union(new VersionConstraint.parse("<3.0.0")), + equals(new VersionConstraint.parse("<3.0.0"))); + }); + + test("and a range with a pre-release min, returns any", () { + expect( + includeMaxPreReleaseRange + .union(new VersionConstraint.parse(">=2.0.0-dev")), + equals(VersionConstraint.any)); + }); + + test("and a range with a pre-release max, returns the original", () { + expect( + includeMaxPreReleaseRange + .union(new VersionConstraint.parse("<2.0.0-dev")), + equals(includeMaxPreReleaseRange)); + }); + }); }); group('difference()', () { @@ -592,7 +703,8 @@ main() { expect( new VersionRange(min: v003, max: v114).difference(v072), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), + new VersionRange( + min: v003, max: v072, alwaysIncludeMaxPreRelease: true), new VersionRange(min: v072, max: v114) ]))); }); @@ -601,7 +713,8 @@ main() { expect( new VersionRange(min: v003, max: v114, includeMax: true) .difference(v114), - equals(new VersionRange(min: v003, max: v114))); + equals(new VersionRange( + min: v003, max: v114, alwaysIncludeMaxPreRelease: true))); }); test("with the min version makes the min exclusive", () { @@ -630,11 +743,11 @@ main() { expect( new VersionRange(min: v080, max: v130) .difference(new VersionRange(min: v010, max: v114)), - equals(new VersionRange(min: v114, max: v130, includeMin: true))); + equals(new VersionConstraint.parse(">=1.1.4-0 <1.3.0"))); expect( new VersionRange(min: v080, max: v130) .difference(new VersionRange(max: v114)), - equals(new VersionRange(min: v114, max: v130, includeMin: true))); + equals(new VersionConstraint.parse(">=1.1.4-0 <1.3.0"))); expect( new VersionRange(min: v080, max: v130).difference( new VersionRange(min: v010, max: v114, includeMax: true)), @@ -646,7 +759,7 @@ main() { expect( new VersionRange(min: v080, max: v130, includeMax: true) .difference(new VersionRange(min: v080, max: v130)), - equals(v130)); + equals(new VersionConstraint.parse(">=1.3.0-0 <=1.3.0"))); }); test("with a range at the end cuts off the end of the range", () { @@ -661,11 +774,13 @@ main() { expect( new VersionRange(min: v080, max: v130).difference( new VersionRange(min: v114, max: v140, includeMin: true)), - equals(new VersionRange(min: v080, max: v114))); + equals(new VersionRange( + min: v080, max: v114, alwaysIncludeMaxPreRelease: true))); expect( new VersionRange(min: v080, max: v130, includeMax: true).difference( new VersionRange(min: v130, max: v140, includeMin: true)), - equals(new VersionRange(min: v080, max: v130))); + equals(new VersionRange( + min: v080, max: v130, alwaysIncludeMaxPreRelease: true))); expect( new VersionRange(min: v080, max: v130, includeMin: true) .difference(new VersionRange(min: v080, max: v130)), @@ -678,7 +793,7 @@ main() { .difference(new VersionRange(min: v072, max: v114)), equals(new VersionConstraint.unionOf([ new VersionRange(min: v003, max: v072, includeMax: true), - new VersionRange(min: v114, max: v130, includeMin: true) + new VersionConstraint.parse(">=1.1.4-0 <1.3.0") ]))); }); @@ -715,8 +830,7 @@ main() { new VersionRange(min: v080, max: v123), new VersionRange(min: v130, max: v200) ])), - equals(new VersionRange( - min: v123, max: v130, includeMin: true, includeMax: true))); + equals(new VersionConstraint.parse(">=1.2.3-0 <=1.3.0"))); }); test("with a version union that intersects the middle, chops it up", () { @@ -724,9 +838,12 @@ main() { new VersionRange(min: v114, max: v140) .difference(new VersionConstraint.unionOf([v123, v124, v130])), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v114, max: v123), - new VersionRange(min: v123, max: v124), - new VersionRange(min: v124, max: v130), + new VersionRange( + min: v114, max: v123, alwaysIncludeMaxPreRelease: true), + new VersionRange( + min: v123, max: v124, alwaysIncludeMaxPreRelease: true), + new VersionRange( + min: v124, max: v130, alwaysIncludeMaxPreRelease: true), new VersionRange(min: v130, max: v140) ]))); }); @@ -752,6 +869,84 @@ main() { .difference(new VersionConstraint.parse("<2.0.0-dev")), equals(VersionConstraint.empty)); }); + + group("with includeMaxPreRelease", () { + group("for the minuend", () { + test("preserves includeMaxPreRelease if the max version is included", + () { + expect( + includeMaxPreReleaseRange + .difference(new VersionConstraint.parse("<1.0.0")), + equals(new VersionRange( + min: new Version.parse("1.0.0-0"), + max: v200, + includeMin: true, + alwaysIncludeMaxPreRelease: true))); + expect( + includeMaxPreReleaseRange + .difference(new VersionConstraint.parse("<2.0.0")), + equals(new VersionRange( + min: v200.firstPreRelease, + max: v200, + includeMin: true, + alwaysIncludeMaxPreRelease: true))); + expect( + includeMaxPreReleaseRange.difference(includeMaxPreReleaseRange), + equals(VersionConstraint.empty)); + expect( + includeMaxPreReleaseRange + .difference(new VersionConstraint.parse("<3.0.0")), + equals(VersionConstraint.empty)); + }); + + test("with a range with a pre-release min, adjusts the max", () { + expect( + includeMaxPreReleaseRange + .difference(new VersionConstraint.parse(">=2.0.0-dev")), + equals(new VersionConstraint.parse("<2.0.0-dev"))); + }); + + test("with a range with a pre-release max, adjusts the min", () { + expect( + includeMaxPreReleaseRange + .difference(new VersionConstraint.parse("<2.0.0-dev")), + equals(new VersionConstraint.parse(">=2.0.0-dev <2.0.0"))); + }); + }); + + group("for the subtrahend", () { + group("doesn't create a pre-release minimum", () { + test("when cutting off the bottom", () { + expect( + new VersionConstraint.parse("<3.0.0") + .difference(includeMaxPreReleaseRange), + equals( + new VersionRange(min: v200, max: v300, includeMin: true))); + }); + + test("with splitting down the middle", () { + expect( + new VersionConstraint.parse("<4.0.0").difference( + new VersionRange( + min: v200, + max: v300, + includeMin: true, + alwaysIncludeMaxPreRelease: true)), + equals(new VersionConstraint.unionOf([ + new VersionRange(max: v200, alwaysIncludeMaxPreRelease: true), + new VersionConstraint.parse(">=3.0.0 <4.0.0") + ]))); + }); + + test("can leave a single version", () { + expect( + new VersionConstraint.parse("<=2.0.0") + .difference(includeMaxPreReleaseRange), + equals(v200)); + }); + }); + }); + }); }); test('isEmpty', () { @@ -786,6 +981,11 @@ main() { new VersionRange(min: v003, max: v080, includeMax: true)); }); + test("includeMaxPreRelease comes after !includeMaxPreRelease", () { + _expectComparesSmaller( + new VersionRange(max: v200), includeMaxPreReleaseRange); + }); + test("no minimum comes before small minimum", () { _expectComparesSmaller( new VersionRange(max: v010), new VersionRange(min: v003, max: v010)); diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index fc6dfef339..448435a577 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -190,8 +190,14 @@ main() { }); test("with a range with the version on the edge, expands the range", () { - expect(v124.union(new VersionRange(min: v114, max: v124)), + expect( + v124.union(new VersionRange( + min: v114, max: v124, alwaysIncludeMaxPreRelease: true)), equals(new VersionRange(min: v114, max: v124, includeMax: true))); + expect( + v124.firstPreRelease.union(new VersionRange(min: v114, max: v124)), + equals(new VersionRange( + min: v114, max: v124.firstPreRelease, includeMax: true))); expect(v114.union(new VersionRange(min: v114, max: v124)), equals(new VersionRange(min: v114, max: v124, includeMin: true))); }); diff --git a/pkgs/pub_semver/test/version_union_test.dart b/pkgs/pub_semver/test/version_union_test.dart index f948832947..f629c83d42 100644 --- a/pkgs/pub_semver/test/version_union_test.dart +++ b/pkgs/pub_semver/test/version_union_test.dart @@ -101,25 +101,32 @@ main() { new VersionConstraint.unionOf([ new VersionRange(min: v003, max: v072, includeMax: true), new VersionRange(min: v072, max: v080), - new VersionRange(min: v114, max: v124), - new VersionRange(min: v124, max: v130, includeMin: true) + new VersionRange( + min: v114, max: v124, alwaysIncludeMaxPreRelease: true), + new VersionRange(min: v124, max: v130, includeMin: true), + new VersionRange( + min: v130.firstPreRelease, max: v200, includeMin: true) ]), equals(new VersionConstraint.unionOf([ new VersionRange(min: v003, max: v080), - new VersionRange(min: v114, max: v130) + new VersionRange(min: v114, max: v200) ]))); }); test("doesn't merge not-quite-adjacent ranges", () { expect( new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - new VersionRange(min: v072, max: v080) + new VersionRange(min: v114, max: v124), + new VersionRange(min: v124, max: v130, includeMin: true) ]), - equals(new VersionConstraint.unionOf([ + isNot(equals(new VersionRange(min: v114, max: v130)))); + + expect( + new VersionConstraint.unionOf([ new VersionRange(min: v003, max: v072), new VersionRange(min: v072, max: v080) - ]))); + ]), + isNot(equals(new VersionRange(min: v003, max: v080)))); }); test("merges version numbers into ranges", () { @@ -139,16 +146,30 @@ main() { test("merges adjacent version numbers into ranges", () { expect( new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), + new VersionRange( + min: v003, max: v072, alwaysIncludeMaxPreRelease: true), v072, v114, - new VersionRange(min: v114, max: v124) + new VersionRange(min: v114, max: v124), + v124.firstPreRelease ]), equals(new VersionConstraint.unionOf([ new VersionRange(min: v003, max: v072, includeMax: true), - new VersionRange(min: v114, max: v124, includeMin: true) + new VersionRange( + min: v114, + max: v124.firstPreRelease, + includeMin: true, + includeMax: true) ]))); }); + + test("doesn't merge not-quite-adjacent version numbers into ranges", () { + expect( + new VersionConstraint.unionOf( + [new VersionRange(min: v003, max: v072), v072]), + isNot(equals( + new VersionRange(min: v003, max: v072, includeMax: true)))); + }); }); test('isEmpty returns false', () { @@ -424,7 +445,8 @@ main() { new VersionRange(min: v124) ])), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v072, max: v080, includeMin: true), + new VersionRange( + min: v072.firstPreRelease, max: v080, includeMin: true), new VersionRange(min: v123, max: v124, includeMax: true) ]))); }); @@ -436,8 +458,10 @@ main() { new VersionRange(min: v130, max: v200) ]).difference(new VersionConstraint.unionOf([v072, v080])), equals(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v072), - new VersionRange(min: v072, max: v080), + new VersionRange( + min: v010, max: v072, alwaysIncludeMaxPreRelease: true), + new VersionRange( + min: v072, max: v080, alwaysIncludeMaxPreRelease: true), new VersionRange(min: v080, max: v114), new VersionRange(min: v130, max: v200) ]))); @@ -455,7 +479,8 @@ main() { equals(new VersionConstraint.unionOf([ new VersionRange(min: v010, max: v072), new VersionRange(min: v080, max: v114, includeMax: true), - new VersionRange(min: v201, max: v234, includeMin: true), + new VersionRange( + min: v201.firstPreRelease, max: v234, includeMin: true), new VersionRange(min: v250, max: v300) ]))); }); From ab3e3dd6e8e6b92f468914aacdb9646955fee315 Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Tue, 1 May 2018 18:28:37 -0700 Subject: [PATCH 046/115] Fix a bug with build identifiers (dart-lang/pub_semver#29) --- pkgs/pub_semver/CHANGELOG.md | 5 +++++ pkgs/pub_semver/lib/src/version_range.dart | 5 ++++- pkgs/pub_semver/test/version_range_test.dart | 5 +++++ 3 files changed, 14 insertions(+), 1 deletion(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 0efa0ea7bb..78865c8861 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,8 @@ +# 1.4.1 + +* Fix a bug where there upper bound of a version range with a build identifier + could accidentally be rewritten. + # 1.4.0 * Add a `Version.firstPreRelease` getter that returns the first possible diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 99dc7189d7..a566891ea2 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -72,6 +72,7 @@ class VersionRange implements Comparable, VersionConstraint { !includeMax && max != null && !max.isPreRelease && + max.build.isEmpty && (min == null || !min.isPreRelease || !equalsWithoutPreRelease(min, max))) { @@ -439,7 +440,9 @@ class VersionRange implements Comparable, VersionConstraint { var minIsPreReleaseOfMax = min != null && min.isPreRelease && equalsWithoutPreRelease(min, max); - if (!max.isPreRelease && !minIsPreReleaseOfMax) buffer.write("-∞"); + if (!max.isPreRelease && max.build.isEmpty && !minIsPreReleaseOfMax) { + buffer.write("-∞"); + } } } } diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index 4bdc21c92c..a24faaea7f 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -33,6 +33,11 @@ main() { .max, equals(v124)); }); + + test("max has a build identifier", () { + expect(new VersionRange(max: new Version.parse("1.2.4+1")).max, + equals(new Version.parse("1.2.4+1"))); + }); }); test('allows omitting max', () { From 98f32005dc4faf3e0534232817129a4ecb759fec Mon Sep 17 00:00:00 2001 From: Natalie Weizenbaum Date: Wed, 2 May 2018 13:00:56 -0700 Subject: [PATCH 047/115] Increase the pubspec version (dart-lang/pub_semver#30) I meant to do this in the last PR. --- pkgs/pub_semver/pubspec.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index a537788f5a..ec526bf89c 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.4.0 +version: 1.4.1 author: Dart Team description: > Versions and version constraints implementing pub's versioning policy. This From 27c6f125ca91786281541e1e9b60fe7070995dc6 Mon Sep 17 00:00:00 2001 From: BC Ko Date: Thu, 24 May 2018 09:05:30 -0700 Subject: [PATCH 048/115] Update .gitignore to new `dart_tool` pub cache (dart-lang/pub_semver#31) dart-lang/sdkdart-lang/pub_semver#32030 --- pkgs/pub_semver/.gitignore | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/pkgs/pub_semver/.gitignore b/pkgs/pub_semver/.gitignore index 98fed01aaf..49ce72d76a 100644 --- a/pkgs/pub_semver/.gitignore +++ b/pkgs/pub_semver/.gitignore @@ -1,6 +1,3 @@ +.dart_tool/ .packages -packages pubspec.lock - -# IntelliJ project. -.idea From 7340a952a2afb228f16209b141745d178c04f8cb Mon Sep 17 00:00:00 2001 From: Patrice Chalin Date: Thu, 19 Jul 2018 15:09:02 -0400 Subject: [PATCH 049/115] chore: set max SDK version to <3.0.0 (dart-lang/pub_semver#32) --- pkgs/pub_semver/CHANGELOG.md | 4 ++++ pkgs/pub_semver/analysis_options.yaml | 2 -- pkgs/pub_semver/pubspec.yaml | 16 ++++++++++------ 3 files changed, 14 insertions(+), 8 deletions(-) delete mode 100644 pkgs/pub_semver/analysis_options.yaml diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 78865c8861..f8feb2460c 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,7 @@ +# 1.4.2 + +* Set max SDK version to `<3.0.0`. + # 1.4.1 * Fix a bug where there upper bound of a version range with a build identifier diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml deleted file mode 100644 index a10d4c5a05..0000000000 --- a/pkgs/pub_semver/analysis_options.yaml +++ /dev/null @@ -1,2 +0,0 @@ -analyzer: - strong-mode: true diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index ec526bf89c..56fa52bf88 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,13 +1,17 @@ name: pub_semver -version: 1.4.1 -author: Dart Team +version: 1.4.2 + description: > Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. +author: Dart Team homepage: http://github.com/dart-lang/pub_semver + +environment: + sdk: '>=1.0.0 <3.0.0' + dependencies: - collection: ">=0.9.0 <2.0.0" + collection: '>=0.9.0 <2.0.0' + dev_dependencies: - test: ">=0.12.0 <0.13.0" -environment: - sdk: ">=1.0.0 <2.0.0" + test: '>=0.12.0 <2.0.0' From 1585cde93b0bb1463b0ed3fdfb287ba847c184db Mon Sep 17 00:00:00 2001 From: Patrice Chalin Date: Wed, 25 Jul 2018 19:30:26 -0400 Subject: [PATCH 050/115] Don't test under 1.21.1 (dart-lang/pub_semver#33) Context: https://github.com/dart-lang/pub_semver/commit/c8859a59688e71fb9d3a2a966340fbfaf45f6239#r29835939 --- pkgs/pub_semver/.travis.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/pkgs/pub_semver/.travis.yml b/pkgs/pub_semver/.travis.yml index 6788deead4..c654072250 100644 --- a/pkgs/pub_semver/.travis.yml +++ b/pkgs/pub_semver/.travis.yml @@ -3,7 +3,6 @@ sudo: false dart: - dev - stable - - 1.21.1 dart_task: - test From 7d1503abfe738282fc31096f9a0f164f1326d784 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Mon, 6 May 2019 10:15:36 -0700 Subject: [PATCH 051/115] Enable and fix a number of lints, test on oldest supported SDK (dart-lang/pub_semver#37) Bump min SDK to Dart 2.0 --- pkgs/pub_semver/.travis.yml | 18 +- pkgs/pub_semver/CHANGELOG.md | 5 + pkgs/pub_semver/analysis_options.yaml | 93 +++ pkgs/pub_semver/lib/src/patterns.dart | 10 +- pkgs/pub_semver/lib/src/version.dart | 53 +- .../lib/src/version_constraint.dart | 64 +- pkgs/pub_semver/lib/src/version_range.dart | 94 ++- pkgs/pub_semver/lib/src/version_union.dart | 14 +- pkgs/pub_semver/pubspec.yaml | 10 +- pkgs/pub_semver/test/utils.dart | 34 +- .../test/version_constraint_test.dart | 131 ++- pkgs/pub_semver/test/version_range_test.dart | 746 +++++++++--------- pkgs/pub_semver/test/version_test.dart | 159 ++-- pkgs/pub_semver/test/version_union_test.dart | 373 +++++---- 14 files changed, 929 insertions(+), 875 deletions(-) create mode 100644 pkgs/pub_semver/analysis_options.yaml diff --git a/pkgs/pub_semver/.travis.yml b/pkgs/pub_semver/.travis.yml index c654072250..0e732d0e73 100644 --- a/pkgs/pub_semver/.travis.yml +++ b/pkgs/pub_semver/.travis.yml @@ -1,13 +1,23 @@ language: dart -sudo: false + dart: - dev - - stable + - 2.0.0 dart_task: - test - - dartfmt - - dartanalyzer + +matrix: + include: + # Only validate formatting using the dev release + - dart: dev + dart_task: dartfmt + - dart: dev + dart_task: + dartanalyzer: --fatal-warnings --fatal-hints . + - dart: 2.0.0 + dart_task: + dartanalyzer: --fatal-warnings . # Only building master means that we don't run two builds for each pull request. branches: diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index f8feb2460c..4183252553 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,8 @@ +# 1.4.3 + +- Update Dart SDK constraint to `>=2.0.0 <3.0.0`. +- Update `package:collection` constraint to `^1.0.0`. + # 1.4.2 * Set max SDK version to `<3.0.0`. diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml new file mode 100644 index 0000000000..c970ea7aad --- /dev/null +++ b/pkgs/pub_semver/analysis_options.yaml @@ -0,0 +1,93 @@ +include: package:pedantic/analysis_options.yaml +analyzer: +# strong-mode: +# implicit-casts: false +linter: + rules: + - always_declare_return_types + #- annotate_overrides + - avoid_bool_literals_in_conditional_expressions + - avoid_classes_with_only_static_members + - avoid_empty_else + - avoid_function_literals_in_foreach_calls + - avoid_init_to_null + - avoid_null_checks_in_equality_operators + - avoid_relative_lib_imports + - avoid_renaming_method_parameters + - avoid_return_types_on_setters + - avoid_returning_null + - avoid_returning_null_for_future + - avoid_returning_null_for_void + - avoid_returning_this + - avoid_shadowing_type_parameters + - avoid_single_cascade_in_expression_statements + - avoid_types_as_parameter_names + - avoid_unused_constructor_parameters + - await_only_futures + - camel_case_types + - cancel_subscriptions + - cascade_invocations + - comment_references + - constant_identifier_names + - control_flow_in_finally + - directives_ordering + - empty_catches + - empty_constructor_bodies + - empty_statements + - file_names + - hash_and_equals + - implementation_imports + - invariant_booleans + - iterable_contains_unrelated_type + - join_return_with_assignment + - library_names + - library_prefixes + - list_remove_unrelated_type + - literal_only_boolean_expressions + - no_adjacent_strings_in_list + - no_duplicate_case_values + - non_constant_identifier_names + - null_closures + - omit_local_variable_types + - only_throw_errors + - overridden_fields + - package_api_docs + - package_names + - package_prefixed_library_names + - prefer_adjacent_string_concatenation + - prefer_collection_literals + - prefer_conditional_assignment + - prefer_const_constructors + - prefer_contains + - prefer_equal_for_default_values + - prefer_final_fields + #- prefer_final_locals + - prefer_generic_function_type_aliases + - prefer_initializing_formals + - prefer_interpolation_to_compose_strings + - prefer_is_empty + - prefer_is_not_empty + - prefer_null_aware_operators + #- prefer_single_quotes + - prefer_typing_uninitialized_variables + - recursive_getters + - slash_for_doc_comments + - test_types_in_equals + - throw_in_finally + - type_init_formals + - unawaited_futures + - unnecessary_await_in_return + - unnecessary_brace_in_string_interps + - unnecessary_const + - unnecessary_getters_setters + - unnecessary_lambdas + - unnecessary_new + - unnecessary_null_aware_assignments + - unnecessary_parenthesis + - unnecessary_statements + - unnecessary_this + - unrelated_type_equality_checks + - use_function_type_syntax_for_parameters + - use_rethrow_when_possible + - valid_regexps + - void_checks diff --git a/pkgs/pub_semver/lib/src/patterns.dart b/pkgs/pub_semver/lib/src/patterns.dart index c4d75d4b76..8829447fad 100644 --- a/pkgs/pub_semver/lib/src/patterns.dart +++ b/pkgs/pub_semver/lib/src/patterns.dart @@ -3,17 +3,17 @@ // BSD-style license that can be found in the LICENSE file. /// Regex that matches a version number at the beginning of a string. -final START_VERSION = new RegExp(r'^' // Start at beginning. +final startVersion = RegExp(r'^' // Start at beginning. r'(\d+).(\d+).(\d+)' // Version number. r'(-([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?' // Pre-release. r'(\+([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?'); // Build. -/// Like [START_VERSION] but matches the entire string. -final COMPLETE_VERSION = new RegExp(START_VERSION.pattern + r'$'); +/// Like [startVersion] but matches the entire string. +final completeVersion = RegExp('${startVersion.pattern}\$'); /// Parses a comparison operator ("<", ">", "<=", or ">=") at the beginning of /// a string. -final START_COMPARISON = new RegExp(r"^[<>]=?"); +final startComparison = RegExp(r"^[<>]=?"); /// The "compatible with" operator. -const COMPATIBLE_WITH = "^"; +const compatibleWithChar = "^"; diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 19ae962621..031af5201b 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -16,7 +16,7 @@ final _equality = const IterableEquality(); /// A parsed semantic version number. class Version implements VersionConstraint, VersionRange { /// No released version: i.e. "0.0.0". - static Version get none => new Version(0, 0, 0); + static Version get none => Version(0, 0, 0); /// Compares [a] and [b] to see which takes priority over the other. /// @@ -92,12 +92,9 @@ class Version implements VersionConstraint, VersionRange { 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.'); + if (major < 0) throw ArgumentError('Major version must be non-negative.'); + if (minor < 0) throw ArgumentError('Minor version must be non-negative.'); + if (patch < 0) throw ArgumentError('Patch version must be non-negative.'); } /// Creates a new [Version] object. @@ -106,27 +103,27 @@ class Version implements VersionConstraint, VersionRange { if (pre != null) text += "-$pre"; if (build != null) text += "+$build"; - return new Version._(major, minor, patch, pre, build, text); + return Version._(major, minor, patch, pre, build, text); } /// Creates a new [Version] by parsing [text]. factory Version.parse(String text) { - final match = COMPLETE_VERSION.firstMatch(text); + final match = completeVersion.firstMatch(text); if (match == null) { - throw new FormatException('Could not parse "$text".'); + throw FormatException('Could not parse "$text".'); } try { - int major = int.parse(match[1]); - int minor = int.parse(match[2]); - int patch = int.parse(match[3]); + var major = int.parse(match[1]); + var minor = int.parse(match[2]); + var patch = int.parse(match[3]); - String preRelease = match[5]; - String build = match[8]; + var preRelease = match[5]; + var build = match[8]; - return new Version._(major, minor, patch, preRelease, build, text); + return Version._(major, minor, patch, preRelease, build, text); } on FormatException { - throw new FormatException('Could not parse "$text".'); + throw FormatException('Could not parse "$text".'); } } @@ -135,7 +132,7 @@ class Version implements VersionConstraint, VersionRange { /// 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 versions) { - var primary; + Version primary; for (var version in versions) { if (primary == null || (!version.isPreRelease && primary.isPreRelease) || @@ -195,7 +192,7 @@ class Version implements VersionConstraint, VersionRange { /// and patch. Version get nextMajor { if (isPreRelease && minor == 0 && patch == 0) { - return new Version(major, minor, patch); + return Version(major, minor, patch); } return _incrementMajor(); @@ -208,7 +205,7 @@ class Version implements VersionConstraint, VersionRange { /// Otherwise, it increments the minor version and resets the patch. Version get nextMinor { if (isPreRelease && patch == 0) { - return new Version(major, minor, patch); + return Version(major, minor, patch); } return _incrementMinor(); @@ -220,7 +217,7 @@ class Version implements VersionConstraint, VersionRange { /// suffix. Otherwise, it increments the patch version. Version get nextPatch { if (isPreRelease) { - return new Version(major, minor, patch); + return Version(major, minor, patch); } return _incrementPatch(); @@ -240,14 +237,14 @@ class Version implements VersionConstraint, VersionRange { } /// Returns the first possible pre-release of this version. - Version get firstPreRelease => new Version(major, minor, patch, pre: "0"); + Version get firstPreRelease => Version(major, minor, patch, pre: "0"); /// Returns whether this is the first possible pre-release of its version. bool get isFirstPreRelease => preRelease.length == 1 && preRelease.first == 0; - Version _incrementMajor() => new Version(major + 1, 0, 0); - Version _incrementMinor() => new Version(major, minor + 1, 0); - Version _incrementPatch() => new Version(major, minor, patch + 1); + Version _incrementMajor() => Version(major + 1, 0, 0); + Version _incrementMinor() => Version(major, minor + 1, 0); + Version _incrementPatch() => Version(major, minor, patch + 1); /// Tests if [other] matches this version exactly. bool allows(Version other) => this == other; @@ -264,7 +261,7 @@ class Version implements VersionConstraint, VersionRange { if (other is VersionRange) { if (other.min == this) { - return new VersionRange( + return VersionRange( min: other.min, max: other.max, includeMin: true, @@ -273,7 +270,7 @@ class Version implements VersionConstraint, VersionRange { } if (other.max == this) { - return new VersionRange( + return VersionRange( min: other.min, max: other.max, includeMin: other.includeMin, @@ -282,7 +279,7 @@ class Version implements VersionConstraint, VersionRange { } } - return new VersionConstraint.unionOf([this, other]); + return VersionConstraint.unionOf([this, other]); } VersionConstraint difference(VersionConstraint other) => diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 67093f701d..6dfd396f57 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -16,7 +16,7 @@ import 'version_union.dart'; /// version. abstract class VersionConstraint { /// A [VersionConstraint] that allows all versions. - static VersionConstraint any = new VersionRange(); + static VersionConstraint any = VersionRange(); /// A [VersionConstraint] that allows no versions -- the empty set. static VersionConstraint empty = const _EmptyVersion(); @@ -47,7 +47,7 @@ abstract class VersionConstraint { factory VersionConstraint.parse(String text) { var originalText = text; - skipWhitespace() { + void skipWhitespace() { text = text.trim(); } @@ -58,16 +58,16 @@ abstract class VersionConstraint { // Try to parse and consume a version number. Version matchVersion() { - var version = START_VERSION.firstMatch(text); + var version = startVersion.firstMatch(text); if (version == null) return null; text = text.substring(version.end); - return new Version.parse(version[0]); + return Version.parse(version[0]); } // Try to parse and consume a comparison operator followed by a version. VersionRange matchComparison() { - var comparison = START_COMPARISON.firstMatch(text); + var comparison = startComparison.firstMatch(text); if (comparison == null) return null; var op = comparison[0]; @@ -76,45 +76,45 @@ abstract class VersionConstraint { var version = matchVersion(); if (version == null) { - throw new FormatException('Expected version number after "$op" in ' + throw FormatException('Expected version number after "$op" in ' '"$originalText", got "$text".'); } switch (op) { case '<=': - return new VersionRange(max: version, includeMax: true); + return VersionRange(max: version, includeMax: true); case '<': - return new VersionRange( + return VersionRange( max: version, includeMax: false, alwaysIncludeMaxPreRelease: true); case '>=': - return new VersionRange(min: version, includeMin: true); + return VersionRange(min: version, includeMin: true); case '>': - return new VersionRange(min: version, includeMin: false); + return VersionRange(min: version, includeMin: false); } - throw "Unreachable."; + throw FallThroughError(); } // Try to parse the "^" operator followed by a version. - matchCompatibleWith() { - if (!text.startsWith(COMPATIBLE_WITH)) return null; + VersionConstraint matchCompatibleWith() { + if (!text.startsWith(compatibleWithChar)) return null; - text = text.substring(COMPATIBLE_WITH.length); + text = text.substring(compatibleWithChar.length); skipWhitespace(); var version = matchVersion(); if (version == null) { - throw new FormatException('Expected version number after ' - '"$COMPATIBLE_WITH" in "$originalText", got "$text".'); + throw FormatException('Expected version number after ' + '"$compatibleWithChar" in "$originalText", got "$text".'); } if (text.isNotEmpty) { - throw new FormatException('Cannot include other constraints with ' - '"$COMPATIBLE_WITH" constraint in "$originalText".'); + throw FormatException('Cannot include other constraints with ' + '"$compatibleWithChar" constraint in "$originalText".'); } - return new VersionConstraint.compatibleWith(version); + return VersionConstraint.compatibleWith(version); } var compatibleWith = matchCompatibleWith(); @@ -125,14 +125,14 @@ abstract class VersionConstraint { Version max; var includeMax = false; - while (true) { + for (;;) { skipWhitespace(); if (text.isEmpty) break; var newRange = matchVersion() ?? matchComparison(); if (newRange == null) { - throw new FormatException('Could not parse version "$originalText". ' + throw FormatException('Could not parse version "$originalText". ' 'Unknown text at "$text".'); } @@ -156,7 +156,7 @@ abstract class VersionConstraint { } if (min == null && max == null) { - throw new FormatException('Cannot parse an empty string.'); + throw const FormatException('Cannot parse an empty string.'); } if (min != null && max != null) { @@ -167,7 +167,7 @@ abstract class VersionConstraint { } } - return new VersionRange( + return VersionRange( min: min, includeMin: includeMin, max: max, includeMax: includeMax); } @@ -178,7 +178,7 @@ abstract class VersionConstraint { /// are greater than or equal to [version], but less than the next breaking /// version ([Version.nextBreaking]) of [version]. factory VersionConstraint.compatibleWith(Version version) => - new CompatibleWithVersionRange(version); + CompatibleWithVersionRange(version); /// Creates a new version constraint that is the intersection of /// [constraints]. @@ -188,7 +188,7 @@ abstract class VersionConstraint { /// all versions. factory VersionConstraint.intersection( Iterable constraints) { - var constraint = new VersionRange(); + var constraint = VersionRange(); for (var other in constraints) { constraint = constraint.intersect(other); } @@ -217,7 +217,7 @@ abstract class VersionConstraint { // filtered out above. for (var constraint in flattened) { if (constraint is VersionRange) continue; - throw new ArgumentError('Unknown VersionConstraint type $constraint.'); + throw ArgumentError('Unknown VersionConstraint type $constraint.'); } flattened.sort(); @@ -235,7 +235,7 @@ abstract class VersionConstraint { } if (merged.length == 1) return merged.single; - return new VersionUnion.fromRanges(merged); + return VersionUnion.fromRanges(merged); } /// Returns `true` if this constraint allows no versions. @@ -259,7 +259,7 @@ abstract class VersionConstraint { /// this and [other]. VersionConstraint intersect(VersionConstraint other); - /// Returns a [VersionConstraint] that allows [Versions]s allowed by either + /// Returns a [VersionConstraint] that allows [Version]s allowed by either /// this or [other]. VersionConstraint union(VersionConstraint other); @@ -272,12 +272,20 @@ class _EmptyVersion implements VersionConstraint { const _EmptyVersion(); bool get isEmpty => true; + bool get isAny => false; + bool allows(Version other) => false; + bool allowsAll(VersionConstraint other) => other.isEmpty; + bool allowsAny(VersionConstraint other) => false; + VersionConstraint intersect(VersionConstraint other) => this; + VersionConstraint union(VersionConstraint other) => other; + VersionConstraint difference(VersionConstraint other) => this; + String toString() => ''; } diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index a566891ea2..8ac79dab8b 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -60,11 +60,11 @@ class VersionRange implements Comparable, VersionConstraint { factory VersionRange( {Version min, Version max, - bool includeMin: false, - bool includeMax: false, - bool alwaysIncludeMaxPreRelease: false}) { + bool includeMin = false, + bool includeMax = false, + bool alwaysIncludeMaxPreRelease = false}) { if (min != null && max != null && min > max) { - throw new ArgumentError( + throw ArgumentError( 'Minimum version ("$min") must be less than maximum ("$max").'); } @@ -79,7 +79,7 @@ class VersionRange implements Comparable, VersionConstraint { max = max.firstPreRelease; } - return new VersionRange._(min, max, includeMin, includeMax); + return VersionRange._(min, max, includeMin, includeMax); } VersionRange._(this.min, this.max, this.includeMin, this.includeMax); @@ -123,14 +123,14 @@ class VersionRange implements Comparable, VersionConstraint { if (other is Version) return allows(other); if (other is VersionUnion) { - return other.ranges.every((constraint) => allowsAll(constraint)); + return other.ranges.every(allowsAll); } if (other is VersionRange) { return !allowsLower(other, this) && !allowsHigher(other, this); } - throw new ArgumentError('Unknown VersionConstraint type $other.'); + throw ArgumentError('Unknown VersionConstraint type $other.'); } bool allowsAny(VersionConstraint other) { @@ -138,14 +138,14 @@ class VersionRange implements Comparable, VersionConstraint { if (other is Version) return allows(other); if (other is VersionUnion) { - return other.ranges.any((constraint) => allowsAny(constraint)); + return other.ranges.any(allowsAny); } if (other is VersionRange) { return !strictlyLower(other, this) && !strictlyHigher(other, this); } - throw new ArgumentError('Unknown VersionConstraint type $other.'); + throw ArgumentError('Unknown VersionConstraint type $other.'); } VersionConstraint intersect(VersionConstraint other) { @@ -167,8 +167,8 @@ class VersionRange implements Comparable, VersionConstraint { intersectIncludeMin = other.includeMin; } else { if (strictlyLower(other, this)) return VersionConstraint.empty; - intersectMin = this.min; - intersectIncludeMin = this.includeMin; + intersectMin = min; + intersectIncludeMin = includeMin; } Version intersectMax; @@ -177,13 +177,13 @@ class VersionRange implements Comparable, VersionConstraint { intersectMax = other.max; intersectIncludeMax = other.includeMax; } else { - intersectMax = this.max; - intersectIncludeMax = this.includeMax; + intersectMax = max; + intersectIncludeMax = includeMax; } if (intersectMin == null && intersectMax == null) { // Open range. - return new VersionRange(); + return VersionRange(); } // If the range is just a single version. @@ -195,7 +195,7 @@ class VersionRange implements Comparable, VersionConstraint { } // If we got here, there is an actual range. - return new VersionRange( + return VersionRange( min: intersectMin, max: intersectMax, includeMin: intersectIncludeMin, @@ -203,7 +203,7 @@ class VersionRange implements Comparable, VersionConstraint { alwaysIncludeMaxPreRelease: true); } - throw new ArgumentError('Unknown VersionConstraint type $other.'); + throw ArgumentError('Unknown VersionConstraint type $other.'); } VersionConstraint union(VersionConstraint other) { @@ -211,24 +211,24 @@ class VersionRange implements Comparable, VersionConstraint { if (allows(other)) return this; if (other == min) { - return new VersionRange( - min: this.min, - max: this.max, + return VersionRange( + min: min, + max: max, includeMin: true, - includeMax: this.includeMax, + includeMax: includeMax, alwaysIncludeMaxPreRelease: true); } if (other == max) { - return new VersionRange( - min: this.min, - max: this.max, - includeMin: this.includeMin, + return VersionRange( + min: min, + max: max, + includeMin: includeMin, includeMax: true, alwaysIncludeMaxPreRelease: true); } - return new VersionConstraint.unionOf([this, other]); + return VersionConstraint.unionOf([this, other]); } if (other is VersionRange) { @@ -237,14 +237,14 @@ class VersionRange implements Comparable, VersionConstraint { var edgesTouch = (max == other.min && (includeMax || other.includeMin)) || (min == other.max && (includeMin || other.includeMax)); if (!edgesTouch && !allowsAny(other)) { - return new VersionConstraint.unionOf([this, other]); + return VersionConstraint.unionOf([this, other]); } Version unionMin; bool unionIncludeMin; if (allowsLower(this, other)) { - unionMin = this.min; - unionIncludeMin = this.includeMin; + unionMin = min; + unionIncludeMin = includeMin; } else { unionMin = other.min; unionIncludeMin = other.includeMin; @@ -253,14 +253,14 @@ class VersionRange implements Comparable, VersionConstraint { Version unionMax; bool unionIncludeMax; if (allowsHigher(this, other)) { - unionMax = this.max; - unionIncludeMax = this.includeMax; + unionMax = max; + unionIncludeMax = includeMax; } else { unionMax = other.max; unionIncludeMax = other.includeMax; } - return new VersionRange( + return VersionRange( min: unionMin, max: unionMax, includeMin: unionIncludeMin, @@ -268,7 +268,7 @@ class VersionRange implements Comparable, VersionConstraint { alwaysIncludeMaxPreRelease: true); } - return new VersionConstraint.unionOf([this, other]); + return VersionConstraint.unionOf([this, other]); } VersionConstraint difference(VersionConstraint other) { @@ -279,7 +279,7 @@ class VersionRange implements Comparable, VersionConstraint { if (other == min) { if (!includeMin) return this; - return new VersionRange( + return VersionRange( min: min, max: max, includeMin: false, @@ -289,7 +289,7 @@ class VersionRange implements Comparable, VersionConstraint { if (other == max) { if (!includeMax) return this; - return new VersionRange( + return VersionRange( min: min, max: max, includeMin: includeMin, @@ -297,14 +297,14 @@ class VersionRange implements Comparable, VersionConstraint { alwaysIncludeMaxPreRelease: true); } - return new VersionUnion.fromRanges([ - new VersionRange( + return VersionUnion.fromRanges([ + VersionRange( min: min, max: other, includeMin: includeMin, includeMax: false, alwaysIncludeMaxPreRelease: true), - new VersionRange( + VersionRange( min: other, max: max, includeMin: false, @@ -322,7 +322,7 @@ class VersionRange implements Comparable, VersionConstraint { assert(min != null); before = min; } else { - before = new VersionRange( + before = VersionRange( min: min, max: other.min, includeMin: includeMin, @@ -338,7 +338,7 @@ class VersionRange implements Comparable, VersionConstraint { assert(max != null); after = max; } else { - after = new VersionRange( + after = VersionRange( min: other.max, max: max, includeMin: !other.includeMax, @@ -349,7 +349,7 @@ class VersionRange implements Comparable, VersionConstraint { if (before == null && after == null) return VersionConstraint.empty; if (before == null) return after; if (after == null) return before; - return new VersionUnion.fromRanges([before, after]); + return VersionUnion.fromRanges([before, after]); } else if (other is VersionUnion) { var ranges = []; var current = this; @@ -377,10 +377,10 @@ class VersionRange implements Comparable, VersionConstraint { } if (ranges.isEmpty) return current; - return new VersionUnion.fromRanges(ranges..add(current)); + return VersionUnion.fromRanges(ranges..add(current)); } - throw new ArgumentError('Unknown VersionConstraint type $other.'); + throw ArgumentError('Unknown VersionConstraint type $other.'); } int compareTo(VersionRange other) { @@ -398,7 +398,7 @@ class VersionRange implements Comparable, VersionConstraint { return _compareMax(other); } - /// Compares the maximum values of [this] and [other]. + /// Compares the maximum values of `this` and [other]. int _compareMax(VersionRange other) { if (max == null) { if (other.max == null) return 0; @@ -414,18 +414,16 @@ class VersionRange implements Comparable, VersionConstraint { } String toString() { - var buffer = new StringBuffer(); + var buffer = StringBuffer(); if (min != null) { - buffer.write(includeMin ? '>=' : '>'); - buffer.write(min); + buffer..write(includeMin ? '>=' : '>')..write(min); } if (max != null) { if (min != null) buffer.write(' '); if (includeMax) { - buffer.write('<='); - buffer.write(max); + buffer..write('<=')..write(max); } else { buffer.write('<'); if (max.isFirstPreRelease) { diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index 9324d3fb7a..b774163ef4 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -113,7 +113,7 @@ class VersionUnion implements VersionConstraint { if (newRanges.isEmpty) return VersionConstraint.empty; if (newRanges.length == 1) return newRanges.single; - return new VersionUnion.fromRanges(newRanges); + return VersionUnion.fromRanges(newRanges); } VersionConstraint difference(VersionConstraint other) { @@ -125,7 +125,7 @@ class VersionUnion implements VersionConstraint { theirRanges.moveNext(); var current = ourRanges.current; - theirNextRange() { + bool theirNextRange() { if (theirRanges.moveNext()) return true; // If there are no more of their ranges, none of the rest of our ranges @@ -137,14 +137,14 @@ class VersionUnion implements VersionConstraint { return false; } - ourNextRange({bool includeCurrent: true}) { + bool ourNextRange({bool includeCurrent = true}) { if (includeCurrent) newRanges.add(current); if (!ourRanges.moveNext()) return false; current = ourRanges.current; return true; } - while (true) { + for (;;) { // If the current ranges are disjoint, move the lowest one forward. if (strictlyLower(theirRanges.current, current)) { if (!theirNextRange()) break; @@ -187,7 +187,7 @@ class VersionUnion implements VersionConstraint { if (newRanges.isEmpty) return VersionConstraint.empty; if (newRanges.length == 1) return newRanges.single; - return new VersionUnion.fromRanges(newRanges); + return VersionUnion.fromRanges(newRanges); } /// Returns [constraint] as a list of ranges. @@ -197,11 +197,11 @@ class VersionUnion implements VersionConstraint { if (constraint.isEmpty) return []; if (constraint is VersionUnion) return constraint.ranges; if (constraint is VersionRange) return [constraint]; - throw new ArgumentError('Unknown VersionConstraint type $constraint.'); + throw ArgumentError('Unknown VersionConstraint type $constraint.'); } VersionConstraint union(VersionConstraint other) => - new VersionConstraint.unionOf([this, other]); + VersionConstraint.unionOf([this, other]); bool operator ==(other) { if (other is! VersionUnion) return false; diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 56fa52bf88..b92d2f66c6 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,17 +1,17 @@ name: pub_semver -version: 1.4.2 +version: 1.4.3-dev -description: > +description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. author: Dart Team homepage: http://github.com/dart-lang/pub_semver environment: - sdk: '>=1.0.0 <3.0.0' + sdk: '>=2.0.0 <3.0.0' dependencies: - collection: '>=0.9.0 <2.0.0' + collection: ^1.0.0 dev_dependencies: - test: '>=0.12.0 <2.0.0' + test: ^1.0.0 diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart index 8ecd8f5d69..a0fd684c1e 100644 --- a/pkgs/pub_semver/test/utils.dart +++ b/pkgs/pub_semver/test/utils.dart @@ -7,24 +7,24 @@ import 'package:test/test.dart'; import 'package:pub_semver/pub_semver.dart'; /// Some stock example versions to use in tests. -final v003 = new Version.parse('0.0.3'); -final v010 = new Version.parse('0.1.0'); -final v072 = new Version.parse('0.7.2'); -final v080 = new Version.parse('0.8.0'); -final v114 = new Version.parse('1.1.4'); -final v123 = new Version.parse('1.2.3'); -final v124 = new Version.parse('1.2.4'); -final v130 = new Version.parse('1.3.0'); -final v140 = new Version.parse('1.4.0'); -final v200 = new Version.parse('2.0.0'); -final v201 = new Version.parse('2.0.1'); -final v234 = new Version.parse('2.3.4'); -final v250 = new Version.parse('2.5.0'); -final v300 = new Version.parse('3.0.0'); +final v003 = Version.parse('0.0.3'); +final v010 = Version.parse('0.1.0'); +final v072 = Version.parse('0.7.2'); +final v080 = Version.parse('0.8.0'); +final v114 = Version.parse('1.1.4'); +final v123 = Version.parse('1.2.3'); +final v124 = Version.parse('1.2.4'); +final v130 = Version.parse('1.3.0'); +final v140 = Version.parse('1.4.0'); +final v200 = Version.parse('2.0.0'); +final v201 = Version.parse('2.0.1'); +final v234 = Version.parse('2.3.4'); +final v250 = Version.parse('2.5.0'); +final v300 = Version.parse('3.0.0'); /// A range that allows pre-release versions of its max version. final includeMaxPreReleaseRange = - new VersionRange(max: v200, alwaysIncludeMaxPreRelease: true); + VersionRange(max: v200, alwaysIncludeMaxPreRelease: true); /// A [Matcher] that tests if a [VersionConstraint] allows or does not allow a /// given list of [Version]s. @@ -84,7 +84,7 @@ Matcher allows(Version v1, Version v7, Version v8]) { var versions = _makeVersionList(v1, v2, v3, v4, v5, v6, v7, v8); - return new _VersionConstraintMatcher(versions, true); + return _VersionConstraintMatcher(versions, true); } /// Gets a [Matcher] that validates that a [VersionConstraint] allows none of @@ -98,7 +98,7 @@ Matcher doesNotAllow(Version v1, Version v7, Version v8]) { var versions = _makeVersionList(v1, v2, v3, v4, v5, v6, v7, v8); - return new _VersionConstraintMatcher(versions, false); + return _VersionConstraintMatcher(versions, false); } List _makeVersionList(Version v1, diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index bf3a01862b..1e48391ee2 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -8,13 +8,13 @@ import 'package:pub_semver/pub_semver.dart'; import 'utils.dart'; -main() { +void main() { test('any', () { expect(VersionConstraint.any.isAny, isTrue); expect( VersionConstraint.any, - allows(new Version.parse('0.0.0-blah'), new Version.parse('1.2.3'), - new Version.parse('12345.678.90'))); + allows(Version.parse('0.0.0-blah'), Version.parse('1.2.3'), + Version.parse('12345.678.90'))); }); test('empty', () { @@ -22,141 +22,132 @@ main() { expect(VersionConstraint.empty.isAny, isFalse); expect( VersionConstraint.empty, - doesNotAllow(new Version.parse('0.0.0-blah'), - new Version.parse('1.2.3'), new Version.parse('12345.678.90'))); + doesNotAllow(Version.parse('0.0.0-blah'), Version.parse('1.2.3'), + Version.parse('12345.678.90'))); }); group('parse()', () { test('parses an exact version', () { - var constraint = new VersionConstraint.parse('1.2.3-alpha'); + var constraint = VersionConstraint.parse('1.2.3-alpha'); expect(constraint is Version, isTrue); - expect(constraint, equals(new Version(1, 2, 3, pre: 'alpha'))); + expect(constraint, equals(Version(1, 2, 3, pre: 'alpha'))); }); test('parses "any"', () { - var constraint = new VersionConstraint.parse('any'); + var constraint = VersionConstraint.parse('any'); expect(constraint is VersionConstraint, isTrue); expect( constraint, - allows(new Version.parse('0.0.0'), new Version.parse('1.2.3'), - new Version.parse('12345.678.90'))); + allows(Version.parse('0.0.0'), Version.parse('1.2.3'), + Version.parse('12345.678.90'))); }); test('parses a ">" minimum version', () { - var constraint = new VersionConstraint.parse('>1.2.3'); + var constraint = VersionConstraint.parse('>1.2.3'); expect(constraint, - allows(new Version.parse('1.2.3+foo'), new Version.parse('1.2.4'))); + allows(Version.parse('1.2.3+foo'), Version.parse('1.2.4'))); expect( constraint, - doesNotAllow(new Version.parse('1.2.1'), - new Version.parse('1.2.3-build'), new Version.parse('1.2.3'))); + doesNotAllow(Version.parse('1.2.1'), Version.parse('1.2.3-build'), + Version.parse('1.2.3'))); }); test('parses a ">=" minimum version', () { - var constraint = new VersionConstraint.parse('>=1.2.3'); + var constraint = VersionConstraint.parse('>=1.2.3'); expect( constraint, - allows(new Version.parse('1.2.3'), new Version.parse('1.2.3+foo'), - new Version.parse('1.2.4'))); - expect( - constraint, - doesNotAllow( - new Version.parse('1.2.1'), new Version.parse('1.2.3-build'))); + allows(Version.parse('1.2.3'), Version.parse('1.2.3+foo'), + Version.parse('1.2.4'))); + expect(constraint, + doesNotAllow(Version.parse('1.2.1'), Version.parse('1.2.3-build'))); }); test('parses a "<" maximum version', () { - var constraint = new VersionConstraint.parse('<1.2.3'); + var constraint = VersionConstraint.parse('<1.2.3'); expect(constraint, - allows(new Version.parse('1.2.1'), new Version.parse('1.2.2+foo'))); + allows(Version.parse('1.2.1'), Version.parse('1.2.2+foo'))); expect( constraint, - doesNotAllow(new Version.parse('1.2.3'), - new Version.parse('1.2.3+foo'), new Version.parse('1.2.4'))); + doesNotAllow(Version.parse('1.2.3'), Version.parse('1.2.3+foo'), + Version.parse('1.2.4'))); }); test('parses a "<=" maximum version', () { - var constraint = new VersionConstraint.parse('<=1.2.3'); + var constraint = VersionConstraint.parse('<=1.2.3'); expect( constraint, - allows(new Version.parse('1.2.1'), new Version.parse('1.2.3-build'), - new Version.parse('1.2.3'))); - expect( - constraint, - doesNotAllow( - new Version.parse('1.2.3+foo'), new Version.parse('1.2.4'))); + allows(Version.parse('1.2.1'), Version.parse('1.2.3-build'), + Version.parse('1.2.3'))); + expect(constraint, + doesNotAllow(Version.parse('1.2.3+foo'), Version.parse('1.2.4'))); }); test('parses a series of space-separated constraints', () { - var constraint = new VersionConstraint.parse('>1.0.0 >=1.2.3 <1.3.0'); + var constraint = VersionConstraint.parse('>1.0.0 >=1.2.3 <1.3.0'); - expect(constraint, - allows(new Version.parse('1.2.3'), new Version.parse('1.2.5'))); + expect( + constraint, allows(Version.parse('1.2.3'), Version.parse('1.2.5'))); expect( constraint, - doesNotAllow(new Version.parse('1.2.3-pre'), - new Version.parse('1.3.0'), new Version.parse('3.4.5'))); + doesNotAllow(Version.parse('1.2.3-pre'), Version.parse('1.3.0'), + Version.parse('3.4.5'))); }); test('parses a pre-release-only constraint', () { - var constraint = new VersionConstraint.parse('>=1.0.0-dev.2 <1.0.0'); - expect( - constraint, - allows(new Version.parse('1.0.0-dev.2'), - new Version.parse('1.0.0-dev.3'))); - expect( - constraint, - doesNotAllow( - new Version.parse('1.0.0-dev.1'), new Version.parse('1.0.0'))); + var constraint = VersionConstraint.parse('>=1.0.0-dev.2 <1.0.0'); + expect(constraint, + allows(Version.parse('1.0.0-dev.2'), Version.parse('1.0.0-dev.3'))); + expect(constraint, + doesNotAllow(Version.parse('1.0.0-dev.1'), Version.parse('1.0.0'))); }); test('ignores whitespace around comparison operators', () { - var constraint = new VersionConstraint.parse(' >1.0.0>=1.2.3 < 1.3.0'); + var constraint = VersionConstraint.parse(' >1.0.0>=1.2.3 < 1.3.0'); - expect(constraint, - allows(new Version.parse('1.2.3'), new Version.parse('1.2.5'))); + expect( + constraint, allows(Version.parse('1.2.3'), Version.parse('1.2.5'))); expect( constraint, - doesNotAllow(new Version.parse('1.2.3-pre'), - new Version.parse('1.3.0'), new Version.parse('3.4.5'))); + doesNotAllow(Version.parse('1.2.3-pre'), Version.parse('1.3.0'), + Version.parse('3.4.5'))); }); test('does not allow "any" to be mixed with other constraints', () { - expect(() => new VersionConstraint.parse('any 1.0.0'), - throwsFormatException); + expect(() => VersionConstraint.parse('any 1.0.0'), throwsFormatException); }); test('parses a "^" version', () { - expect(new VersionConstraint.parse('^0.0.3'), - equals(new VersionConstraint.compatibleWith(v003))); + expect(VersionConstraint.parse('^0.0.3'), + equals(VersionConstraint.compatibleWith(v003))); - expect(new VersionConstraint.parse('^0.7.2'), - equals(new VersionConstraint.compatibleWith(v072))); + expect(VersionConstraint.parse('^0.7.2'), + equals(VersionConstraint.compatibleWith(v072))); - expect(new VersionConstraint.parse('^1.2.3'), - equals(new VersionConstraint.compatibleWith(v123))); + expect(VersionConstraint.parse('^1.2.3'), + equals(VersionConstraint.compatibleWith(v123))); - var min = new Version.parse('0.7.2-pre+1'); - expect(new VersionConstraint.parse('^0.7.2-pre+1'), - equals(new VersionConstraint.compatibleWith(min))); + var min = Version.parse('0.7.2-pre+1'); + expect(VersionConstraint.parse('^0.7.2-pre+1'), + equals(VersionConstraint.compatibleWith(min))); }); test('does not allow "^" to be mixed with other constraints', () { - expect(() => new VersionConstraint.parse('>=1.2.3 ^1.0.0'), + expect(() => VersionConstraint.parse('>=1.2.3 ^1.0.0'), throwsFormatException); - expect(() => new VersionConstraint.parse('^1.0.0 <1.2.3'), + expect(() => VersionConstraint.parse('^1.0.0 <1.2.3'), throwsFormatException); }); test('ignores whitespace around "^"', () { - var constraint = new VersionConstraint.parse(' ^ 1.2.3 '); + var constraint = VersionConstraint.parse(' ^ 1.2.3 '); - expect(constraint, equals(new VersionConstraint.compatibleWith(v123))); + expect(constraint, equals(VersionConstraint.compatibleWith(v123))); }); test('throws FormatException on a bad string', () { @@ -172,23 +163,23 @@ main() { ]; for (var text in bad) { - expect(() => new VersionConstraint.parse(text), throwsFormatException); + expect(() => VersionConstraint.parse(text), throwsFormatException); } }); }); group('compatibleWith()', () { test('returns the range of compatible versions', () { - var constraint = new VersionConstraint.compatibleWith(v072); + var constraint = VersionConstraint.compatibleWith(v072); expect( constraint, - equals(new VersionRange( + equals(VersionRange( min: v072, includeMin: true, max: v072.nextBreaking))); }); test('toString() uses "^"', () { - var constraint = new VersionConstraint.compatibleWith(v072); + var constraint = VersionConstraint.compatibleWith(v072); expect(constraint.toString(), equals('^0.7.2')); }); diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index a24faaea7f..cfd66d9756 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -8,10 +8,10 @@ import 'package:pub_semver/pub_semver.dart'; import 'utils.dart'; -main() { +void main() { group('constructor', () { test('takes a min and max', () { - var range = new VersionRange(min: v123, max: v124); + var range = VersionRange(min: v123, max: v124); expect(range.isAny, isFalse); expect(range.min, equals(v123)); expect(range.max, equals(v124.firstPreRelease)); @@ -19,184 +19,175 @@ main() { group("doesn't make the max a pre-release if", () { test("it's already a pre-release", () { - expect(new VersionRange(max: new Version.parse("1.2.4-pre")).max, - equals(new Version.parse("1.2.4-pre"))); + expect(VersionRange(max: Version.parse("1.2.4-pre")).max, + equals(Version.parse("1.2.4-pre"))); }); test("includeMax is true", () { - expect(new VersionRange(max: v124, includeMax: true).max, equals(v124)); + expect(VersionRange(max: v124, includeMax: true).max, equals(v124)); }); test("min is a prerelease of max", () { - expect( - new VersionRange(min: new Version.parse("1.2.4-pre"), max: v124) - .max, + expect(VersionRange(min: Version.parse("1.2.4-pre"), max: v124).max, equals(v124)); }); test("max has a build identifier", () { - expect(new VersionRange(max: new Version.parse("1.2.4+1")).max, - equals(new Version.parse("1.2.4+1"))); + expect(VersionRange(max: Version.parse("1.2.4+1")).max, + equals(Version.parse("1.2.4+1"))); }); }); test('allows omitting max', () { - var range = new VersionRange(min: v123); + var range = VersionRange(min: v123); expect(range.isAny, isFalse); expect(range.min, equals(v123)); expect(range.max, isNull); }); test('allows omitting min and max', () { - var range = new VersionRange(); + var range = VersionRange(); expect(range.isAny, isTrue); expect(range.min, isNull); expect(range.max, isNull); }); test('takes includeMin', () { - var range = new VersionRange(min: v123, includeMin: true); + var range = VersionRange(min: v123, includeMin: true); expect(range.includeMin, isTrue); }); test('includeMin defaults to false if omitted', () { - var range = new VersionRange(min: v123); + var range = VersionRange(min: v123); expect(range.includeMin, isFalse); }); test('takes includeMax', () { - var range = new VersionRange(max: v123, includeMax: true); + var range = VersionRange(max: v123, includeMax: true); expect(range.includeMax, isTrue); }); test('includeMax defaults to false if omitted', () { - var range = new VersionRange(max: v123); + var range = VersionRange(max: v123); expect(range.includeMax, isFalse); }); test('throws if min > max', () { - expect(() => new VersionRange(min: v124, max: v123), throwsArgumentError); + expect(() => VersionRange(min: v124, max: v123), throwsArgumentError); }); }); group('allows()', () { test('version must be greater than min', () { - var range = new VersionRange(min: v123); + var range = VersionRange(min: v123); - expect(range, - allows(new Version.parse('1.3.3'), new Version.parse('2.3.3'))); - expect(range, - doesNotAllow(new Version.parse('1.2.2'), new Version.parse('1.2.3'))); + expect(range, allows(Version.parse('1.3.3'), Version.parse('2.3.3'))); + expect( + range, doesNotAllow(Version.parse('1.2.2'), Version.parse('1.2.3'))); }); test('version must be min or greater if includeMin', () { - var range = new VersionRange(min: v123, includeMin: true); + var range = VersionRange(min: v123, includeMin: true); expect( range, - allows(new Version.parse('1.2.3'), new Version.parse('1.3.3'), - new Version.parse('2.3.3'))); - expect(range, doesNotAllow(new Version.parse('1.2.2'))); + allows(Version.parse('1.2.3'), Version.parse('1.3.3'), + Version.parse('2.3.3'))); + expect(range, doesNotAllow(Version.parse('1.2.2'))); }); test('pre-release versions of inclusive min are excluded', () { - var range = new VersionRange(min: v123, includeMin: true); + var range = VersionRange(min: v123, includeMin: true); - expect(range, allows(new Version.parse('1.2.4-dev'))); - expect(range, doesNotAllow(new Version.parse('1.2.3-dev'))); + expect(range, allows(Version.parse('1.2.4-dev'))); + expect(range, doesNotAllow(Version.parse('1.2.3-dev'))); }); test('version must be less than max', () { - var range = new VersionRange(max: v234); + var range = VersionRange(max: v234); - expect(range, allows(new Version.parse('2.3.3'))); - expect(range, - doesNotAllow(new Version.parse('2.3.4'), new Version.parse('2.4.3'))); + expect(range, allows(Version.parse('2.3.3'))); + expect( + range, doesNotAllow(Version.parse('2.3.4'), Version.parse('2.4.3'))); }); test('pre-release versions of non-pre-release max are excluded', () { - var range = new VersionRange(max: v234); + var range = VersionRange(max: v234); - expect(range, allows(new Version.parse('2.3.3'))); - expect( - range, - doesNotAllow( - new Version.parse('2.3.4-dev'), new Version.parse('2.3.4'))); + expect(range, allows(Version.parse('2.3.3'))); + expect(range, + doesNotAllow(Version.parse('2.3.4-dev'), Version.parse('2.3.4'))); }); test( 'pre-release versions of non-pre-release max are included if min is a ' 'pre-release of the same version', () { - var range = - new VersionRange(min: new Version.parse('2.3.4-dev.0'), max: v234); + var range = VersionRange(min: Version.parse('2.3.4-dev.0'), max: v234); - expect(range, allows(new Version.parse('2.3.4-dev.1'))); + expect(range, allows(Version.parse('2.3.4-dev.1'))); expect( range, - doesNotAllow(new Version.parse('2.3.3'), - new Version.parse('2.3.4-dev'), new Version.parse('2.3.4'))); + doesNotAllow(Version.parse('2.3.3'), Version.parse('2.3.4-dev'), + Version.parse('2.3.4'))); }); test('pre-release versions of pre-release max are included', () { - var range = new VersionRange(max: new Version.parse('2.3.4-dev.2')); + var range = VersionRange(max: Version.parse('2.3.4-dev.2')); - expect(range, allows(new Version.parse('2.3.4-dev.1'))); + expect(range, allows(Version.parse('2.3.4-dev.1'))); expect( range, - doesNotAllow(new Version.parse('2.3.4-dev.2'), - new Version.parse('2.3.4-dev.3'))); + doesNotAllow( + Version.parse('2.3.4-dev.2'), Version.parse('2.3.4-dev.3'))); }); test('version must be max or less if includeMax', () { - var range = new VersionRange(min: v123, max: v234, includeMax: true); + var range = VersionRange(min: v123, max: v234, includeMax: true); expect( range, allows( - new Version.parse('2.3.3'), - new Version.parse('2.3.4'), + Version.parse('2.3.3'), + Version.parse('2.3.4'), // Pre-releases of the max are allowed. - new Version.parse('2.3.4-dev'))); - expect(range, doesNotAllow(new Version.parse('2.4.3'))); + Version.parse('2.3.4-dev'))); + expect(range, doesNotAllow(Version.parse('2.4.3'))); }); test('has no min if one was not set', () { - var range = new VersionRange(max: v123); + var range = VersionRange(max: v123); - expect(range, allows(new Version.parse('0.0.0'))); - expect(range, doesNotAllow(new Version.parse('1.2.3'))); + expect(range, allows(Version.parse('0.0.0'))); + expect(range, doesNotAllow(Version.parse('1.2.3'))); }); test('has no max if one was not set', () { - var range = new VersionRange(min: v123); + var range = VersionRange(min: v123); - expect(range, - allows(new Version.parse('1.3.3'), new Version.parse('999.3.3'))); - expect(range, doesNotAllow(new Version.parse('1.2.3'))); + expect(range, allows(Version.parse('1.3.3'), Version.parse('999.3.3'))); + expect(range, doesNotAllow(Version.parse('1.2.3'))); }); test('allows any version if there is no min or max', () { - var range = new VersionRange(); + var range = VersionRange(); - expect(range, - allows(new Version.parse('0.0.0'), new Version.parse('999.99.9'))); + expect(range, allows(Version.parse('0.0.0'), Version.parse('999.99.9'))); }); test('allows pre-releases of the max with includeMaxPreRelease', () { - expect(includeMaxPreReleaseRange, allows(new Version.parse('2.0.0-dev'))); + expect(includeMaxPreReleaseRange, allows(Version.parse('2.0.0-dev'))); }); }); group('allowsAll()', () { test('allows an empty constraint', () { expect( - new VersionRange(min: v123, max: v250) - .allowsAll(VersionConstraint.empty), + VersionRange(min: v123, max: v250).allowsAll(VersionConstraint.empty), isTrue); }); test('allows allowed versions', () { - var range = new VersionRange(min: v123, max: v250, includeMax: true); + var range = VersionRange(min: v123, max: v250, includeMax: true); expect(range.allowsAll(v123), isFalse); expect(range.allowsAll(v124), isTrue); expect(range.allowsAll(v250), isTrue); @@ -204,38 +195,38 @@ main() { }); test('with no min', () { - var range = new VersionRange(max: v250); - expect(range.allowsAll(new VersionRange(min: v080, max: v140)), isTrue); - expect(range.allowsAll(new VersionRange(min: v080, max: v300)), isFalse); - expect(range.allowsAll(new VersionRange(max: v140)), isTrue); - expect(range.allowsAll(new VersionRange(max: v300)), isFalse); + var range = VersionRange(max: v250); + expect(range.allowsAll(VersionRange(min: v080, max: v140)), isTrue); + expect(range.allowsAll(VersionRange(min: v080, max: v300)), isFalse); + expect(range.allowsAll(VersionRange(max: v140)), isTrue); + expect(range.allowsAll(VersionRange(max: v300)), isFalse); expect(range.allowsAll(range), isTrue); expect(range.allowsAll(VersionConstraint.any), isFalse); }); test('with no max', () { - var range = new VersionRange(min: v010); - expect(range.allowsAll(new VersionRange(min: v080, max: v140)), isTrue); - expect(range.allowsAll(new VersionRange(min: v003, max: v140)), isFalse); - expect(range.allowsAll(new VersionRange(min: v080)), isTrue); - expect(range.allowsAll(new VersionRange(min: v003)), isFalse); + var range = VersionRange(min: v010); + expect(range.allowsAll(VersionRange(min: v080, max: v140)), isTrue); + expect(range.allowsAll(VersionRange(min: v003, max: v140)), isFalse); + expect(range.allowsAll(VersionRange(min: v080)), isTrue); + expect(range.allowsAll(VersionRange(min: v003)), isFalse); expect(range.allowsAll(range), isTrue); expect(range.allowsAll(VersionConstraint.any), isFalse); }); test('with a min and max', () { - var range = new VersionRange(min: v010, max: v250); - expect(range.allowsAll(new VersionRange(min: v080, max: v140)), isTrue); - expect(range.allowsAll(new VersionRange(min: v080, max: v300)), isFalse); - expect(range.allowsAll(new VersionRange(min: v003, max: v140)), isFalse); - expect(range.allowsAll(new VersionRange(min: v080)), isFalse); - expect(range.allowsAll(new VersionRange(max: v140)), isFalse); + var range = VersionRange(min: v010, max: v250); + expect(range.allowsAll(VersionRange(min: v080, max: v140)), isTrue); + expect(range.allowsAll(VersionRange(min: v080, max: v300)), isFalse); + expect(range.allowsAll(VersionRange(min: v003, max: v140)), isFalse); + expect(range.allowsAll(VersionRange(min: v080)), isFalse); + expect(range.allowsAll(VersionRange(max: v140)), isFalse); expect(range.allowsAll(range), isTrue); }); test("allows a bordering range that's not more inclusive", () { - var exclusive = new VersionRange(min: v010, max: v250); - var inclusive = new VersionRange( + var exclusive = VersionRange(min: v010, max: v250); + var inclusive = VersionRange( min: v010, includeMin: true, max: v250, includeMax: true); expect(inclusive.allowsAll(exclusive), isTrue); expect(inclusive.allowsAll(inclusive), isTrue); @@ -244,66 +235,59 @@ main() { }); test('allows unions that are completely contained', () { - var range = new VersionRange(min: v114, max: v200); - expect( - range.allowsAll(new VersionRange(min: v123, max: v124).union(v140)), + var range = VersionRange(min: v114, max: v200); + expect(range.allowsAll(VersionRange(min: v123, max: v124).union(v140)), isTrue); - expect( - range.allowsAll(new VersionRange(min: v010, max: v124).union(v140)), + expect(range.allowsAll(VersionRange(min: v010, max: v124).union(v140)), isFalse); - expect( - range.allowsAll(new VersionRange(min: v123, max: v234).union(v140)), + expect(range.allowsAll(VersionRange(min: v123, max: v234).union(v140)), isFalse); }); group('pre-release versions', () { test('of inclusive min are excluded', () { - var range = new VersionRange(min: v123, includeMin: true); + var range = VersionRange(min: v123, includeMin: true); - expect( - range.allowsAll(new VersionConstraint.parse('>1.2.4-dev')), isTrue); - expect(range.allowsAll(new VersionConstraint.parse('>1.2.3-dev')), - isFalse); + expect(range.allowsAll(VersionConstraint.parse('>1.2.4-dev')), isTrue); + expect(range.allowsAll(VersionConstraint.parse('>1.2.3-dev')), isFalse); }); test('of non-pre-release max are excluded', () { - var range = new VersionRange(max: v234); + var range = VersionRange(max: v234); - expect(range.allowsAll(new VersionConstraint.parse('<2.3.3')), isTrue); - expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev')), - isFalse); + expect(range.allowsAll(VersionConstraint.parse('<2.3.3')), isTrue); + expect(range.allowsAll(VersionConstraint.parse('<2.3.4-dev')), isFalse); }); test('of non-pre-release max are included with includeMaxPreRelease', () { expect( includeMaxPreReleaseRange - .allowsAll(new VersionConstraint.parse('<2.0.0-dev')), + .allowsAll(VersionConstraint.parse('<2.0.0-dev')), isTrue); }); test( 'of non-pre-release max are included if min is a pre-release of the ' 'same version', () { - var range = - new VersionRange(min: new Version.parse('2.3.4-dev.0'), max: v234); + var range = VersionRange(min: Version.parse('2.3.4-dev.0'), max: v234); expect( range.allowsAll( - new VersionConstraint.parse('>2.3.4-dev.0 <2.3.4-dev.1')), + VersionConstraint.parse('>2.3.4-dev.0 <2.3.4-dev.1')), isTrue); }); test('of pre-release max are included', () { - var range = new VersionRange(max: new Version.parse('2.3.4-dev.2')); + var range = VersionRange(max: Version.parse('2.3.4-dev.2')); - expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev.1')), - isTrue); - expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev.2')), - isTrue); - expect(range.allowsAll(new VersionConstraint.parse('<=2.3.4-dev.2')), - isFalse); - expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev.3')), - isFalse); + expect( + range.allowsAll(VersionConstraint.parse('<2.3.4-dev.1')), isTrue); + expect( + range.allowsAll(VersionConstraint.parse('<2.3.4-dev.2')), isTrue); + expect( + range.allowsAll(VersionConstraint.parse('<=2.3.4-dev.2')), isFalse); + expect( + range.allowsAll(VersionConstraint.parse('<2.3.4-dev.3')), isFalse); }); }); }); @@ -311,13 +295,12 @@ main() { group('allowsAny()', () { test('disallows an empty constraint', () { expect( - new VersionRange(min: v123, max: v250) - .allowsAny(VersionConstraint.empty), + VersionRange(min: v123, max: v250).allowsAny(VersionConstraint.empty), isFalse); }); test('allows allowed versions', () { - var range = new VersionRange(min: v123, max: v250, includeMax: true); + var range = VersionRange(min: v123, max: v250, includeMax: true); expect(range.allowsAny(v123), isFalse); expect(range.allowsAny(v124), isTrue); expect(range.allowsAny(v250), isTrue); @@ -325,135 +308,127 @@ main() { }); test('with no min', () { - var range = new VersionRange(max: v200); - expect(range.allowsAny(new VersionRange(min: v140, max: v300)), isTrue); - expect(range.allowsAny(new VersionRange(min: v234, max: v300)), isFalse); - expect(range.allowsAny(new VersionRange(min: v140)), isTrue); - expect(range.allowsAny(new VersionRange(min: v234)), isFalse); + var range = VersionRange(max: v200); + expect(range.allowsAny(VersionRange(min: v140, max: v300)), isTrue); + expect(range.allowsAny(VersionRange(min: v234, max: v300)), isFalse); + expect(range.allowsAny(VersionRange(min: v140)), isTrue); + expect(range.allowsAny(VersionRange(min: v234)), isFalse); expect(range.allowsAny(range), isTrue); }); test('with no max', () { - var range = new VersionRange(min: v072); - expect(range.allowsAny(new VersionRange(min: v003, max: v140)), isTrue); - expect(range.allowsAny(new VersionRange(min: v003, max: v010)), isFalse); - expect(range.allowsAny(new VersionRange(max: v080)), isTrue); - expect(range.allowsAny(new VersionRange(max: v003)), isFalse); + var range = VersionRange(min: v072); + expect(range.allowsAny(VersionRange(min: v003, max: v140)), isTrue); + expect(range.allowsAny(VersionRange(min: v003, max: v010)), isFalse); + expect(range.allowsAny(VersionRange(max: v080)), isTrue); + expect(range.allowsAny(VersionRange(max: v003)), isFalse); expect(range.allowsAny(range), isTrue); }); test('with a min and max', () { - var range = new VersionRange(min: v072, max: v200); - expect(range.allowsAny(new VersionRange(min: v003, max: v140)), isTrue); - expect(range.allowsAny(new VersionRange(min: v140, max: v300)), isTrue); - expect(range.allowsAny(new VersionRange(min: v003, max: v010)), isFalse); - expect(range.allowsAny(new VersionRange(min: v234, max: v300)), isFalse); - expect(range.allowsAny(new VersionRange(max: v010)), isFalse); - expect(range.allowsAny(new VersionRange(min: v234)), isFalse); + var range = VersionRange(min: v072, max: v200); + expect(range.allowsAny(VersionRange(min: v003, max: v140)), isTrue); + expect(range.allowsAny(VersionRange(min: v140, max: v300)), isTrue); + expect(range.allowsAny(VersionRange(min: v003, max: v010)), isFalse); + expect(range.allowsAny(VersionRange(min: v234, max: v300)), isFalse); + expect(range.allowsAny(VersionRange(max: v010)), isFalse); + expect(range.allowsAny(VersionRange(min: v234)), isFalse); expect(range.allowsAny(range), isTrue); }); test('allows a bordering range when both are inclusive', () { - expect(new VersionRange(max: v250).allowsAny(new VersionRange(min: v250)), - isFalse); + expect( + VersionRange(max: v250).allowsAny(VersionRange(min: v250)), isFalse); expect( - new VersionRange(max: v250, includeMax: true) - .allowsAny(new VersionRange(min: v250)), + VersionRange(max: v250, includeMax: true) + .allowsAny(VersionRange(min: v250)), isFalse); expect( - new VersionRange(max: v250) - .allowsAny(new VersionRange(min: v250, includeMin: true)), + VersionRange(max: v250) + .allowsAny(VersionRange(min: v250, includeMin: true)), isFalse); expect( - new VersionRange(max: v250, includeMax: true) - .allowsAny(new VersionRange(min: v250, includeMin: true)), + VersionRange(max: v250, includeMax: true) + .allowsAny(VersionRange(min: v250, includeMin: true)), isTrue); - expect(new VersionRange(min: v250).allowsAny(new VersionRange(max: v250)), - isFalse); + expect( + VersionRange(min: v250).allowsAny(VersionRange(max: v250)), isFalse); expect( - new VersionRange(min: v250, includeMin: true) - .allowsAny(new VersionRange(max: v250)), + VersionRange(min: v250, includeMin: true) + .allowsAny(VersionRange(max: v250)), isFalse); expect( - new VersionRange(min: v250) - .allowsAny(new VersionRange(max: v250, includeMax: true)), + VersionRange(min: v250) + .allowsAny(VersionRange(max: v250, includeMax: true)), isFalse); expect( - new VersionRange(min: v250, includeMin: true) - .allowsAny(new VersionRange(max: v250, includeMax: true)), + VersionRange(min: v250, includeMin: true) + .allowsAny(VersionRange(max: v250, includeMax: true)), isTrue); }); test('allows unions that are partially contained', () { - var range = new VersionRange(min: v114, max: v200); - expect( - range.allowsAny(new VersionRange(min: v010, max: v080).union(v140)), + var range = VersionRange(min: v114, max: v200); + expect(range.allowsAny(VersionRange(min: v010, max: v080).union(v140)), isTrue); - expect( - range.allowsAny(new VersionRange(min: v123, max: v234).union(v300)), + expect(range.allowsAny(VersionRange(min: v123, max: v234).union(v300)), isTrue); - expect( - range.allowsAny(new VersionRange(min: v234, max: v300).union(v010)), + expect(range.allowsAny(VersionRange(min: v234, max: v300).union(v010)), isFalse); }); group('pre-release versions', () { test('of inclusive min are excluded', () { - var range = new VersionRange(min: v123, includeMin: true); + var range = VersionRange(min: v123, includeMin: true); - expect( - range.allowsAny(new VersionConstraint.parse('<1.2.4-dev')), isTrue); - expect(range.allowsAny(new VersionConstraint.parse('<1.2.3-dev')), - isFalse); + expect(range.allowsAny(VersionConstraint.parse('<1.2.4-dev')), isTrue); + expect(range.allowsAny(VersionConstraint.parse('<1.2.3-dev')), isFalse); }); test('of non-pre-release max are excluded', () { - var range = new VersionRange(max: v234); + var range = VersionRange(max: v234); - expect(range.allowsAny(new VersionConstraint.parse('>2.3.3')), isTrue); - expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev')), - isFalse); + expect(range.allowsAny(VersionConstraint.parse('>2.3.3')), isTrue); + expect(range.allowsAny(VersionConstraint.parse('>2.3.4-dev')), isFalse); }); test('of non-pre-release max are included with includeMaxPreRelease', () { expect( includeMaxPreReleaseRange - .allowsAny(new VersionConstraint.parse('>2.0.0-dev')), + .allowsAny(VersionConstraint.parse('>2.0.0-dev')), isTrue); }); test( 'of non-pre-release max are included if min is a pre-release of the ' 'same version', () { - var range = - new VersionRange(min: new Version.parse('2.3.4-dev.0'), max: v234); + var range = VersionRange(min: Version.parse('2.3.4-dev.0'), max: v234); - expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.1')), - isTrue); - expect(range.allowsAny(new VersionConstraint.parse('>2.3.4')), isFalse); + expect( + range.allowsAny(VersionConstraint.parse('>2.3.4-dev.1')), isTrue); + expect(range.allowsAny(VersionConstraint.parse('>2.3.4')), isFalse); - expect(range.allowsAny(new VersionConstraint.parse('<2.3.4-dev.1')), - isTrue); - expect(range.allowsAny(new VersionConstraint.parse('<2.3.4-dev')), - isFalse); + expect( + range.allowsAny(VersionConstraint.parse('<2.3.4-dev.1')), isTrue); + expect(range.allowsAny(VersionConstraint.parse('<2.3.4-dev')), isFalse); }); test('of pre-release max are included', () { - var range = new VersionConstraint.parse('<2.3.4-dev.2'); + var range = VersionConstraint.parse('<2.3.4-dev.2'); - expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.1')), - isTrue); - expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.2')), - isFalse); - expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.3')), - isFalse); + expect( + range.allowsAny(VersionConstraint.parse('>2.3.4-dev.1')), isTrue); + expect( + range.allowsAny(VersionConstraint.parse('>2.3.4-dev.2')), isFalse); + expect( + range.allowsAny(VersionConstraint.parse('>2.3.4-dev.3')), isFalse); }); }); }); @@ -461,78 +436,77 @@ main() { group('intersect()', () { test('two overlapping ranges', () { expect( - new VersionRange(min: v123, max: v250) - .intersect(new VersionRange(min: v200, max: v300)), - equals(new VersionRange(min: v200, max: v250))); + VersionRange(min: v123, max: v250) + .intersect(VersionRange(min: v200, max: v300)), + equals(VersionRange(min: v200, max: v250))); }); test('a non-overlapping range allows no versions', () { - var a = new VersionRange(min: v114, max: v124); - var b = new VersionRange(min: v200, max: v250); + var a = VersionRange(min: v114, max: v124); + var b = VersionRange(min: v200, max: v250); expect(a.intersect(b).isEmpty, isTrue); }); test('adjacent ranges allow no versions if exclusive', () { - var a = new VersionRange(min: v114, max: v124); - var b = new VersionRange(min: v124, max: v200); + var a = VersionRange(min: v114, max: v124); + var b = VersionRange(min: v124, max: v200); expect(a.intersect(b).isEmpty, isTrue); }); test('adjacent ranges allow version if inclusive', () { - var a = new VersionRange(min: v114, max: v124, includeMax: true); - var b = new VersionRange(min: v124, max: v200, includeMin: true); + var a = VersionRange(min: v114, max: v124, includeMax: true); + var b = VersionRange(min: v124, max: v200, includeMin: true); expect(a.intersect(b), equals(v124)); }); test('with an open range', () { - var open = new VersionRange(); - var a = new VersionRange(min: v114, max: v124); + var open = VersionRange(); + var a = VersionRange(min: v114, max: v124); expect(open.intersect(open), equals(open)); expect(a.intersect(open), equals(a)); }); test('returns the version if the range allows it', () { + expect(VersionRange(min: v114, max: v124).intersect(v123), equals(v123)); expect( - new VersionRange(min: v114, max: v124).intersect(v123), equals(v123)); - expect(new VersionRange(min: v123, max: v124).intersect(v114).isEmpty, - isTrue); + VersionRange(min: v123, max: v124).intersect(v114).isEmpty, isTrue); }); test("with a range with a pre-release min, returns an empty constraint", () { expect( - new VersionRange(max: v200) - .intersect(new VersionConstraint.parse(">=2.0.0-dev")), + VersionRange(max: v200) + .intersect(VersionConstraint.parse(">=2.0.0-dev")), equals(VersionConstraint.empty)); }); test("with a range with a pre-release max, returns the original", () { expect( - new VersionRange(max: v200) - .intersect(new VersionConstraint.parse("<2.0.0-dev")), - equals(new VersionRange(max: v200))); + VersionRange(max: v200) + .intersect(VersionConstraint.parse("<2.0.0-dev")), + equals(VersionRange(max: v200))); }); group("with includeMaxPreRelease", () { test('preserves includeMaxPreRelease if the max version is included', () { expect( includeMaxPreReleaseRange - .intersect(new VersionConstraint.parse("<1.0.0")), - equals(new VersionConstraint.parse("<1.0.0"))); + .intersect(VersionConstraint.parse("<1.0.0")), + equals(VersionConstraint.parse("<1.0.0"))); expect( includeMaxPreReleaseRange - .intersect(new VersionConstraint.parse("<2.0.0")), - equals(new VersionConstraint.parse("<2.0.0"))); + .intersect(VersionConstraint.parse("<2.0.0")), + equals(VersionConstraint.parse("<2.0.0"))); expect(includeMaxPreReleaseRange.intersect(includeMaxPreReleaseRange), equals(includeMaxPreReleaseRange)); expect( includeMaxPreReleaseRange - .intersect(new VersionConstraint.parse("<3.0.0")), + .intersect(VersionConstraint.parse("<3.0.0")), equals(includeMaxPreReleaseRange)); expect( includeMaxPreReleaseRange - .intersect(new VersionConstraint.parse(">1.1.4")), - equals(new VersionRange( + .intersect(VersionConstraint.parse(">1.1.4")), + equals(VersionRange( min: v114, max: v200, alwaysIncludeMaxPreRelease: true))); }); @@ -541,8 +515,8 @@ main() { "an intersection", () { expect( includeMaxPreReleaseRange - .intersect(new VersionConstraint.parse(">=2.0.0-dev")), - equals(new VersionConstraint.parse(">=2.0.0-dev <2.0.0"))); + .intersect(VersionConstraint.parse(">=2.0.0-dev")), + equals(VersionConstraint.parse(">=2.0.0-dev <2.0.0"))); }); test( @@ -550,142 +524,136 @@ main() { "the narrower constraint", () { expect( includeMaxPreReleaseRange - .intersect(new VersionConstraint.parse("<2.0.0-dev")), - equals(new VersionConstraint.parse("<2.0.0-dev"))); + .intersect(VersionConstraint.parse("<2.0.0-dev")), + equals(VersionConstraint.parse("<2.0.0-dev"))); }); }); }); group('union()', () { test("with a version returns the range if it contains the version", () { - var range = new VersionRange(min: v114, max: v124); + var range = VersionRange(min: v114, max: v124); expect(range.union(v123), equals(range)); }); test("with a version on the edge of the range, expands the range", () { expect( - new VersionRange( - min: v114, max: v124, alwaysIncludeMaxPreRelease: true) + VersionRange(min: v114, max: v124, alwaysIncludeMaxPreRelease: true) .union(v124), - equals(new VersionRange(min: v114, max: v124, includeMax: true))); - expect(new VersionRange(min: v114, max: v124).union(v114), - equals(new VersionRange(min: v114, max: v124, includeMin: true))); + equals(VersionRange(min: v114, max: v124, includeMax: true))); + expect(VersionRange(min: v114, max: v124).union(v114), + equals(VersionRange(min: v114, max: v124, includeMin: true))); }); test( "with a version allows both the range and the version if the range " "doesn't contain the version", () { - var result = new VersionRange(min: v003, max: v114).union(v124); + var result = VersionRange(min: v003, max: v114).union(v124); expect(result, allows(v010)); expect(result, doesNotAllow(v123)); expect(result, allows(v124)); }); test("returns a VersionUnion for a disjoint range", () { - var result = new VersionRange(min: v003, max: v114) - .union(new VersionRange(min: v130, max: v200)); + var result = VersionRange(min: v003, max: v114) + .union(VersionRange(min: v130, max: v200)); expect(result, allows(v080)); expect(result, doesNotAllow(v123)); expect(result, allows(v140)); }); test("considers open ranges disjoint", () { - var result = new VersionRange(min: v003, max: v114) - .union(new VersionRange(min: v114, max: v200)); + var result = VersionRange(min: v003, max: v114) + .union(VersionRange(min: v114, max: v200)); expect(result, allows(v080)); expect(result, doesNotAllow(v114)); expect(result, allows(v140)); - result = new VersionRange(min: v114, max: v200) - .union(new VersionRange(min: v003, max: v114)); + result = VersionRange(min: v114, max: v200) + .union(VersionRange(min: v003, max: v114)); expect(result, allows(v080)); expect(result, doesNotAllow(v114)); expect(result, allows(v140)); }); test("returns a merged range for an overlapping range", () { - var result = new VersionRange(min: v003, max: v114) - .union(new VersionRange(min: v080, max: v200)); - expect(result, equals(new VersionRange(min: v003, max: v200))); + var result = VersionRange(min: v003, max: v114) + .union(VersionRange(min: v080, max: v200)); + expect(result, equals(VersionRange(min: v003, max: v200))); }); test("considers closed ranges overlapping", () { - var result = new VersionRange(min: v003, max: v114, includeMax: true) - .union(new VersionRange(min: v114, max: v200)); - expect(result, equals(new VersionRange(min: v003, max: v200))); + var result = VersionRange(min: v003, max: v114, includeMax: true) + .union(VersionRange(min: v114, max: v200)); + expect(result, equals(VersionRange(min: v003, max: v200))); - result = new VersionRange( - min: v003, max: v114, alwaysIncludeMaxPreRelease: true) - .union(new VersionRange(min: v114, max: v200, includeMin: true)); - expect(result, equals(new VersionRange(min: v003, max: v200))); + result = + VersionRange(min: v003, max: v114, alwaysIncludeMaxPreRelease: true) + .union(VersionRange(min: v114, max: v200, includeMin: true)); + expect(result, equals(VersionRange(min: v003, max: v200))); - result = new VersionRange(min: v114, max: v200) - .union(new VersionRange(min: v003, max: v114, includeMax: true)); - expect(result, equals(new VersionRange(min: v003, max: v200))); + result = VersionRange(min: v114, max: v200) + .union(VersionRange(min: v003, max: v114, includeMax: true)); + expect(result, equals(VersionRange(min: v003, max: v200))); - result = new VersionRange(min: v114, max: v200, includeMin: true).union( - new VersionRange( - min: v003, max: v114, alwaysIncludeMaxPreRelease: true)); - expect(result, equals(new VersionRange(min: v003, max: v200))); + result = VersionRange(min: v114, max: v200, includeMin: true).union( + VersionRange(min: v003, max: v114, alwaysIncludeMaxPreRelease: true)); + expect(result, equals(VersionRange(min: v003, max: v200))); }); test("includes edges if either range does", () { - var result = new VersionRange(min: v003, max: v114, includeMin: true) - .union(new VersionRange(min: v003, max: v114, includeMax: true)); + var result = VersionRange(min: v003, max: v114, includeMin: true) + .union(VersionRange(min: v003, max: v114, includeMax: true)); expect( result, - equals(new VersionRange( + equals(VersionRange( min: v003, max: v114, includeMin: true, includeMax: true))); }); test("with a range with a pre-release min, returns a constraint with a gap", () { - var result = new VersionRange(max: v200) - .union(new VersionConstraint.parse(">=2.0.0-dev")); + var result = + VersionRange(max: v200).union(VersionConstraint.parse(">=2.0.0-dev")); expect(result, allows(v140)); - expect(result, doesNotAllow(new Version.parse("2.0.0-alpha"))); - expect(result, allows(new Version.parse("2.0.0-dev"))); - expect(result, allows(new Version.parse("2.0.0-dev.1"))); - expect(result, allows(new Version.parse("2.0.0"))); + expect(result, doesNotAllow(Version.parse("2.0.0-alpha"))); + expect(result, allows(Version.parse("2.0.0-dev"))); + expect(result, allows(Version.parse("2.0.0-dev.1"))); + expect(result, allows(Version.parse("2.0.0"))); }); test("with a range with a pre-release max, returns the larger constraint", () { expect( - new VersionRange(max: v200) - .union(new VersionConstraint.parse("<2.0.0-dev")), - equals(new VersionConstraint.parse("<2.0.0-dev"))); + VersionRange(max: v200).union(VersionConstraint.parse("<2.0.0-dev")), + equals(VersionConstraint.parse("<2.0.0-dev"))); }); group("with includeMaxPreRelease", () { test('adds includeMaxPreRelease if the max version is included', () { expect( - includeMaxPreReleaseRange - .union(new VersionConstraint.parse("<1.0.0")), + includeMaxPreReleaseRange.union(VersionConstraint.parse("<1.0.0")), equals(includeMaxPreReleaseRange)); expect(includeMaxPreReleaseRange.union(includeMaxPreReleaseRange), equals(includeMaxPreReleaseRange)); expect( - includeMaxPreReleaseRange - .union(new VersionConstraint.parse("<2.0.0")), + includeMaxPreReleaseRange.union(VersionConstraint.parse("<2.0.0")), equals(includeMaxPreReleaseRange)); expect( - includeMaxPreReleaseRange - .union(new VersionConstraint.parse("<3.0.0")), - equals(new VersionConstraint.parse("<3.0.0"))); + includeMaxPreReleaseRange.union(VersionConstraint.parse("<3.0.0")), + equals(VersionConstraint.parse("<3.0.0"))); }); test("and a range with a pre-release min, returns any", () { expect( includeMaxPreReleaseRange - .union(new VersionConstraint.parse(">=2.0.0-dev")), + .union(VersionConstraint.parse(">=2.0.0-dev")), equals(VersionConstraint.any)); }); test("and a range with a pre-release max, returns the original", () { expect( includeMaxPreReleaseRange - .union(new VersionConstraint.parse("<2.0.0-dev")), + .union(VersionConstraint.parse("<2.0.0-dev")), equals(includeMaxPreReleaseRange)); }); }); @@ -694,127 +662,124 @@ main() { group('difference()', () { test("with an empty range returns the original range", () { expect( - new VersionRange(min: v003, max: v114) + VersionRange(min: v003, max: v114) .difference(VersionConstraint.empty), - equals(new VersionRange(min: v003, max: v114))); + equals(VersionRange(min: v003, max: v114))); }); test("with a version outside the range returns the original range", () { - expect(new VersionRange(min: v003, max: v114).difference(v200), - equals(new VersionRange(min: v003, max: v114))); + expect(VersionRange(min: v003, max: v114).difference(v200), + equals(VersionRange(min: v003, max: v114))); }); test("with a version in the range splits the range", () { expect( - new VersionRange(min: v003, max: v114).difference(v072), - equals(new VersionConstraint.unionOf([ - new VersionRange( + VersionRange(min: v003, max: v114).difference(v072), + equals(VersionConstraint.unionOf([ + VersionRange( min: v003, max: v072, alwaysIncludeMaxPreRelease: true), - new VersionRange(min: v072, max: v114) + VersionRange(min: v072, max: v114) ]))); }); test("with the max version makes the max exclusive", () { expect( - new VersionRange(min: v003, max: v114, includeMax: true) - .difference(v114), - equals(new VersionRange( + VersionRange(min: v003, max: v114, includeMax: true).difference(v114), + equals(VersionRange( min: v003, max: v114, alwaysIncludeMaxPreRelease: true))); }); test("with the min version makes the min exclusive", () { expect( - new VersionRange(min: v003, max: v114, includeMin: true) - .difference(v003), - equals(new VersionRange(min: v003, max: v114))); + VersionRange(min: v003, max: v114, includeMin: true).difference(v003), + equals(VersionRange(min: v003, max: v114))); }); test("with a disjoint range returns the original", () { expect( - new VersionRange(min: v003, max: v114) - .difference(new VersionRange(min: v123, max: v140)), - equals(new VersionRange(min: v003, max: v114))); + VersionRange(min: v003, max: v114) + .difference(VersionRange(min: v123, max: v140)), + equals(VersionRange(min: v003, max: v114))); }); test("with an adjacent range returns the original", () { expect( - new VersionRange(min: v003, max: v114, includeMax: true) - .difference(new VersionRange(min: v114, max: v140)), - equals(new VersionRange(min: v003, max: v114, includeMax: true))); + VersionRange(min: v003, max: v114, includeMax: true) + .difference(VersionRange(min: v114, max: v140)), + equals(VersionRange(min: v003, max: v114, includeMax: true))); }); test("with a range at the beginning cuts off the beginning of the range", () { expect( - new VersionRange(min: v080, max: v130) - .difference(new VersionRange(min: v010, max: v114)), - equals(new VersionConstraint.parse(">=1.1.4-0 <1.3.0"))); + VersionRange(min: v080, max: v130) + .difference(VersionRange(min: v010, max: v114)), + equals(VersionConstraint.parse(">=1.1.4-0 <1.3.0"))); expect( - new VersionRange(min: v080, max: v130) - .difference(new VersionRange(max: v114)), - equals(new VersionConstraint.parse(">=1.1.4-0 <1.3.0"))); + VersionRange(min: v080, max: v130) + .difference(VersionRange(max: v114)), + equals(VersionConstraint.parse(">=1.1.4-0 <1.3.0"))); expect( - new VersionRange(min: v080, max: v130).difference( - new VersionRange(min: v010, max: v114, includeMax: true)), - equals(new VersionRange(min: v114, max: v130))); + VersionRange(min: v080, max: v130) + .difference(VersionRange(min: v010, max: v114, includeMax: true)), + equals(VersionRange(min: v114, max: v130))); expect( - new VersionRange(min: v080, max: v130, includeMin: true).difference( - new VersionRange(min: v010, max: v080, includeMax: true)), - equals(new VersionRange(min: v080, max: v130))); + VersionRange(min: v080, max: v130, includeMin: true) + .difference(VersionRange(min: v010, max: v080, includeMax: true)), + equals(VersionRange(min: v080, max: v130))); expect( - new VersionRange(min: v080, max: v130, includeMax: true) - .difference(new VersionRange(min: v080, max: v130)), - equals(new VersionConstraint.parse(">=1.3.0-0 <=1.3.0"))); + VersionRange(min: v080, max: v130, includeMax: true) + .difference(VersionRange(min: v080, max: v130)), + equals(VersionConstraint.parse(">=1.3.0-0 <=1.3.0"))); }); test("with a range at the end cuts off the end of the range", () { expect( - new VersionRange(min: v080, max: v130) - .difference(new VersionRange(min: v114, max: v140)), - equals(new VersionRange(min: v080, max: v114, includeMax: true))); + VersionRange(min: v080, max: v130) + .difference(VersionRange(min: v114, max: v140)), + equals(VersionRange(min: v080, max: v114, includeMax: true))); expect( - new VersionRange(min: v080, max: v130) - .difference(new VersionRange(min: v114)), - equals(new VersionRange(min: v080, max: v114, includeMax: true))); + VersionRange(min: v080, max: v130) + .difference(VersionRange(min: v114)), + equals(VersionRange(min: v080, max: v114, includeMax: true))); expect( - new VersionRange(min: v080, max: v130).difference( - new VersionRange(min: v114, max: v140, includeMin: true)), - equals(new VersionRange( + VersionRange(min: v080, max: v130) + .difference(VersionRange(min: v114, max: v140, includeMin: true)), + equals(VersionRange( min: v080, max: v114, alwaysIncludeMaxPreRelease: true))); expect( - new VersionRange(min: v080, max: v130, includeMax: true).difference( - new VersionRange(min: v130, max: v140, includeMin: true)), - equals(new VersionRange( + VersionRange(min: v080, max: v130, includeMax: true) + .difference(VersionRange(min: v130, max: v140, includeMin: true)), + equals(VersionRange( min: v080, max: v130, alwaysIncludeMaxPreRelease: true))); expect( - new VersionRange(min: v080, max: v130, includeMin: true) - .difference(new VersionRange(min: v080, max: v130)), + VersionRange(min: v080, max: v130, includeMin: true) + .difference(VersionRange(min: v080, max: v130)), equals(v080)); }); test("with a range in the middle cuts the range in half", () { expect( - new VersionRange(min: v003, max: v130) - .difference(new VersionRange(min: v072, max: v114)), - equals(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072, includeMax: true), - new VersionConstraint.parse(">=1.1.4-0 <1.3.0") + VersionRange(min: v003, max: v130) + .difference(VersionRange(min: v072, max: v114)), + equals(VersionConstraint.unionOf([ + VersionRange(min: v003, max: v072, includeMax: true), + VersionConstraint.parse(">=1.1.4-0 <1.3.0") ]))); }); test("with a totally covering range returns empty", () { expect( - new VersionRange(min: v114, max: v200) - .difference(new VersionRange(min: v072, max: v300)), + VersionRange(min: v114, max: v200) + .difference(VersionRange(min: v072, max: v300)), isEmpty); expect( - new VersionRange(min: v003, max: v114) - .difference(new VersionRange(min: v003, max: v114)), + VersionRange(min: v003, max: v114) + .difference(VersionRange(min: v003, max: v114)), isEmpty); expect( - new VersionRange( - min: v003, max: v114, includeMin: true, includeMax: true) - .difference(new VersionRange( + VersionRange(min: v003, max: v114, includeMin: true, includeMax: true) + .difference(VersionRange( min: v003, max: v114, includeMin: true, includeMax: true)), isEmpty); }); @@ -823,55 +788,54 @@ main() { "with a version union that doesn't cover the range, returns the " "original", () { expect( - new VersionRange(min: v114, max: v140) - .difference(new VersionConstraint.unionOf([v010, v200])), - equals(new VersionRange(min: v114, max: v140))); + VersionRange(min: v114, max: v140) + .difference(VersionConstraint.unionOf([v010, v200])), + equals(VersionRange(min: v114, max: v140))); }); test("with a version union that intersects the ends, chops them off", () { expect( - new VersionRange(min: v114, max: v140).difference( - new VersionConstraint.unionOf([ - new VersionRange(min: v080, max: v123), - new VersionRange(min: v130, max: v200) + VersionRange(min: v114, max: v140).difference( + VersionConstraint.unionOf([ + VersionRange(min: v080, max: v123), + VersionRange(min: v130, max: v200) ])), - equals(new VersionConstraint.parse(">=1.2.3-0 <=1.3.0"))); + equals(VersionConstraint.parse(">=1.2.3-0 <=1.3.0"))); }); test("with a version union that intersects the middle, chops it up", () { expect( - new VersionRange(min: v114, max: v140) - .difference(new VersionConstraint.unionOf([v123, v124, v130])), - equals(new VersionConstraint.unionOf([ - new VersionRange( + VersionRange(min: v114, max: v140) + .difference(VersionConstraint.unionOf([v123, v124, v130])), + equals(VersionConstraint.unionOf([ + VersionRange( min: v114, max: v123, alwaysIncludeMaxPreRelease: true), - new VersionRange( + VersionRange( min: v123, max: v124, alwaysIncludeMaxPreRelease: true), - new VersionRange( + VersionRange( min: v124, max: v130, alwaysIncludeMaxPreRelease: true), - new VersionRange(min: v130, max: v140) + VersionRange(min: v130, max: v140) ]))); }); test("with a version union that covers the whole range, returns empty", () { expect( - new VersionRange(min: v114, max: v140).difference( - new VersionConstraint.unionOf( - [v003, new VersionRange(min: v010)])), + VersionRange(min: v114, max: v140).difference( + VersionConstraint.unionOf([v003, VersionRange(min: v010)])), equals(VersionConstraint.empty)); }); test("with a range with a pre-release min, returns the original", () { expect( - new VersionRange(max: v200) - .difference(new VersionConstraint.parse(">=2.0.0-dev")), - equals(new VersionRange(max: v200))); + VersionRange(max: v200) + .difference(VersionConstraint.parse(">=2.0.0-dev")), + equals(VersionRange(max: v200))); }); test("with a range with a pre-release max, returns null", () { expect( - new VersionRange(max: v200) - .difference(new VersionConstraint.parse("<2.0.0-dev")), + VersionRange(max: v200) + .difference(VersionConstraint.parse("<2.0.0-dev")), equals(VersionConstraint.empty)); }); @@ -881,16 +845,16 @@ main() { () { expect( includeMaxPreReleaseRange - .difference(new VersionConstraint.parse("<1.0.0")), - equals(new VersionRange( - min: new Version.parse("1.0.0-0"), + .difference(VersionConstraint.parse("<1.0.0")), + equals(VersionRange( + min: Version.parse("1.0.0-0"), max: v200, includeMin: true, alwaysIncludeMaxPreRelease: true))); expect( includeMaxPreReleaseRange - .difference(new VersionConstraint.parse("<2.0.0")), - equals(new VersionRange( + .difference(VersionConstraint.parse("<2.0.0")), + equals(VersionRange( min: v200.firstPreRelease, max: v200, includeMin: true, @@ -900,22 +864,22 @@ main() { equals(VersionConstraint.empty)); expect( includeMaxPreReleaseRange - .difference(new VersionConstraint.parse("<3.0.0")), + .difference(VersionConstraint.parse("<3.0.0")), equals(VersionConstraint.empty)); }); test("with a range with a pre-release min, adjusts the max", () { expect( includeMaxPreReleaseRange - .difference(new VersionConstraint.parse(">=2.0.0-dev")), - equals(new VersionConstraint.parse("<2.0.0-dev"))); + .difference(VersionConstraint.parse(">=2.0.0-dev")), + equals(VersionConstraint.parse("<2.0.0-dev"))); }); test("with a range with a pre-release max, adjusts the min", () { expect( includeMaxPreReleaseRange - .difference(new VersionConstraint.parse("<2.0.0-dev")), - equals(new VersionConstraint.parse(">=2.0.0-dev <2.0.0"))); + .difference(VersionConstraint.parse("<2.0.0-dev")), + equals(VersionConstraint.parse(">=2.0.0-dev <2.0.0"))); }); }); @@ -923,29 +887,27 @@ main() { group("doesn't create a pre-release minimum", () { test("when cutting off the bottom", () { expect( - new VersionConstraint.parse("<3.0.0") + VersionConstraint.parse("<3.0.0") .difference(includeMaxPreReleaseRange), - equals( - new VersionRange(min: v200, max: v300, includeMin: true))); + equals(VersionRange(min: v200, max: v300, includeMin: true))); }); test("with splitting down the middle", () { expect( - new VersionConstraint.parse("<4.0.0").difference( - new VersionRange( - min: v200, - max: v300, - includeMin: true, - alwaysIncludeMaxPreRelease: true)), - equals(new VersionConstraint.unionOf([ - new VersionRange(max: v200, alwaysIncludeMaxPreRelease: true), - new VersionConstraint.parse(">=3.0.0 <4.0.0") + VersionConstraint.parse("<4.0.0").difference(VersionRange( + min: v200, + max: v300, + includeMin: true, + alwaysIncludeMaxPreRelease: true)), + equals(VersionConstraint.unionOf([ + VersionRange(max: v200, alwaysIncludeMaxPreRelease: true), + VersionConstraint.parse(">=3.0.0 <4.0.0") ]))); }); test("can leave a single version", () { expect( - new VersionConstraint.parse("<=2.0.0") + VersionConstraint.parse("<=2.0.0") .difference(includeMaxPreReleaseRange), equals(v200)); }); @@ -955,54 +917,54 @@ main() { }); test('isEmpty', () { - expect(new VersionRange().isEmpty, isFalse); - expect(new VersionRange(min: v123, max: v124).isEmpty, isFalse); + expect(VersionRange().isEmpty, isFalse); + expect(VersionRange(min: v123, max: v124).isEmpty, isFalse); }); group('compareTo()', () { test("orders by minimum first", () { - _expectComparesSmaller(new VersionRange(min: v003, max: v080), - new VersionRange(min: v010, max: v072)); - _expectComparesSmaller(new VersionRange(min: v003, max: v080), - new VersionRange(min: v010, max: v080)); - _expectComparesSmaller(new VersionRange(min: v003, max: v080), - new VersionRange(min: v010, max: v114)); + _expectComparesSmaller(VersionRange(min: v003, max: v080), + VersionRange(min: v010, max: v072)); + _expectComparesSmaller(VersionRange(min: v003, max: v080), + VersionRange(min: v010, max: v080)); + _expectComparesSmaller(VersionRange(min: v003, max: v080), + VersionRange(min: v010, max: v114)); }); test("orders by maximum second", () { - _expectComparesSmaller(new VersionRange(min: v003, max: v010), - new VersionRange(min: v003, max: v072)); + _expectComparesSmaller(VersionRange(min: v003, max: v010), + VersionRange(min: v003, max: v072)); }); test("includeMin comes before !includeMin", () { _expectComparesSmaller( - new VersionRange(min: v003, max: v080, includeMin: true), - new VersionRange(min: v003, max: v080, includeMin: false)); + VersionRange(min: v003, max: v080, includeMin: true), + VersionRange(min: v003, max: v080, includeMin: false)); }); test("includeMax comes after !includeMax", () { _expectComparesSmaller( - new VersionRange(min: v003, max: v080, includeMax: false), - new VersionRange(min: v003, max: v080, includeMax: true)); + VersionRange(min: v003, max: v080, includeMax: false), + VersionRange(min: v003, max: v080, includeMax: true)); }); test("includeMaxPreRelease comes after !includeMaxPreRelease", () { _expectComparesSmaller( - new VersionRange(max: v200), includeMaxPreReleaseRange); + VersionRange(max: v200), includeMaxPreReleaseRange); }); test("no minimum comes before small minimum", () { _expectComparesSmaller( - new VersionRange(max: v010), new VersionRange(min: v003, max: v010)); - _expectComparesSmaller(new VersionRange(max: v010, includeMin: true), - new VersionRange(min: v003, max: v010)); + VersionRange(max: v010), VersionRange(min: v003, max: v010)); + _expectComparesSmaller(VersionRange(max: v010, includeMin: true), + VersionRange(min: v003, max: v010)); }); test("no maximium comes after large maximum", () { _expectComparesSmaller( - new VersionRange(min: v003, max: v300), new VersionRange(min: v003)); - _expectComparesSmaller(new VersionRange(min: v003, max: v300), - new VersionRange(min: v003, includeMax: true)); + VersionRange(min: v003, max: v300), VersionRange(min: v003)); + _expectComparesSmaller(VersionRange(min: v003, max: v300), + VersionRange(min: v003, includeMax: true)); }); }); } diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index 448435a577..634148bccf 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -8,7 +8,7 @@ import 'package:pub_semver/pub_semver.dart'; import 'utils.dart'; -main() { +void main() { test('none', () { expect(Version.none.toString(), equals('0.0.0')); }); @@ -29,8 +29,8 @@ main() { // appears in the list. for (var i = 0; i < versions.length; i++) { for (var j = 0; j < versions.length; j++) { - var a = new Version.parse(versions[i]); - var b = new Version.parse(versions[j]); + var a = Version.parse(versions[i]); + var b = Version.parse(versions[j]); expect(Version.prioritize(a, b), equals(i.compareTo(j))); } } @@ -52,8 +52,8 @@ main() { // appears in the list. for (var i = 0; i < versions.length; i++) { for (var j = 0; j < versions.length; j++) { - var a = new Version.parse(versions[i]); - var b = new Version.parse(versions[j]); + var a = Version.parse(versions[i]); + var b = Version.parse(versions[j]); expect(Version.antiprioritize(a, b), equals(i.compareTo(j))); } } @@ -61,9 +61,9 @@ main() { group('constructor', () { test('throws on negative numbers', () { - expect(() => new Version(-1, 1, 1), throwsArgumentError); - expect(() => new Version(1, -1, 1), throwsArgumentError); - expect(() => new Version(1, 1, -1), throwsArgumentError); + expect(() => Version(-1, 1, 1), throwsArgumentError); + expect(() => Version(1, -1, 1), throwsArgumentError); + expect(() => Version(1, 1, -1), throwsArgumentError); }); }); @@ -93,8 +93,8 @@ main() { // appears in the list. for (var i = 0; i < versions.length; i++) { for (var j = 0; j < versions.length; j++) { - var a = new Version.parse(versions[i]); - var b = new Version.parse(versions[j]); + var a = Version.parse(versions[i]); + var b = Version.parse(versions[j]); expect(a.compareTo(b), equals(i.compareTo(j))); } } @@ -103,8 +103,8 @@ main() { test('operators', () { for (var i = 0; i < versions.length; i++) { for (var j = 0; j < versions.length; j++) { - var a = new Version.parse(versions[i]); - var b = new Version.parse(versions[j]); + var a = Version.parse(versions[i]); + var b = Version.parse(versions[j]); expect(a < b, equals(i < j)); expect(a > b, equals(i > j)); expect(a <= b, equals(i <= j)); @@ -116,13 +116,11 @@ main() { }); test('equality', () { - expect(new Version.parse('01.2.3'), equals(new Version.parse('1.2.3'))); - expect(new Version.parse('1.02.3'), equals(new Version.parse('1.2.3'))); - expect(new Version.parse('1.2.03'), equals(new Version.parse('1.2.3'))); - expect( - new Version.parse('1.2.3-01'), equals(new Version.parse('1.2.3-1'))); - expect( - new Version.parse('1.2.3+01'), equals(new Version.parse('1.2.3+1'))); + expect(Version.parse('01.2.3'), equals(Version.parse('1.2.3'))); + expect(Version.parse('1.02.3'), equals(Version.parse('1.2.3'))); + expect(Version.parse('1.2.03'), equals(Version.parse('1.2.3'))); + expect(Version.parse('1.2.3-01'), equals(Version.parse('1.2.3-1'))); + expect(Version.parse('1.2.3+01'), equals(Version.parse('1.2.3+1'))); }); }); @@ -131,17 +129,17 @@ main() { expect( v123, doesNotAllow( - new Version.parse('2.2.3'), - new Version.parse('1.3.3'), - new Version.parse('1.2.4'), - new Version.parse('1.2.3-dev'), - new Version.parse('1.2.3+build'))); + Version.parse('2.2.3'), + Version.parse('1.3.3'), + Version.parse('1.2.4'), + Version.parse('1.2.3-dev'), + Version.parse('1.2.3+build'))); }); test('allowsAll()', () { expect(v123.allowsAll(v123), isTrue); expect(v123.allowsAll(v003), isFalse); - expect(v123.allowsAll(new VersionRange(min: v114, max: v124)), isFalse); + expect(v123.allowsAll(VersionRange(min: v114, max: v124)), isFalse); expect(v123.allowsAll(VersionConstraint.any), isFalse); expect(v123.allowsAll(VersionConstraint.empty), isTrue); }); @@ -149,7 +147,7 @@ main() { test('allowsAny()', () { expect(v123.allowsAny(v123), isTrue); expect(v123.allowsAny(v003), isFalse); - expect(v123.allowsAny(new VersionRange(min: v114, max: v124)), isTrue); + expect(v123.allowsAny(VersionRange(min: v114, max: v124)), isTrue); expect(v123.allowsAny(VersionConstraint.any), isTrue); expect(v123.allowsAny(VersionConstraint.empty), isFalse); }); @@ -162,12 +160,10 @@ main() { expect(v123.intersect(v114).isEmpty, isTrue); // Intersecting a range returns the version if the range allows it. - expect( - v123.intersect(new VersionRange(min: v114, max: v124)), equals(v123)); + expect(v123.intersect(VersionRange(min: v114, max: v124)), equals(v123)); // Intersecting a range allows no versions if the range doesn't allow it. - expect( - v114.intersect(new VersionRange(min: v123, max: v124)).isEmpty, isTrue); + expect(v114.intersect(VersionRange(min: v123, max: v124)).isEmpty, isTrue); }); group('union()', () { @@ -185,27 +181,27 @@ main() { }); test("with a range returns the range if it contains the version", () { - var range = new VersionRange(min: v114, max: v124); + var range = VersionRange(min: v114, max: v124); expect(v123.union(range), equals(range)); }); test("with a range with the version on the edge, expands the range", () { expect( - v124.union(new VersionRange( + v124.union(VersionRange( min: v114, max: v124, alwaysIncludeMaxPreRelease: true)), - equals(new VersionRange(min: v114, max: v124, includeMax: true))); + equals(VersionRange(min: v114, max: v124, includeMax: true))); expect( - v124.firstPreRelease.union(new VersionRange(min: v114, max: v124)), - equals(new VersionRange( + v124.firstPreRelease.union(VersionRange(min: v114, max: v124)), + equals(VersionRange( min: v114, max: v124.firstPreRelease, includeMax: true))); - expect(v114.union(new VersionRange(min: v114, max: v124)), - equals(new VersionRange(min: v114, max: v124, includeMin: true))); + expect(v114.union(VersionRange(min: v114, max: v124)), + equals(VersionRange(min: v114, max: v124, includeMin: true))); }); test( "with a range allows both the range and the version if the range " "doesn't contain the version", () { - var result = v123.union(new VersionRange(min: v003, max: v114)); + var result = v123.union(VersionRange(min: v003, max: v114)); expect(result, allows(v123)); expect(result, allows(v010)); }); @@ -222,13 +218,12 @@ main() { test("returns an empty constraint with a range that contains the version", () { - expect(v123.difference(new VersionRange(min: v114, max: v124)), isEmpty); + expect(v123.difference(VersionRange(min: v114, max: v124)), isEmpty); }); test("returns the version constraint with a range that doesn't contain it", () { - expect(v123.difference(new VersionRange(min: v140, max: v300)), - equals(v123)); + expect(v123.difference(VersionRange(min: v140, max: v300)), equals(v123)); }); }); @@ -242,13 +237,13 @@ main() { expect(v200.nextMajor, equals(v300)); // Ignores pre-release if not on a major version. - expect(new Version.parse('1.2.3-dev').nextMajor, equals(v200)); + expect(Version.parse('1.2.3-dev').nextMajor, equals(v200)); // Just removes it if on a major version. - expect(new Version.parse('2.0.0-dev').nextMajor, equals(v200)); + expect(Version.parse('2.0.0-dev').nextMajor, equals(v200)); // Strips build suffix. - expect(new Version.parse('1.2.3+patch').nextMajor, equals(v200)); + expect(Version.parse('1.2.3+patch').nextMajor, equals(v200)); }); test('nextMinor', () { @@ -256,13 +251,13 @@ main() { expect(v130.nextMinor, equals(v140)); // Ignores pre-release if not on a minor version. - expect(new Version.parse('1.2.3-dev').nextMinor, equals(v130)); + expect(Version.parse('1.2.3-dev').nextMinor, equals(v130)); // Just removes it if on a minor version. - expect(new Version.parse('1.3.0-dev').nextMinor, equals(v130)); + expect(Version.parse('1.3.0-dev').nextMinor, equals(v130)); // Strips build suffix. - expect(new Version.parse('1.2.3+patch').nextMinor, equals(v130)); + expect(Version.parse('1.2.3+patch').nextMinor, equals(v130)); }); test('nextPatch', () { @@ -270,10 +265,10 @@ main() { expect(v200.nextPatch, equals(v201)); // Just removes pre-release version if present. - expect(new Version.parse('1.2.4-dev').nextPatch, equals(v124)); + expect(Version.parse('1.2.4-dev').nextPatch, equals(v124)); // Strips build suffix. - expect(new Version.parse('1.2.3+patch').nextPatch, equals(v124)); + expect(Version.parse('1.2.3+patch').nextPatch, equals(v124)); }); test('nextBreaking', () { @@ -282,56 +277,56 @@ main() { expect(v003.nextBreaking, equals(v010)); // Removes pre-release version if present. - expect(new Version.parse('1.2.3-dev').nextBreaking, equals(v200)); + expect(Version.parse('1.2.3-dev').nextBreaking, equals(v200)); // Strips build suffix. - expect(new Version.parse('1.2.3+patch').nextBreaking, equals(v200)); + expect(Version.parse('1.2.3+patch').nextBreaking, equals(v200)); }); test('parse()', () { - expect(new Version.parse('0.0.0'), equals(new Version(0, 0, 0))); - expect(new Version.parse('12.34.56'), equals(new Version(12, 34, 56))); - - expect(new Version.parse('1.2.3-alpha.1'), - equals(new Version(1, 2, 3, pre: 'alpha.1'))); - expect(new Version.parse('1.2.3-x.7.z-92'), - equals(new Version(1, 2, 3, pre: 'x.7.z-92'))); - - expect(new Version.parse('1.2.3+build.1'), - equals(new Version(1, 2, 3, build: 'build.1'))); - expect(new Version.parse('1.2.3+x.7.z-92'), - equals(new Version(1, 2, 3, build: 'x.7.z-92'))); - - expect(new Version.parse('1.0.0-rc-1+build-1'), - equals(new Version(1, 0, 0, pre: 'rc-1', build: 'build-1'))); - - expect(() => new Version.parse('1.0'), throwsFormatException); - expect(() => new Version.parse('1.2.3.4'), throwsFormatException); - expect(() => new Version.parse('1234'), throwsFormatException); - expect(() => new Version.parse('-2.3.4'), throwsFormatException); - expect(() => new Version.parse('1.3-pre'), throwsFormatException); - expect(() => new Version.parse('1.3+build'), throwsFormatException); - expect(() => new Version.parse('1.3+bu?!3ild'), throwsFormatException); + expect(Version.parse('0.0.0'), equals(Version(0, 0, 0))); + expect(Version.parse('12.34.56'), equals(Version(12, 34, 56))); + + expect(Version.parse('1.2.3-alpha.1'), + equals(Version(1, 2, 3, pre: 'alpha.1'))); + expect(Version.parse('1.2.3-x.7.z-92'), + equals(Version(1, 2, 3, pre: 'x.7.z-92'))); + + expect(Version.parse('1.2.3+build.1'), + equals(Version(1, 2, 3, build: 'build.1'))); + expect(Version.parse('1.2.3+x.7.z-92'), + equals(Version(1, 2, 3, build: 'x.7.z-92'))); + + expect(Version.parse('1.0.0-rc-1+build-1'), + equals(Version(1, 0, 0, pre: 'rc-1', build: 'build-1'))); + + expect(() => Version.parse('1.0'), throwsFormatException); + expect(() => Version.parse('1.2.3.4'), throwsFormatException); + expect(() => Version.parse('1234'), throwsFormatException); + expect(() => Version.parse('-2.3.4'), throwsFormatException); + expect(() => Version.parse('1.3-pre'), throwsFormatException); + expect(() => Version.parse('1.3+build'), throwsFormatException); + expect(() => Version.parse('1.3+bu?!3ild'), throwsFormatException); }); group('toString()', () { test('returns the version string', () { - expect(new Version(0, 0, 0).toString(), equals('0.0.0')); - expect(new Version(12, 34, 56).toString(), equals('12.34.56')); + expect(Version(0, 0, 0).toString(), equals('0.0.0')); + expect(Version(12, 34, 56).toString(), equals('12.34.56')); - expect(new Version(1, 2, 3, pre: 'alpha.1').toString(), - equals('1.2.3-alpha.1')); - expect(new Version(1, 2, 3, pre: 'x.7.z-92').toString(), + expect( + Version(1, 2, 3, pre: 'alpha.1').toString(), equals('1.2.3-alpha.1')); + expect(Version(1, 2, 3, pre: 'x.7.z-92').toString(), equals('1.2.3-x.7.z-92')); - expect(new Version(1, 2, 3, build: 'build.1').toString(), + expect(Version(1, 2, 3, build: 'build.1').toString(), equals('1.2.3+build.1')); - expect(new Version(1, 2, 3, pre: 'pre', build: 'bui').toString(), + expect(Version(1, 2, 3, pre: 'pre', build: 'bui').toString(), equals('1.2.3-pre+bui')); }); test('preserves leading zeroes', () { - expect(new Version.parse('001.02.0003-01.dev+pre.002').toString(), + expect(Version.parse('001.02.0003-01.dev+pre.002').toString(), equals('001.02.0003-01.dev+pre.002')); }); }); diff --git a/pkgs/pub_semver/test/version_union_test.dart b/pkgs/pub_semver/test/version_union_test.dart index f629c83d42..11a5ecd732 100644 --- a/pkgs/pub_semver/test/version_union_test.dart +++ b/pkgs/pub_semver/test/version_union_test.dart @@ -8,11 +8,11 @@ import 'package:pub_semver/pub_semver.dart'; import 'utils.dart'; -main() { +void main() { group('factory', () { test('ignores empty constraints', () { expect( - new VersionConstraint.unionOf([ + VersionConstraint.unionOf([ VersionConstraint.empty, VersionConstraint.empty, v123, @@ -21,141 +21,140 @@ main() { equals(v123)); expect( - new VersionConstraint.unionOf( + VersionConstraint.unionOf( [VersionConstraint.empty, VersionConstraint.empty]), isEmpty); }); test('returns an empty constraint for an empty list', () { - expect(new VersionConstraint.unionOf([]), isEmpty); + expect(VersionConstraint.unionOf([]), isEmpty); }); test('any constraints override everything', () { expect( - new VersionConstraint.unionOf([ + VersionConstraint.unionOf([ v123, VersionConstraint.any, v200, - new VersionRange(min: v234, max: v250) + VersionRange(min: v234, max: v250) ]), equals(VersionConstraint.any)); }); test('flattens other unions', () { expect( - new VersionConstraint.unionOf([ + VersionConstraint.unionOf([ v072, - new VersionConstraint.unionOf([v123, v124]), + VersionConstraint.unionOf([v123, v124]), v250 ]), - equals(new VersionConstraint.unionOf([v072, v123, v124, v250]))); + equals(VersionConstraint.unionOf([v072, v123, v124, v250]))); }); test('returns a single merged range as-is', () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v080, max: v140), - new VersionRange(min: v123, max: v200) + VersionConstraint.unionOf([ + VersionRange(min: v080, max: v140), + VersionRange(min: v123, max: v200) ]), - equals(new VersionRange(min: v080, max: v200))); + equals(VersionRange(min: v080, max: v200))); }); }); group('equality', () { test("doesn't depend on original order", () { expect( - new VersionConstraint.unionOf([ + VersionConstraint.unionOf([ v250, - new VersionRange(min: v201, max: v234), + VersionRange(min: v201, max: v234), v124, v072, - new VersionRange(min: v080, max: v114), + VersionRange(min: v080, max: v114), v123 ]), - equals(new VersionConstraint.unionOf([ + equals(VersionConstraint.unionOf([ v072, - new VersionRange(min: v080, max: v114), + VersionRange(min: v080, max: v114), v123, v124, - new VersionRange(min: v201, max: v234), + VersionRange(min: v201, max: v234), v250 ]))); }); test("merges overlapping ranges", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - new VersionRange(min: v010, max: v080), - new VersionRange(min: v114, max: v124), - new VersionRange(min: v123, max: v130) + VersionConstraint.unionOf([ + VersionRange(min: v003, max: v072), + VersionRange(min: v010, max: v080), + VersionRange(min: v114, max: v124), + VersionRange(min: v123, max: v130) ]), - equals(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v114, max: v130) + equals(VersionConstraint.unionOf([ + VersionRange(min: v003, max: v080), + VersionRange(min: v114, max: v130) ]))); }); test("merges adjacent ranges", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072, includeMax: true), - new VersionRange(min: v072, max: v080), - new VersionRange( + VersionConstraint.unionOf([ + VersionRange(min: v003, max: v072, includeMax: true), + VersionRange(min: v072, max: v080), + VersionRange( min: v114, max: v124, alwaysIncludeMaxPreRelease: true), - new VersionRange(min: v124, max: v130, includeMin: true), - new VersionRange( - min: v130.firstPreRelease, max: v200, includeMin: true) + VersionRange(min: v124, max: v130, includeMin: true), + VersionRange(min: v130.firstPreRelease, max: v200, includeMin: true) ]), - equals(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v114, max: v200) + equals(VersionConstraint.unionOf([ + VersionRange(min: v003, max: v080), + VersionRange(min: v114, max: v200) ]))); }); test("doesn't merge not-quite-adjacent ranges", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v114, max: v124), - new VersionRange(min: v124, max: v130, includeMin: true) + VersionConstraint.unionOf([ + VersionRange(min: v114, max: v124), + VersionRange(min: v124, max: v130, includeMin: true) ]), - isNot(equals(new VersionRange(min: v114, max: v130)))); + isNot(equals(VersionRange(min: v114, max: v130)))); expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - new VersionRange(min: v072, max: v080) + VersionConstraint.unionOf([ + VersionRange(min: v003, max: v072), + VersionRange(min: v072, max: v080) ]), - isNot(equals(new VersionRange(min: v003, max: v080)))); + isNot(equals(VersionRange(min: v003, max: v080)))); }); test("merges version numbers into ranges", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), + VersionConstraint.unionOf([ + VersionRange(min: v003, max: v072), v010, - new VersionRange(min: v114, max: v124), + VersionRange(min: v114, max: v124), v123 ]), - equals(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - new VersionRange(min: v114, max: v124) + equals(VersionConstraint.unionOf([ + VersionRange(min: v003, max: v072), + VersionRange(min: v114, max: v124) ]))); }); test("merges adjacent version numbers into ranges", () { expect( - new VersionConstraint.unionOf([ - new VersionRange( + VersionConstraint.unionOf([ + VersionRange( min: v003, max: v072, alwaysIncludeMaxPreRelease: true), v072, v114, - new VersionRange(min: v114, max: v124), + VersionRange(min: v114, max: v124), v124.firstPreRelease ]), - equals(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072, includeMax: true), - new VersionRange( + equals(VersionConstraint.unionOf([ + VersionRange(min: v003, max: v072, includeMax: true), + VersionRange( min: v114, max: v124.firstPreRelease, includeMin: true, @@ -165,35 +164,33 @@ main() { test("doesn't merge not-quite-adjacent version numbers into ranges", () { expect( - new VersionConstraint.unionOf( - [new VersionRange(min: v003, max: v072), v072]), - isNot(equals( - new VersionRange(min: v003, max: v072, includeMax: true)))); + VersionConstraint.unionOf([VersionRange(min: v003, max: v072), v072]), + isNot(equals(VersionRange(min: v003, max: v072, includeMax: true)))); }); }); test('isEmpty returns false', () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v123, max: v130), + VersionConstraint.unionOf([ + VersionRange(min: v003, max: v080), + VersionRange(min: v123, max: v130), ]), isNot(isEmpty)); }); test('isAny returns false', () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v123, max: v130), + VersionConstraint.unionOf([ + VersionRange(min: v003, max: v080), + VersionRange(min: v123, max: v130), ]).isAny, isFalse); }); test('allows() allows anything the components allow', () { - var union = new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v123, max: v130), + var union = VersionConstraint.unionOf([ + VersionRange(min: v003, max: v080), + VersionRange(min: v123, max: v130), v200 ]); @@ -206,9 +203,9 @@ main() { group('allowsAll()', () { test('for a version, returns true if any component allows the version', () { - var union = new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v123, max: v130), + var union = VersionConstraint.unionOf([ + VersionRange(min: v003, max: v080), + VersionRange(min: v123, max: v130), v200 ]); @@ -222,56 +219,56 @@ main() { test( 'for a version range, returns true if any component allows the whole ' 'range', () { - var union = new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v123, max: v130) + var union = VersionConstraint.unionOf([ + VersionRange(min: v003, max: v080), + VersionRange(min: v123, max: v130) ]); - expect(union.allowsAll(new VersionRange(min: v003, max: v080)), isTrue); - expect(union.allowsAll(new VersionRange(min: v010, max: v072)), isTrue); - expect(union.allowsAll(new VersionRange(min: v010, max: v124)), isFalse); + expect(union.allowsAll(VersionRange(min: v003, max: v080)), isTrue); + expect(union.allowsAll(VersionRange(min: v010, max: v072)), isTrue); + expect(union.allowsAll(VersionRange(min: v010, max: v124)), isFalse); }); group('for a union,', () { - var union = new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v123, max: v130) + var union = VersionConstraint.unionOf([ + VersionRange(min: v003, max: v080), + VersionRange(min: v123, max: v130) ]); test('returns true if every constraint matches a different constraint', () { expect( - union.allowsAll(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v072), - new VersionRange(min: v124, max: v130) + union.allowsAll(VersionConstraint.unionOf([ + VersionRange(min: v010, max: v072), + VersionRange(min: v124, max: v130) ])), isTrue); }); test('returns true if every constraint matches the same constraint', () { expect( - union.allowsAll(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v010), - new VersionRange(min: v072, max: v080) + union.allowsAll(VersionConstraint.unionOf([ + VersionRange(min: v003, max: v010), + VersionRange(min: v072, max: v080) ])), isTrue); }); test("returns false if there's an unmatched constraint", () { expect( - union.allowsAll(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v072), - new VersionRange(min: v124, max: v130), - new VersionRange(min: v140, max: v200) + union.allowsAll(VersionConstraint.unionOf([ + VersionRange(min: v010, max: v072), + VersionRange(min: v124, max: v130), + VersionRange(min: v140, max: v200) ])), isFalse); }); test("returns false if a constraint isn't fully matched", () { expect( - union.allowsAll(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v114), - new VersionRange(min: v124, max: v130) + union.allowsAll(VersionConstraint.unionOf([ + VersionRange(min: v010, max: v114), + VersionRange(min: v124, max: v130) ])), isFalse); }); @@ -280,9 +277,9 @@ main() { group('allowsAny()', () { test('for a version, returns true if any component allows the version', () { - var union = new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v123, max: v130), + var union = VersionConstraint.unionOf([ + VersionRange(min: v003, max: v080), + VersionRange(min: v123, max: v130), v200 ]); @@ -296,38 +293,38 @@ main() { test( 'for a version range, returns true if any component allows part of ' 'the range', () { - var union = new VersionConstraint.unionOf( - [new VersionRange(min: v003, max: v080), v123]); + var union = + VersionConstraint.unionOf([VersionRange(min: v003, max: v080), v123]); - expect(union.allowsAny(new VersionRange(min: v010, max: v114)), isTrue); - expect(union.allowsAny(new VersionRange(min: v114, max: v124)), isTrue); - expect(union.allowsAny(new VersionRange(min: v124, max: v130)), isFalse); + expect(union.allowsAny(VersionRange(min: v010, max: v114)), isTrue); + expect(union.allowsAny(VersionRange(min: v114, max: v124)), isTrue); + expect(union.allowsAny(VersionRange(min: v124, max: v130)), isFalse); }); group('for a union,', () { - var union = new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v130) + var union = VersionConstraint.unionOf([ + VersionRange(min: v010, max: v080), + VersionRange(min: v123, max: v130) ]); test('returns true if any constraint matches', () { expect( - union.allowsAny(new VersionConstraint.unionOf( - [v072, new VersionRange(min: v200, max: v300)])), + union.allowsAny(VersionConstraint.unionOf( + [v072, VersionRange(min: v200, max: v300)])), isTrue); expect( - union.allowsAny(new VersionConstraint.unionOf( - [v003, new VersionRange(min: v124, max: v300)])), + union.allowsAny(VersionConstraint.unionOf( + [v003, VersionRange(min: v124, max: v300)])), isTrue); }); test("returns false if no constraint matches", () { expect( - union.allowsAny(new VersionConstraint.unionOf([ + union.allowsAny(VersionConstraint.unionOf([ v003, - new VersionRange(min: v130, max: v140), - new VersionRange(min: v140, max: v200) + VersionRange(min: v130, max: v140), + VersionRange(min: v140, max: v200) ])), isFalse); }); @@ -337,83 +334,83 @@ main() { group("intersect()", () { test("with an overlapping version, returns that version", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v140) + VersionConstraint.unionOf([ + VersionRange(min: v010, max: v080), + VersionRange(min: v123, max: v140) ]).intersect(v072), equals(v072)); }); test("with a non-overlapping version, returns an empty constraint", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v140) + VersionConstraint.unionOf([ + VersionRange(min: v010, max: v080), + VersionRange(min: v123, max: v140) ]).intersect(v300), isEmpty); }); test("with an overlapping range, returns that range", () { - var range = new VersionRange(min: v072, max: v080); + var range = VersionRange(min: v072, max: v080); expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v140) + VersionConstraint.unionOf([ + VersionRange(min: v010, max: v080), + VersionRange(min: v123, max: v140) ]).intersect(range), equals(range)); }); test("with a non-overlapping range, returns an empty constraint", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v140) - ]).intersect(new VersionRange(min: v080, max: v123)), + VersionConstraint.unionOf([ + VersionRange(min: v010, max: v080), + VersionRange(min: v123, max: v140) + ]).intersect(VersionRange(min: v080, max: v123)), isEmpty); }); test("with a parially-overlapping range, returns the overlapping parts", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v140) - ]).intersect(new VersionRange(min: v072, max: v130)), - equals(new VersionConstraint.unionOf([ - new VersionRange(min: v072, max: v080), - new VersionRange(min: v123, max: v130) + VersionConstraint.unionOf([ + VersionRange(min: v010, max: v080), + VersionRange(min: v123, max: v140) + ]).intersect(VersionRange(min: v072, max: v130)), + equals(VersionConstraint.unionOf([ + VersionRange(min: v072, max: v080), + VersionRange(min: v123, max: v130) ]))); }); group("for a union,", () { - var union = new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v080), - new VersionRange(min: v123, max: v130) + var union = VersionConstraint.unionOf([ + VersionRange(min: v003, max: v080), + VersionRange(min: v123, max: v130) ]); test("returns the overlapping parts", () { expect( - union.intersect(new VersionConstraint.unionOf([ + union.intersect(VersionConstraint.unionOf([ v010, - new VersionRange(min: v072, max: v124), - new VersionRange(min: v124, max: v130) + VersionRange(min: v072, max: v124), + VersionRange(min: v124, max: v130) ])), - equals(new VersionConstraint.unionOf([ + equals(VersionConstraint.unionOf([ v010, - new VersionRange(min: v072, max: v080), - new VersionRange(min: v123, max: v124), - new VersionRange(min: v124, max: v130) + VersionRange(min: v072, max: v080), + VersionRange(min: v123, max: v124), + VersionRange(min: v124, max: v130) ]))); }); test("drops parts that don't match", () { expect( - union.intersect(new VersionConstraint.unionOf([ + union.intersect(VersionConstraint.unionOf([ v003, - new VersionRange(min: v072, max: v080), - new VersionRange(min: v080, max: v123) + VersionRange(min: v072, max: v080), + VersionRange(min: v080, max: v123) ])), - equals(new VersionRange(min: v072, max: v080))); + equals(VersionRange(min: v072, max: v080))); }); }); }); @@ -421,67 +418,65 @@ main() { group("difference()", () { test("ignores ranges that don't intersect", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v072, max: v080), - new VersionRange(min: v123, max: v130) - ]).difference(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v010), - new VersionRange(min: v080, max: v123), - new VersionRange(min: v140) + VersionConstraint.unionOf([ + VersionRange(min: v072, max: v080), + VersionRange(min: v123, max: v130) + ]).difference(VersionConstraint.unionOf([ + VersionRange(min: v003, max: v010), + VersionRange(min: v080, max: v123), + VersionRange(min: v140) ])), - equals(new VersionConstraint.unionOf([ - new VersionRange(min: v072, max: v080), - new VersionRange(min: v123, max: v130) + equals(VersionConstraint.unionOf([ + VersionRange(min: v072, max: v080), + VersionRange(min: v123, max: v130) ]))); }); test("removes overlapping portions", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v080), - new VersionRange(min: v123, max: v130) - ]).difference(new VersionConstraint.unionOf([ - new VersionRange(min: v003, max: v072), - new VersionRange(min: v124) - ])), - equals(new VersionConstraint.unionOf([ - new VersionRange( + VersionConstraint.unionOf([ + VersionRange(min: v010, max: v080), + VersionRange(min: v123, max: v130) + ]).difference(VersionConstraint.unionOf( + [VersionRange(min: v003, max: v072), VersionRange(min: v124)])), + equals(VersionConstraint.unionOf([ + VersionRange( min: v072.firstPreRelease, max: v080, includeMin: true), - new VersionRange(min: v123, max: v124, includeMax: true) + VersionRange(min: v123, max: v124, includeMax: true) ]))); }); test("removes multiple portions from the same range", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v114), - new VersionRange(min: v130, max: v200) - ]).difference(new VersionConstraint.unionOf([v072, v080])), - equals(new VersionConstraint.unionOf([ - new VersionRange( + VersionConstraint.unionOf([ + VersionRange(min: v010, max: v114), + VersionRange(min: v130, max: v200) + ]).difference(VersionConstraint.unionOf([v072, v080])), + equals(VersionConstraint.unionOf([ + VersionRange( min: v010, max: v072, alwaysIncludeMaxPreRelease: true), - new VersionRange( + VersionRange( min: v072, max: v080, alwaysIncludeMaxPreRelease: true), - new VersionRange(min: v080, max: v114), - new VersionRange(min: v130, max: v200) + VersionRange(min: v080, max: v114), + VersionRange(min: v130, max: v200) ]))); }); test("removes the same range from multiple ranges", () { expect( - new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v072), - new VersionRange(min: v080, max: v123), - new VersionRange(min: v124, max: v130), - new VersionRange(min: v200, max: v234), - new VersionRange(min: v250, max: v300) - ]).difference(new VersionRange(min: v114, max: v201)), - equals(new VersionConstraint.unionOf([ - new VersionRange(min: v010, max: v072), - new VersionRange(min: v080, max: v114, includeMax: true), - new VersionRange( + VersionConstraint.unionOf([ + VersionRange(min: v010, max: v072), + VersionRange(min: v080, max: v123), + VersionRange(min: v124, max: v130), + VersionRange(min: v200, max: v234), + VersionRange(min: v250, max: v300) + ]).difference(VersionRange(min: v114, max: v201)), + equals(VersionConstraint.unionOf([ + VersionRange(min: v010, max: v072), + VersionRange(min: v080, max: v114, includeMax: true), + VersionRange( min: v201.firstPreRelease, max: v234, includeMin: true), - new VersionRange(min: v250, max: v300) + VersionRange(min: v250, max: v300) ]))); }); }); From 547690ec9057f78780f352889b169fa11511eab3 Mon Sep 17 00:00:00 2001 From: Jonas Finnemann Jensen Date: Mon, 22 Jul 2019 13:57:02 +0200 Subject: [PATCH 052/115] Reference https://semver.org/spec/v2.0.0-rc.1.html --- pkgs/pub_semver/README.md | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/pkgs/pub_semver/README.md b/pkgs/pub_semver/README.md index b359754077..5e0c36cd85 100644 --- a/pkgs/pub_semver/README.md +++ b/pkgs/pub_semver/README.md @@ -1,6 +1,7 @@ Handles version numbers and version constraints in the same way that [pub][] -does. The semantics here very closely follow the [Semantic Versioning][semver] -spec. It differs from semver in a few corner cases: +does. The semantics here very closely follow the +[Semantic Versioning spec version 2.0.0-rc.1][semver]. It differs from semver +in a few corner cases: * **Version ordering does take build suffixes into account.** This is unlike semver 2.0.0 but like earlier versions of semver. Version `1.2.3+1` is @@ -94,5 +95,5 @@ spec. It differs from semver in a few corner cases: constraint greater than or equal to a given version, but less than its next breaking one. -[pub]: http://pub.dartlang.org/ -[semver]: http://semver.org/ +[pub]: https://pub.dev +[semver]: https://semver.org/spec/v2.0.0-rc.1.html From a51b52678a4855fee1721a39cb8ad5030217dc1b Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Wed, 31 Jul 2019 21:02:43 -0700 Subject: [PATCH 053/115] Delete codereview.settings --- pkgs/pub_semver/codereview.settings | 3 --- 1 file changed, 3 deletions(-) delete mode 100644 pkgs/pub_semver/codereview.settings diff --git a/pkgs/pub_semver/codereview.settings b/pkgs/pub_semver/codereview.settings deleted file mode 100644 index 94ddf0ea9f..0000000000 --- a/pkgs/pub_semver/codereview.settings +++ /dev/null @@ -1,3 +0,0 @@ -CODE_REVIEW_SERVER: https://codereview.chromium.org/ -VIEW_VC: https://github.com/dart-lang/pub_semver/commit/ -CC_LIST: reviews@dartlang.org \ No newline at end of file From fe4d2e4f339582570525b5776f62030ee0ffd915 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Wed, 18 Dec 2019 17:54:39 -0800 Subject: [PATCH 054/115] Fix new pedantic lints, disallow implicit casts (dart-lang/pub_semver#40) - annotate_overrides - prefer_single_quotes There is a minor breaking change in `VersionConstraint.unionOf` if any callers were passing a custom subtype of `VersionConstraint` and _also_ always had a constraint with `.isAny` of `true`. There are no known remaining callers of this API and it should be removed - allowing a technically breaking change that no one will hit allows us to have nice static types within the method. --- pkgs/pub_semver/analysis_options.yaml | 6 +- pkgs/pub_semver/lib/src/patterns.dart | 4 +- pkgs/pub_semver/lib/src/version.dart | 41 ++-- .../lib/src/version_constraint.dart | 29 +-- pkgs/pub_semver/lib/src/version_range.dart | 17 +- pkgs/pub_semver/lib/src/version_union.dart | 22 +- pkgs/pub_semver/test/utils.dart | 3 + .../test/version_constraint_test.dart | 16 +- pkgs/pub_semver/test/version_range_test.dart | 214 +++++++++--------- pkgs/pub_semver/test/version_test.dart | 16 +- pkgs/pub_semver/test/version_union_test.dart | 34 +-- 11 files changed, 224 insertions(+), 178 deletions(-) diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml index c970ea7aad..248e8c6d76 100644 --- a/pkgs/pub_semver/analysis_options.yaml +++ b/pkgs/pub_semver/analysis_options.yaml @@ -1,7 +1,9 @@ include: package:pedantic/analysis_options.yaml + analyzer: -# strong-mode: -# implicit-casts: false + strong-mode: + implicit-casts: false + linter: rules: - always_declare_return_types diff --git a/pkgs/pub_semver/lib/src/patterns.dart b/pkgs/pub_semver/lib/src/patterns.dart index 8829447fad..d5f1897113 100644 --- a/pkgs/pub_semver/lib/src/patterns.dart +++ b/pkgs/pub_semver/lib/src/patterns.dart @@ -13,7 +13,7 @@ final completeVersion = RegExp('${startVersion.pattern}\$'); /// Parses a comparison operator ("<", ">", "<=", or ">=") at the beginning of /// a string. -final startComparison = RegExp(r"^[<>]=?"); +final startComparison = RegExp(r'^[<>]=?'); /// The "compatible with" operator. -const compatibleWithChar = "^"; +const compatibleWithChar = '^'; diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 031af5201b..eb38409dc9 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -83,9 +83,13 @@ class Version implements VersionConstraint, VersionRange { /// of the parsed version. final String _text; + @override Version get min => this; + @override Version get max => this; + @override bool get includeMin => true; + @override bool get includeMax => true; Version._(this.major, this.minor, this.patch, String preRelease, String build, @@ -99,9 +103,9 @@ class Version implements VersionConstraint, VersionRange { /// Creates a new [Version] object. factory Version(int major, int minor, int patch, {String pre, String build}) { - var text = "$major.$minor.$patch"; - if (pre != null) text += "-$pre"; - if (build != null) text += "+$build"; + var text = '$major.$minor.$patch'; + if (pre != null) text += '-$pre'; + if (build != null) text += '+$build'; return Version._(major, minor, patch, pre, build, text); } @@ -157,15 +161,16 @@ class Version implements VersionConstraint, VersionRange { }).toList(); } - bool operator ==(other) { - if (other is! Version) return false; - return major == other.major && - minor == other.minor && - patch == other.patch && - _equality.equals(preRelease, other.preRelease) && - _equality.equals(build, other.build); - } + @override + bool operator ==(Object other) => + other is Version && + major == other.major && + minor == other.minor && + patch == other.patch && + _equality.equals(preRelease, other.preRelease) && + _equality.equals(build, other.build); + @override int get hashCode => major ^ minor ^ @@ -178,7 +183,9 @@ class Version implements VersionConstraint, VersionRange { bool operator <=(Version other) => compareTo(other) <= 0; bool operator >=(Version other) => compareTo(other) >= 0; + @override bool get isAny => false; + @override bool get isEmpty => false; /// Whether or not this is a pre-release version. @@ -237,7 +244,7 @@ class Version implements VersionConstraint, VersionRange { } /// Returns the first possible pre-release of this version. - Version get firstPreRelease => Version(major, minor, patch, pre: "0"); + Version get firstPreRelease => Version(major, minor, patch, pre: '0'); /// Returns whether this is the first possible pre-release of its version. bool get isFirstPreRelease => preRelease.length == 1 && preRelease.first == 0; @@ -247,15 +254,20 @@ class Version implements VersionConstraint, VersionRange { Version _incrementPatch() => Version(major, minor, patch + 1); /// Tests if [other] matches this version exactly. + @override bool allows(Version other) => this == other; + @override bool allowsAll(VersionConstraint other) => other.isEmpty || other == this; + @override bool allowsAny(VersionConstraint other) => other.allows(this); + @override VersionConstraint intersect(VersionConstraint other) => other.allows(this) ? this : VersionConstraint.empty; + @override VersionConstraint union(VersionConstraint other) { if (other.allows(this)) return other; @@ -282,9 +294,11 @@ class Version implements VersionConstraint, VersionRange { return VersionConstraint.unionOf([this, other]); } + @override VersionConstraint difference(VersionConstraint other) => other.allows(this) ? VersionConstraint.empty : this; + @override int compareTo(VersionRange other) { if (other is Version) { if (major != other.major) return major.compareTo(other.major); @@ -307,6 +321,7 @@ class Version implements VersionConstraint, VersionRange { } } + @override String toString() => _text; /// Compares a dot-separated component of two versions. @@ -338,7 +353,7 @@ class Version implements VersionConstraint, VersionRange { return 1; } else { // Compare two strings. - return aPart.compareTo(bPart); + return (aPart as String).compareTo(bPart as String); } } } diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 6dfd396f57..ac39b6b183 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -54,7 +54,7 @@ abstract class VersionConstraint { skipWhitespace(); // Handle the "any" constraint. - if (text == "any") return any; + if (text == 'any') return any; // Try to parse and consume a version number. Version matchVersion() { @@ -190,7 +190,7 @@ abstract class VersionConstraint { Iterable constraints) { var constraint = VersionRange(); for (var other in constraints) { - constraint = constraint.intersect(other); + constraint = constraint.intersect(other) as VersionRange; } return constraint; } @@ -201,9 +201,10 @@ abstract class VersionConstraint { /// [constraints] is empty, this returns a constraint that allows no versions. factory VersionConstraint.unionOf(Iterable constraints) { var flattened = constraints.expand((constraint) { - if (constraint.isEmpty) return []; + if (constraint.isEmpty) return []; if (constraint is VersionUnion) return constraint.ranges; - return [constraint]; + if (constraint is VersionRange) return [constraint]; + throw ArgumentError('Unknown VersionConstraint type $constraint.'); }).toList(); if (flattened.isEmpty) return VersionConstraint.empty; @@ -212,14 +213,6 @@ abstract class VersionConstraint { return VersionConstraint.any; } - // Only allow Versions and VersionRanges here so we can more easily reason - // about everything in [flattened]. _EmptyVersions and VersionUnions are - // filtered out above. - for (var constraint in flattened) { - if (constraint is VersionRange) continue; - throw ArgumentError('Unknown VersionConstraint type $constraint.'); - } - flattened.sort(); var merged = []; @@ -230,7 +223,8 @@ abstract class VersionConstraint { !areAdjacent(merged.last, constraint))) { merged.add(constraint); } else { - merged[merged.length - 1] = merged.last.union(constraint); + merged[merged.length - 1] = + merged.last.union(constraint) as VersionRange; } } @@ -271,21 +265,30 @@ abstract class VersionConstraint { class _EmptyVersion implements VersionConstraint { const _EmptyVersion(); + @override bool get isEmpty => true; + @override bool get isAny => false; + @override bool allows(Version other) => false; + @override bool allowsAll(VersionConstraint other) => other.isEmpty; + @override bool allowsAny(VersionConstraint other) => false; + @override VersionConstraint intersect(VersionConstraint other) => this; + @override VersionConstraint union(VersionConstraint other) => other; + @override VersionConstraint difference(VersionConstraint other) => this; + @override String toString() => ''; } diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 8ac79dab8b..2c4088426f 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -84,6 +84,7 @@ class VersionRange implements Comparable, VersionConstraint { VersionRange._(this.min, this.max, this.includeMin, this.includeMax); + @override bool operator ==(other) { if (other is! VersionRange) return false; @@ -93,17 +94,21 @@ class VersionRange implements Comparable, VersionConstraint { includeMax == other.includeMax; } + @override int get hashCode => min.hashCode ^ (max.hashCode * 3) ^ (includeMin.hashCode * 5) ^ (includeMax.hashCode * 7); + @override bool get isEmpty => false; + @override bool get isAny => min == null && max == null; /// Tests if [other] falls within this version range. + @override bool allows(Version other) { if (min != null) { if (other < min) return false; @@ -118,6 +123,7 @@ class VersionRange implements Comparable, VersionConstraint { return true; } + @override bool allowsAll(VersionConstraint other) { if (other.isEmpty) return true; if (other is Version) return allows(other); @@ -133,6 +139,7 @@ class VersionRange implements Comparable, VersionConstraint { throw ArgumentError('Unknown VersionConstraint type $other.'); } + @override bool allowsAny(VersionConstraint other) { if (other.isEmpty) return false; if (other is Version) return allows(other); @@ -148,6 +155,7 @@ class VersionRange implements Comparable, VersionConstraint { throw ArgumentError('Unknown VersionConstraint type $other.'); } + @override VersionConstraint intersect(VersionConstraint other) { if (other.isEmpty) return other; if (other is VersionUnion) return other.intersect(this); @@ -206,6 +214,7 @@ class VersionRange implements Comparable, VersionConstraint { throw ArgumentError('Unknown VersionConstraint type $other.'); } + @override VersionConstraint union(VersionConstraint other) { if (other is Version) { if (allows(other)) return this; @@ -271,6 +280,7 @@ class VersionRange implements Comparable, VersionConstraint { return VersionConstraint.unionOf([this, other]); } + @override VersionConstraint difference(VersionConstraint other) { if (other.isEmpty) return this; @@ -383,6 +393,7 @@ class VersionRange implements Comparable, VersionConstraint { throw ArgumentError('Unknown VersionConstraint type $other.'); } + @override int compareTo(VersionRange other) { if (min == null) { if (other.min == null) return _compareMax(other); @@ -413,6 +424,7 @@ class VersionRange implements Comparable, VersionConstraint { return 0; } + @override String toString() { var buffer = StringBuffer(); @@ -429,7 +441,7 @@ class VersionRange implements Comparable, VersionConstraint { if (max.isFirstPreRelease) { // Since `"<$max"` would parse the same as `"<$max-0"`, we just emit // `<$max` to avoid confusing "-0" suffixes. - buffer.write("${max.major}.${max.minor}.${max.patch}"); + buffer.write('${max.major}.${max.minor}.${max.patch}'); } else { buffer.write(max); @@ -439,7 +451,7 @@ class VersionRange implements Comparable, VersionConstraint { min.isPreRelease && equalsWithoutPreRelease(min, max); if (!max.isPreRelease && max.build.isEmpty && !minIsPreReleaseOfMax) { - buffer.write("-∞"); + buffer.write('-∞'); } } } @@ -454,5 +466,6 @@ class CompatibleWithVersionRange extends VersionRange { CompatibleWithVersionRange(Version version) : super._(version, version.nextBreaking.firstPreRelease, true, false); + @override String toString() => '^$min'; } diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index b774163ef4..8a235220cf 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -25,8 +25,10 @@ class VersionUnion implements VersionConstraint { /// those constraints that they don't match. final List ranges; + @override bool get isEmpty => false; + @override bool get isAny => false; /// Creates a union from a list of ranges with no pre-processing. @@ -37,9 +39,11 @@ class VersionUnion implements VersionConstraint { /// VersionConstraint.unionOf] instead. VersionUnion.fromRanges(this.ranges); + @override bool allows(Version version) => ranges.any((constraint) => constraint.allows(version)); + @override bool allowsAll(VersionConstraint other) { var ourRanges = ranges.iterator; var theirRanges = _rangesFor(other).iterator; @@ -61,6 +65,7 @@ class VersionUnion implements VersionConstraint { return theirRanges.current == null; } + @override bool allowsAny(VersionConstraint other) { var ourRanges = ranges.iterator; var theirRanges = _rangesFor(other).iterator; @@ -86,6 +91,7 @@ class VersionUnion implements VersionConstraint { return false; } + @override VersionConstraint intersect(VersionConstraint other) { var ourRanges = ranges.iterator; var theirRanges = _rangesFor(other).iterator; @@ -98,7 +104,7 @@ class VersionUnion implements VersionConstraint { while (ourRanges.current != null && theirRanges.current != null) { var intersection = ourRanges.current.intersect(theirRanges.current); - if (!intersection.isEmpty) newRanges.add(intersection); + if (!intersection.isEmpty) newRanges.add(intersection as VersionRange); // Move the constraint with the lower max value forward. This ensures that // we keep both lists in sync as much as possible, and that large ranges @@ -116,6 +122,7 @@ class VersionUnion implements VersionConstraint { return VersionUnion.fromRanges(newRanges); } + @override VersionConstraint difference(VersionConstraint other) { var ourRanges = ranges.iterator; var theirRanges = _rangesFor(other).iterator; @@ -200,15 +207,18 @@ class VersionUnion implements VersionConstraint { throw ArgumentError('Unknown VersionConstraint type $constraint.'); } + @override VersionConstraint union(VersionConstraint other) => VersionConstraint.unionOf([this, other]); - bool operator ==(other) { - if (other is! VersionUnion) return false; - return const ListEquality().equals(ranges, other.ranges); - } + @override + bool operator ==(Object other) => + other is VersionUnion && + const ListEquality().equals(ranges, other.ranges); + @override int get hashCode => const ListEquality().hash(ranges); - String toString() => ranges.join(" or "); + @override + String toString() => ranges.join(' or '); } diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart index a0fd684c1e..eb3358a984 100644 --- a/pkgs/pub_semver/test/utils.dart +++ b/pkgs/pub_semver/test/utils.dart @@ -34,16 +34,19 @@ class _VersionConstraintMatcher implements Matcher { _VersionConstraintMatcher(this._expected, this._allow); + @override bool matches(item, Map matchState) => (item is VersionConstraint) && _expected.every((version) => item.allows(version) == _allow); + @override Description describe(Description description) { description.addAll(' ${_allow ? "allows" : "does not allow"} versions ', ', ', '', _expected); return description; } + @override Description describeMismatch( item, Description mismatchDescription, Map matchState, bool verbose) { if (item is! VersionConstraint) { diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index 1e48391ee2..c9d8e611bd 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -152,14 +152,14 @@ void main() { test('throws FormatException on a bad string', () { var bad = [ - "", " ", // Empty string. - "foo", // Bad text. - ">foo", // Bad text after operator. - "^foo", // Bad text after "^". - "1.0.0 foo", "1.0.0foo", // Bad text after version. - "anything", // Bad text after "any". - "<>1.0.0", // Multiple operators. - "1.0.0<" // Trailing operator. + '', ' ', // Empty string. + 'foo', // Bad text. + '>foo', // Bad text after operator. + '^foo', // Bad text after "^". + '1.0.0 foo', '1.0.0foo', // Bad text after version. + 'anything', // Bad text after "any". + '<>1.0.0', // Multiple operators. + '1.0.0<' // Trailing operator. ]; for (var text in bad) { diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index cfd66d9756..bf280c23ce 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -19,22 +19,22 @@ void main() { group("doesn't make the max a pre-release if", () { test("it's already a pre-release", () { - expect(VersionRange(max: Version.parse("1.2.4-pre")).max, - equals(Version.parse("1.2.4-pre"))); + expect(VersionRange(max: Version.parse('1.2.4-pre')).max, + equals(Version.parse('1.2.4-pre'))); }); - test("includeMax is true", () { + test('includeMax is true', () { expect(VersionRange(max: v124, includeMax: true).max, equals(v124)); }); - test("min is a prerelease of max", () { - expect(VersionRange(min: Version.parse("1.2.4-pre"), max: v124).max, + test('min is a prerelease of max', () { + expect(VersionRange(min: Version.parse('1.2.4-pre'), max: v124).max, equals(v124)); }); - test("max has a build identifier", () { - expect(VersionRange(max: Version.parse("1.2.4+1")).max, - equals(Version.parse("1.2.4+1"))); + test('max has a build identifier', () { + expect(VersionRange(max: Version.parse('1.2.4+1')).max, + equals(Version.parse('1.2.4+1'))); }); }); @@ -472,71 +472,71 @@ void main() { VersionRange(min: v123, max: v124).intersect(v114).isEmpty, isTrue); }); - test("with a range with a pre-release min, returns an empty constraint", + test('with a range with a pre-release min, returns an empty constraint', () { expect( VersionRange(max: v200) - .intersect(VersionConstraint.parse(">=2.0.0-dev")), + .intersect(VersionConstraint.parse('>=2.0.0-dev')), equals(VersionConstraint.empty)); }); - test("with a range with a pre-release max, returns the original", () { + test('with a range with a pre-release max, returns the original', () { expect( VersionRange(max: v200) - .intersect(VersionConstraint.parse("<2.0.0-dev")), + .intersect(VersionConstraint.parse('<2.0.0-dev')), equals(VersionRange(max: v200))); }); - group("with includeMaxPreRelease", () { + group('with includeMaxPreRelease', () { test('preserves includeMaxPreRelease if the max version is included', () { expect( includeMaxPreReleaseRange - .intersect(VersionConstraint.parse("<1.0.0")), - equals(VersionConstraint.parse("<1.0.0"))); + .intersect(VersionConstraint.parse('<1.0.0')), + equals(VersionConstraint.parse('<1.0.0'))); expect( includeMaxPreReleaseRange - .intersect(VersionConstraint.parse("<2.0.0")), - equals(VersionConstraint.parse("<2.0.0"))); + .intersect(VersionConstraint.parse('<2.0.0')), + equals(VersionConstraint.parse('<2.0.0'))); expect(includeMaxPreReleaseRange.intersect(includeMaxPreReleaseRange), equals(includeMaxPreReleaseRange)); expect( includeMaxPreReleaseRange - .intersect(VersionConstraint.parse("<3.0.0")), + .intersect(VersionConstraint.parse('<3.0.0')), equals(includeMaxPreReleaseRange)); expect( includeMaxPreReleaseRange - .intersect(VersionConstraint.parse(">1.1.4")), + .intersect(VersionConstraint.parse('>1.1.4')), equals(VersionRange( min: v114, max: v200, alwaysIncludeMaxPreRelease: true))); }); test( - "and a range with a pre-release min, returns " - "an intersection", () { + 'and a range with a pre-release min, returns ' + 'an intersection', () { expect( includeMaxPreReleaseRange - .intersect(VersionConstraint.parse(">=2.0.0-dev")), - equals(VersionConstraint.parse(">=2.0.0-dev <2.0.0"))); + .intersect(VersionConstraint.parse('>=2.0.0-dev')), + equals(VersionConstraint.parse('>=2.0.0-dev <2.0.0'))); }); test( - "and a range with a pre-release max, returns " - "the narrower constraint", () { + 'and a range with a pre-release max, returns ' + 'the narrower constraint', () { expect( includeMaxPreReleaseRange - .intersect(VersionConstraint.parse("<2.0.0-dev")), - equals(VersionConstraint.parse("<2.0.0-dev"))); + .intersect(VersionConstraint.parse('<2.0.0-dev')), + equals(VersionConstraint.parse('<2.0.0-dev'))); }); }); }); group('union()', () { - test("with a version returns the range if it contains the version", () { + test('with a version returns the range if it contains the version', () { var range = VersionRange(min: v114, max: v124); expect(range.union(v123), equals(range)); }); - test("with a version on the edge of the range, expands the range", () { + test('with a version on the edge of the range, expands the range', () { expect( VersionRange(min: v114, max: v124, alwaysIncludeMaxPreRelease: true) .union(v124), @@ -546,7 +546,7 @@ void main() { }); test( - "with a version allows both the range and the version if the range " + 'with a version allows both the range and the version if the range ' "doesn't contain the version", () { var result = VersionRange(min: v003, max: v114).union(v124); expect(result, allows(v010)); @@ -554,7 +554,7 @@ void main() { expect(result, allows(v124)); }); - test("returns a VersionUnion for a disjoint range", () { + test('returns a VersionUnion for a disjoint range', () { var result = VersionRange(min: v003, max: v114) .union(VersionRange(min: v130, max: v200)); expect(result, allows(v080)); @@ -562,7 +562,7 @@ void main() { expect(result, allows(v140)); }); - test("considers open ranges disjoint", () { + test('considers open ranges disjoint', () { var result = VersionRange(min: v003, max: v114) .union(VersionRange(min: v114, max: v200)); expect(result, allows(v080)); @@ -576,13 +576,13 @@ void main() { expect(result, allows(v140)); }); - test("returns a merged range for an overlapping range", () { + test('returns a merged range for an overlapping range', () { var result = VersionRange(min: v003, max: v114) .union(VersionRange(min: v080, max: v200)); expect(result, equals(VersionRange(min: v003, max: v200))); }); - test("considers closed ranges overlapping", () { + test('considers closed ranges overlapping', () { var result = VersionRange(min: v003, max: v114, includeMax: true) .union(VersionRange(min: v114, max: v200)); expect(result, equals(VersionRange(min: v003, max: v200))); @@ -601,7 +601,7 @@ void main() { expect(result, equals(VersionRange(min: v003, max: v200))); }); - test("includes edges if either range does", () { + test('includes edges if either range does', () { var result = VersionRange(min: v003, max: v114, includeMin: true) .union(VersionRange(min: v003, max: v114, includeMax: true)); expect( @@ -610,69 +610,69 @@ void main() { min: v003, max: v114, includeMin: true, includeMax: true))); }); - test("with a range with a pre-release min, returns a constraint with a gap", + test('with a range with a pre-release min, returns a constraint with a gap', () { var result = - VersionRange(max: v200).union(VersionConstraint.parse(">=2.0.0-dev")); + VersionRange(max: v200).union(VersionConstraint.parse('>=2.0.0-dev')); expect(result, allows(v140)); - expect(result, doesNotAllow(Version.parse("2.0.0-alpha"))); - expect(result, allows(Version.parse("2.0.0-dev"))); - expect(result, allows(Version.parse("2.0.0-dev.1"))); - expect(result, allows(Version.parse("2.0.0"))); + expect(result, doesNotAllow(Version.parse('2.0.0-alpha'))); + expect(result, allows(Version.parse('2.0.0-dev'))); + expect(result, allows(Version.parse('2.0.0-dev.1'))); + expect(result, allows(Version.parse('2.0.0'))); }); - test("with a range with a pre-release max, returns the larger constraint", + test('with a range with a pre-release max, returns the larger constraint', () { expect( - VersionRange(max: v200).union(VersionConstraint.parse("<2.0.0-dev")), - equals(VersionConstraint.parse("<2.0.0-dev"))); + VersionRange(max: v200).union(VersionConstraint.parse('<2.0.0-dev')), + equals(VersionConstraint.parse('<2.0.0-dev'))); }); - group("with includeMaxPreRelease", () { + group('with includeMaxPreRelease', () { test('adds includeMaxPreRelease if the max version is included', () { expect( - includeMaxPreReleaseRange.union(VersionConstraint.parse("<1.0.0")), + includeMaxPreReleaseRange.union(VersionConstraint.parse('<1.0.0')), equals(includeMaxPreReleaseRange)); expect(includeMaxPreReleaseRange.union(includeMaxPreReleaseRange), equals(includeMaxPreReleaseRange)); expect( - includeMaxPreReleaseRange.union(VersionConstraint.parse("<2.0.0")), + includeMaxPreReleaseRange.union(VersionConstraint.parse('<2.0.0')), equals(includeMaxPreReleaseRange)); expect( - includeMaxPreReleaseRange.union(VersionConstraint.parse("<3.0.0")), - equals(VersionConstraint.parse("<3.0.0"))); + includeMaxPreReleaseRange.union(VersionConstraint.parse('<3.0.0')), + equals(VersionConstraint.parse('<3.0.0'))); }); - test("and a range with a pre-release min, returns any", () { + test('and a range with a pre-release min, returns any', () { expect( includeMaxPreReleaseRange - .union(VersionConstraint.parse(">=2.0.0-dev")), + .union(VersionConstraint.parse('>=2.0.0-dev')), equals(VersionConstraint.any)); }); - test("and a range with a pre-release max, returns the original", () { + test('and a range with a pre-release max, returns the original', () { expect( includeMaxPreReleaseRange - .union(VersionConstraint.parse("<2.0.0-dev")), + .union(VersionConstraint.parse('<2.0.0-dev')), equals(includeMaxPreReleaseRange)); }); }); }); group('difference()', () { - test("with an empty range returns the original range", () { + test('with an empty range returns the original range', () { expect( VersionRange(min: v003, max: v114) .difference(VersionConstraint.empty), equals(VersionRange(min: v003, max: v114))); }); - test("with a version outside the range returns the original range", () { + test('with a version outside the range returns the original range', () { expect(VersionRange(min: v003, max: v114).difference(v200), equals(VersionRange(min: v003, max: v114))); }); - test("with a version in the range splits the range", () { + test('with a version in the range splits the range', () { expect( VersionRange(min: v003, max: v114).difference(v072), equals(VersionConstraint.unionOf([ @@ -682,43 +682,43 @@ void main() { ]))); }); - test("with the max version makes the max exclusive", () { + test('with the max version makes the max exclusive', () { expect( VersionRange(min: v003, max: v114, includeMax: true).difference(v114), equals(VersionRange( min: v003, max: v114, alwaysIncludeMaxPreRelease: true))); }); - test("with the min version makes the min exclusive", () { + test('with the min version makes the min exclusive', () { expect( VersionRange(min: v003, max: v114, includeMin: true).difference(v003), equals(VersionRange(min: v003, max: v114))); }); - test("with a disjoint range returns the original", () { + test('with a disjoint range returns the original', () { expect( VersionRange(min: v003, max: v114) .difference(VersionRange(min: v123, max: v140)), equals(VersionRange(min: v003, max: v114))); }); - test("with an adjacent range returns the original", () { + test('with an adjacent range returns the original', () { expect( VersionRange(min: v003, max: v114, includeMax: true) .difference(VersionRange(min: v114, max: v140)), equals(VersionRange(min: v003, max: v114, includeMax: true))); }); - test("with a range at the beginning cuts off the beginning of the range", + test('with a range at the beginning cuts off the beginning of the range', () { expect( VersionRange(min: v080, max: v130) .difference(VersionRange(min: v010, max: v114)), - equals(VersionConstraint.parse(">=1.1.4-0 <1.3.0"))); + equals(VersionConstraint.parse('>=1.1.4-0 <1.3.0'))); expect( VersionRange(min: v080, max: v130) .difference(VersionRange(max: v114)), - equals(VersionConstraint.parse(">=1.1.4-0 <1.3.0"))); + equals(VersionConstraint.parse('>=1.1.4-0 <1.3.0'))); expect( VersionRange(min: v080, max: v130) .difference(VersionRange(min: v010, max: v114, includeMax: true)), @@ -730,10 +730,10 @@ void main() { expect( VersionRange(min: v080, max: v130, includeMax: true) .difference(VersionRange(min: v080, max: v130)), - equals(VersionConstraint.parse(">=1.3.0-0 <=1.3.0"))); + equals(VersionConstraint.parse('>=1.3.0-0 <=1.3.0'))); }); - test("with a range at the end cuts off the end of the range", () { + test('with a range at the end cuts off the end of the range', () { expect( VersionRange(min: v080, max: v130) .difference(VersionRange(min: v114, max: v140)), @@ -758,17 +758,17 @@ void main() { equals(v080)); }); - test("with a range in the middle cuts the range in half", () { + test('with a range in the middle cuts the range in half', () { expect( VersionRange(min: v003, max: v130) .difference(VersionRange(min: v072, max: v114)), equals(VersionConstraint.unionOf([ VersionRange(min: v003, max: v072, includeMax: true), - VersionConstraint.parse(">=1.1.4-0 <1.3.0") + VersionConstraint.parse('>=1.1.4-0 <1.3.0') ]))); }); - test("with a totally covering range returns empty", () { + test('with a totally covering range returns empty', () { expect( VersionRange(min: v114, max: v200) .difference(VersionRange(min: v072, max: v300)), @@ -786,24 +786,24 @@ void main() { test( "with a version union that doesn't cover the range, returns the " - "original", () { + 'original', () { expect( VersionRange(min: v114, max: v140) .difference(VersionConstraint.unionOf([v010, v200])), equals(VersionRange(min: v114, max: v140))); }); - test("with a version union that intersects the ends, chops them off", () { + test('with a version union that intersects the ends, chops them off', () { expect( VersionRange(min: v114, max: v140).difference( VersionConstraint.unionOf([ VersionRange(min: v080, max: v123), VersionRange(min: v130, max: v200) ])), - equals(VersionConstraint.parse(">=1.2.3-0 <=1.3.0"))); + equals(VersionConstraint.parse('>=1.2.3-0 <=1.3.0'))); }); - test("with a version union that intersects the middle, chops it up", () { + test('with a version union that intersects the middle, chops it up', () { expect( VersionRange(min: v114, max: v140) .difference(VersionConstraint.unionOf([v123, v124, v130])), @@ -818,42 +818,42 @@ void main() { ]))); }); - test("with a version union that covers the whole range, returns empty", () { + test('with a version union that covers the whole range, returns empty', () { expect( VersionRange(min: v114, max: v140).difference( VersionConstraint.unionOf([v003, VersionRange(min: v010)])), equals(VersionConstraint.empty)); }); - test("with a range with a pre-release min, returns the original", () { + test('with a range with a pre-release min, returns the original', () { expect( VersionRange(max: v200) - .difference(VersionConstraint.parse(">=2.0.0-dev")), + .difference(VersionConstraint.parse('>=2.0.0-dev')), equals(VersionRange(max: v200))); }); - test("with a range with a pre-release max, returns null", () { + test('with a range with a pre-release max, returns null', () { expect( VersionRange(max: v200) - .difference(VersionConstraint.parse("<2.0.0-dev")), + .difference(VersionConstraint.parse('<2.0.0-dev')), equals(VersionConstraint.empty)); }); - group("with includeMaxPreRelease", () { - group("for the minuend", () { - test("preserves includeMaxPreRelease if the max version is included", + group('with includeMaxPreRelease', () { + group('for the minuend', () { + test('preserves includeMaxPreRelease if the max version is included', () { expect( includeMaxPreReleaseRange - .difference(VersionConstraint.parse("<1.0.0")), + .difference(VersionConstraint.parse('<1.0.0')), equals(VersionRange( - min: Version.parse("1.0.0-0"), + min: Version.parse('1.0.0-0'), max: v200, includeMin: true, alwaysIncludeMaxPreRelease: true))); expect( includeMaxPreReleaseRange - .difference(VersionConstraint.parse("<2.0.0")), + .difference(VersionConstraint.parse('<2.0.0')), equals(VersionRange( min: v200.firstPreRelease, max: v200, @@ -864,50 +864,50 @@ void main() { equals(VersionConstraint.empty)); expect( includeMaxPreReleaseRange - .difference(VersionConstraint.parse("<3.0.0")), + .difference(VersionConstraint.parse('<3.0.0')), equals(VersionConstraint.empty)); }); - test("with a range with a pre-release min, adjusts the max", () { + test('with a range with a pre-release min, adjusts the max', () { expect( includeMaxPreReleaseRange - .difference(VersionConstraint.parse(">=2.0.0-dev")), - equals(VersionConstraint.parse("<2.0.0-dev"))); + .difference(VersionConstraint.parse('>=2.0.0-dev')), + equals(VersionConstraint.parse('<2.0.0-dev'))); }); - test("with a range with a pre-release max, adjusts the min", () { + test('with a range with a pre-release max, adjusts the min', () { expect( includeMaxPreReleaseRange - .difference(VersionConstraint.parse("<2.0.0-dev")), - equals(VersionConstraint.parse(">=2.0.0-dev <2.0.0"))); + .difference(VersionConstraint.parse('<2.0.0-dev')), + equals(VersionConstraint.parse('>=2.0.0-dev <2.0.0'))); }); }); - group("for the subtrahend", () { + group('for the subtrahend', () { group("doesn't create a pre-release minimum", () { - test("when cutting off the bottom", () { + test('when cutting off the bottom', () { expect( - VersionConstraint.parse("<3.0.0") + VersionConstraint.parse('<3.0.0') .difference(includeMaxPreReleaseRange), equals(VersionRange(min: v200, max: v300, includeMin: true))); }); - test("with splitting down the middle", () { + test('with splitting down the middle', () { expect( - VersionConstraint.parse("<4.0.0").difference(VersionRange( + VersionConstraint.parse('<4.0.0').difference(VersionRange( min: v200, max: v300, includeMin: true, alwaysIncludeMaxPreRelease: true)), equals(VersionConstraint.unionOf([ VersionRange(max: v200, alwaysIncludeMaxPreRelease: true), - VersionConstraint.parse(">=3.0.0 <4.0.0") + VersionConstraint.parse('>=3.0.0 <4.0.0') ]))); }); - test("can leave a single version", () { + test('can leave a single version', () { expect( - VersionConstraint.parse("<=2.0.0") + VersionConstraint.parse('<=2.0.0') .difference(includeMaxPreReleaseRange), equals(v200)); }); @@ -922,7 +922,7 @@ void main() { }); group('compareTo()', () { - test("orders by minimum first", () { + test('orders by minimum first', () { _expectComparesSmaller(VersionRange(min: v003, max: v080), VersionRange(min: v010, max: v072)); _expectComparesSmaller(VersionRange(min: v003, max: v080), @@ -931,36 +931,36 @@ void main() { VersionRange(min: v010, max: v114)); }); - test("orders by maximum second", () { + test('orders by maximum second', () { _expectComparesSmaller(VersionRange(min: v003, max: v010), VersionRange(min: v003, max: v072)); }); - test("includeMin comes before !includeMin", () { + test('includeMin comes before !includeMin', () { _expectComparesSmaller( VersionRange(min: v003, max: v080, includeMin: true), VersionRange(min: v003, max: v080, includeMin: false)); }); - test("includeMax comes after !includeMax", () { + test('includeMax comes after !includeMax', () { _expectComparesSmaller( VersionRange(min: v003, max: v080, includeMax: false), VersionRange(min: v003, max: v080, includeMax: true)); }); - test("includeMaxPreRelease comes after !includeMaxPreRelease", () { + test('includeMaxPreRelease comes after !includeMaxPreRelease', () { _expectComparesSmaller( VersionRange(max: v200), includeMaxPreReleaseRange); }); - test("no minimum comes before small minimum", () { + test('no minimum comes before small minimum', () { _expectComparesSmaller( VersionRange(max: v010), VersionRange(min: v003, max: v010)); _expectComparesSmaller(VersionRange(max: v010, includeMin: true), VersionRange(min: v003, max: v010)); }); - test("no maximium comes after large maximum", () { + test('no maximium comes after large maximum', () { _expectComparesSmaller( VersionRange(min: v003, max: v300), VersionRange(min: v003)); _expectComparesSmaller(VersionRange(min: v003, max: v300), @@ -971,7 +971,7 @@ void main() { void _expectComparesSmaller(VersionRange smaller, VersionRange larger) { expect(smaller.compareTo(larger), lessThan(0), - reason: "expected $smaller to sort below $larger"); + reason: 'expected $smaller to sort below $larger'); expect(larger.compareTo(smaller), greaterThan(0), - reason: "expected $larger to sort above $smaller"); + reason: 'expected $larger to sort above $smaller'); } diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index 634148bccf..df0d25b147 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -167,11 +167,11 @@ void main() { }); group('union()', () { - test("with the same version returns the version", () { + test('with the same version returns the version', () { expect(v123.union(v123), equals(v123)); }); - test("with a different version returns a version that matches both", () { + test('with a different version returns a version that matches both', () { var result = v123.union(v080); expect(result, allows(v123)); expect(result, allows(v080)); @@ -180,12 +180,12 @@ void main() { expect(result, doesNotAllow(v114)); }); - test("with a range returns the range if it contains the version", () { + test('with a range returns the range if it contains the version', () { var range = VersionRange(min: v114, max: v124); expect(v123.union(range), equals(range)); }); - test("with a range with the version on the edge, expands the range", () { + test('with a range with the version on the edge, expands the range', () { expect( v124.union(VersionRange( min: v114, max: v124, alwaysIncludeMaxPreRelease: true)), @@ -199,7 +199,7 @@ void main() { }); test( - "with a range allows both the range and the version if the range " + 'with a range allows both the range and the version if the range ' "doesn't contain the version", () { var result = v123.union(VersionRange(min: v003, max: v114)); expect(result, allows(v123)); @@ -208,15 +208,15 @@ void main() { }); group('difference()', () { - test("with the same version returns an empty constraint", () { + test('with the same version returns an empty constraint', () { expect(v123.difference(v123), isEmpty); }); - test("with a different version returns the original version", () { + test('with a different version returns the original version', () { expect(v123.difference(v080), equals(v123)); }); - test("returns an empty constraint with a range that contains the version", + test('returns an empty constraint with a range that contains the version', () { expect(v123.difference(VersionRange(min: v114, max: v124)), isEmpty); }); diff --git a/pkgs/pub_semver/test/version_union_test.dart b/pkgs/pub_semver/test/version_union_test.dart index 11a5ecd732..89f9a85534 100644 --- a/pkgs/pub_semver/test/version_union_test.dart +++ b/pkgs/pub_semver/test/version_union_test.dart @@ -82,7 +82,7 @@ void main() { ]))); }); - test("merges overlapping ranges", () { + test('merges overlapping ranges', () { expect( VersionConstraint.unionOf([ VersionRange(min: v003, max: v072), @@ -96,7 +96,7 @@ void main() { ]))); }); - test("merges adjacent ranges", () { + test('merges adjacent ranges', () { expect( VersionConstraint.unionOf([ VersionRange(min: v003, max: v072, includeMax: true), @@ -128,7 +128,7 @@ void main() { isNot(equals(VersionRange(min: v003, max: v080)))); }); - test("merges version numbers into ranges", () { + test('merges version numbers into ranges', () { expect( VersionConstraint.unionOf([ VersionRange(min: v003, max: v072), @@ -142,7 +142,7 @@ void main() { ]))); }); - test("merges adjacent version numbers into ranges", () { + test('merges adjacent version numbers into ranges', () { expect( VersionConstraint.unionOf([ VersionRange( @@ -319,7 +319,7 @@ void main() { isTrue); }); - test("returns false if no constraint matches", () { + test('returns false if no constraint matches', () { expect( union.allowsAny(VersionConstraint.unionOf([ v003, @@ -331,8 +331,8 @@ void main() { }); }); - group("intersect()", () { - test("with an overlapping version, returns that version", () { + group('intersect()', () { + test('with an overlapping version, returns that version', () { expect( VersionConstraint.unionOf([ VersionRange(min: v010, max: v080), @@ -341,7 +341,7 @@ void main() { equals(v072)); }); - test("with a non-overlapping version, returns an empty constraint", () { + test('with a non-overlapping version, returns an empty constraint', () { expect( VersionConstraint.unionOf([ VersionRange(min: v010, max: v080), @@ -350,7 +350,7 @@ void main() { isEmpty); }); - test("with an overlapping range, returns that range", () { + test('with an overlapping range, returns that range', () { var range = VersionRange(min: v072, max: v080); expect( VersionConstraint.unionOf([ @@ -360,7 +360,7 @@ void main() { equals(range)); }); - test("with a non-overlapping range, returns an empty constraint", () { + test('with a non-overlapping range, returns an empty constraint', () { expect( VersionConstraint.unionOf([ VersionRange(min: v010, max: v080), @@ -369,7 +369,7 @@ void main() { isEmpty); }); - test("with a parially-overlapping range, returns the overlapping parts", + test('with a parially-overlapping range, returns the overlapping parts', () { expect( VersionConstraint.unionOf([ @@ -382,13 +382,13 @@ void main() { ]))); }); - group("for a union,", () { + group('for a union,', () { var union = VersionConstraint.unionOf([ VersionRange(min: v003, max: v080), VersionRange(min: v123, max: v130) ]); - test("returns the overlapping parts", () { + test('returns the overlapping parts', () { expect( union.intersect(VersionConstraint.unionOf([ v010, @@ -415,7 +415,7 @@ void main() { }); }); - group("difference()", () { + group('difference()', () { test("ignores ranges that don't intersect", () { expect( VersionConstraint.unionOf([ @@ -432,7 +432,7 @@ void main() { ]))); }); - test("removes overlapping portions", () { + test('removes overlapping portions', () { expect( VersionConstraint.unionOf([ VersionRange(min: v010, max: v080), @@ -446,7 +446,7 @@ void main() { ]))); }); - test("removes multiple portions from the same range", () { + test('removes multiple portions from the same range', () { expect( VersionConstraint.unionOf([ VersionRange(min: v010, max: v114), @@ -462,7 +462,7 @@ void main() { ]))); }); - test("removes the same range from multiple ranges", () { + test('removes the same range from multiple ranges', () { expect( VersionConstraint.unionOf([ VersionRange(min: v010, max: v072), From ace073c02a863dce77e998dc1b9393f3d28bb5a2 Mon Sep 17 00:00:00 2001 From: Scott Hyndman Date: Thu, 6 Feb 2020 17:21:08 -0600 Subject: [PATCH 055/115] Replace use of int.parse with int.tryParse (dart-lang/pub_semver#43) By replacing `int.parse` with `int.tryParse`, exceptions will no longer be thrown if the version part is a non-integer. This avoids triggering the debugger if set to break on "All Exceptions". Fixes dart-lang/pub_semver#42 --- pkgs/pub_semver/lib/src/version.dart | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index eb38409dc9..e769dcd64b 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -152,12 +152,8 @@ class Version implements VersionConstraint, VersionRange { /// Identifiers that are numeric are converted to numbers. static List _splitParts(String text) { return text.split('.').map((part) { - try { - return int.parse(part); - } on FormatException { - // Not a number. - return part; - } + // Return an integer part if possible, otherwise return the string as-is + return int.tryParse(part) ?? part; }).toList(); } From 1c3193eb96a374e66a4abeb248433cc7610a1cfd Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Tue, 11 Feb 2020 08:52:01 -0800 Subject: [PATCH 056/115] pubspec: remove author, update homepage URL --- pkgs/pub_semver/pubspec.yaml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index b92d2f66c6..1297883d1a 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -4,8 +4,7 @@ version: 1.4.3-dev description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. -author: Dart Team -homepage: http://github.com/dart-lang/pub_semver +homepage: https://github.com/dart-lang/pub_semver environment: sdk: '>=2.0.0 <3.0.0' From c3c9fdd5b8fd6aa4ee9dad802059012460a62b3c Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Tue, 11 Feb 2020 08:58:44 -0800 Subject: [PATCH 057/115] Add example, prepare for 1.4.3 ship --- pkgs/pub_semver/example/example.dart | 17 +++++++++++++++++ pkgs/pub_semver/pubspec.yaml | 2 +- 2 files changed, 18 insertions(+), 1 deletion(-) create mode 100644 pkgs/pub_semver/example/example.dart diff --git a/pkgs/pub_semver/example/example.dart b/pkgs/pub_semver/example/example.dart new file mode 100644 index 0000000000..890343c935 --- /dev/null +++ b/pkgs/pub_semver/example/example.dart @@ -0,0 +1,17 @@ +// Copyright (c) 2020, 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. + +import 'package:pub_semver/pub_semver.dart'; + +void main() { + final range = VersionConstraint.parse('^2.0.0'); + + for (var version in [ + Version.parse('1.2.3-pre'), + Version.parse('2.0.0+123'), + Version.parse('3.0.0-dev'), + ]) { + print('$version ${version.isPreRelease} ${range.allows(version)}'); + } +} diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 1297883d1a..e2ac3b0786 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.4.3-dev +version: 1.4.3 description: >- Versions and version constraints implementing pub's versioning policy. This From 4af6bbb0ef75d2bf85ac00babc1737e250c5f593 Mon Sep 17 00:00:00 2001 From: Sigurd Meldgaard Date: Fri, 13 Mar 2020 14:49:10 +0100 Subject: [PATCH 058/115] Fix union of version ranges --- pkgs/pub_semver/lib/src/version_range.dart | 6 +++-- pkgs/pub_semver/test/version_range_test.dart | 23 ++++++++++++++++++++ 2 files changed, 27 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 2c4088426f..78cd6d0269 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -243,8 +243,10 @@ class VersionRange implements Comparable, VersionConstraint { 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)) || - (min == other.max && (includeMin || other.includeMax)); + var edgesTouch = (max != null && + max == other.min && + (includeMax || other.includeMin)) || + (min != null && min == other.max && (includeMin || other.includeMax)); if (!edgesTouch && !allowsAny(other)) { return VersionConstraint.unionOf([this, other]); } diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index bf280c23ce..67c7f351be 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -562,6 +562,29 @@ void main() { expect(result, allows(v140)); }); + test('returns a VersionUnion for a disjoint range with infinite end', () { + void isVersionUnion(VersionConstraint constraint) { + expect(constraint, allows(v080)); + expect(constraint, doesNotAllow(v123)); + expect(constraint, allows(v140)); + } + + for (final includeAMin in [true, false]) { + for (final includeAMax in [true, false]) { + for (final includeBMin in [true, false]) { + for (final includeBMax in [true, false]) { + final a = VersionRange( + min: v130, includeMin: includeAMin, includeMax: includeAMax); + final b = VersionRange( + max: v114, includeMin: includeBMin, includeMax: includeBMax); + isVersionUnion(a.union(b)); + isVersionUnion(b.union(a)); + } + } + } + } + }); + test('considers open ranges disjoint', () { var result = VersionRange(min: v003, max: v114) .union(VersionRange(min: v114, max: v200)); From 3449b075dd78647b58a4056c742b1fe741d02523 Mon Sep 17 00:00:00 2001 From: Sigurd Meldgaard Date: Mon, 16 Mar 2020 10:01:37 +0100 Subject: [PATCH 059/115] Bump version --- pkgs/pub_semver/CHANGELOG.md | 5 +++++ pkgs/pub_semver/pubspec.yaml | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 4183252553..40f7c3e25f 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,8 @@ +# 1.4.4 + +- Fix a bug of `VersionRange.union` where ranges bounded at infinity would get + combined wrongly. + # 1.4.3 - Update Dart SDK constraint to `>=2.0.0 <3.0.0`. diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index e2ac3b0786..a2238d2f77 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.4.3 +version: 1.4.4 description: >- Versions and version constraints implementing pub's versioning policy. This From 76343bfb7cb807f7862708f60c298bfdfcb03873 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Mon, 16 Mar 2020 10:21:26 -0700 Subject: [PATCH 060/115] Remove lints duplicated by pkg:pedantic --- pkgs/pub_semver/analysis_options.yaml | 37 --------------------------- 1 file changed, 37 deletions(-) diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml index 248e8c6d76..d73e8049ee 100644 --- a/pkgs/pub_semver/analysis_options.yaml +++ b/pkgs/pub_semver/analysis_options.yaml @@ -6,24 +6,15 @@ analyzer: linter: rules: - - always_declare_return_types - #- annotate_overrides - avoid_bool_literals_in_conditional_expressions - avoid_classes_with_only_static_members - - avoid_empty_else - avoid_function_literals_in_foreach_calls - - avoid_init_to_null - - avoid_null_checks_in_equality_operators - - avoid_relative_lib_imports - avoid_renaming_method_parameters - - avoid_return_types_on_setters - avoid_returning_null - avoid_returning_null_for_future - avoid_returning_null_for_void - avoid_returning_this - - avoid_shadowing_type_parameters - avoid_single_cascade_in_expression_statements - - avoid_types_as_parameter_names - avoid_unused_constructor_parameters - await_only_futures - camel_case_types @@ -33,8 +24,6 @@ linter: - constant_identifier_names - control_flow_in_finally - directives_ordering - - empty_catches - - empty_constructor_bodies - empty_statements - file_names - hash_and_equals @@ -42,54 +31,28 @@ linter: - invariant_booleans - iterable_contains_unrelated_type - join_return_with_assignment - - library_names - - library_prefixes - list_remove_unrelated_type - literal_only_boolean_expressions - no_adjacent_strings_in_list - - no_duplicate_case_values - non_constant_identifier_names - - null_closures - - omit_local_variable_types - only_throw_errors - overridden_fields - package_api_docs - package_names - package_prefixed_library_names - - prefer_adjacent_string_concatenation - - prefer_collection_literals - - prefer_conditional_assignment - prefer_const_constructors - - prefer_contains - - prefer_equal_for_default_values - - prefer_final_fields #- prefer_final_locals - - prefer_generic_function_type_aliases - prefer_initializing_formals - prefer_interpolation_to_compose_strings - - prefer_is_empty - - prefer_is_not_empty - prefer_null_aware_operators - #- prefer_single_quotes - prefer_typing_uninitialized_variables - - recursive_getters - - slash_for_doc_comments - test_types_in_equals - throw_in_finally - - type_init_formals - - unawaited_futures - unnecessary_await_in_return - unnecessary_brace_in_string_interps - - unnecessary_const - unnecessary_getters_setters - unnecessary_lambdas - - unnecessary_new - unnecessary_null_aware_assignments - unnecessary_parenthesis - unnecessary_statements - - unnecessary_this - - unrelated_type_equality_checks - - use_function_type_syntax_for_parameters - - use_rethrow_when_possible - - valid_regexps - void_checks From cbb00b94b4b35fb7b60dfd16ed08eb5bba3b1cd9 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Tue, 28 Jul 2020 20:34:07 -0700 Subject: [PATCH 061/115] Delete .test_config No longer used --- pkgs/pub_semver/.test_config | 3 --- 1 file changed, 3 deletions(-) delete mode 100644 pkgs/pub_semver/.test_config diff --git a/pkgs/pub_semver/.test_config b/pkgs/pub_semver/.test_config deleted file mode 100644 index 25355634fc..0000000000 --- a/pkgs/pub_semver/.test_config +++ /dev/null @@ -1,3 +0,0 @@ -{ - "test_package": true -} From 5d1d313f0da9e182c848c2f155b2a40037d3fe40 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Thu, 30 Jul 2020 09:08:57 -0700 Subject: [PATCH 062/115] Add tests and improve docs for Version.primary (dart-lang/pub_semver#47) --- pkgs/pub_semver/CHANGELOG.md | 2 + pkgs/pub_semver/lib/src/version.dart | 4 +- pkgs/pub_semver/pubspec.yaml | 2 +- pkgs/pub_semver/test/version_test.dart | 54 +++++++++++++++++++++++++- 4 files changed, 58 insertions(+), 4 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 40f7c3e25f..63f72851ce 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,5 @@ +# 1.4.5-dev + # 1.4.4 - Fix a bug of `VersionRange.union` where ranges bounded at infinity would get diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index e769dcd64b..314937dbfa 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -131,10 +131,12 @@ class Version implements VersionConstraint, VersionRange { } } - /// Returns the primary version out of a list of candidates. + /// Returns the primary version out of [versions]. /// /// This is the highest-numbered stable (non-prerelease) version. If there /// are no stable versions, it's just the highest-numbered version. + /// + /// If [versions] is empty, returns `null`. static Version primary(List versions) { Version primary; for (var version in versions) { diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index a2238d2f77..78de107cb7 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 1.4.4 +version: 1.4.5-dev description: >- Versions and version constraints implementing pub's versioning policy. This diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index df0d25b147..70d277975c 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -2,9 +2,8 @@ // 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. -import 'package:test/test.dart'; - import 'package:pub_semver/pub_semver.dart'; +import 'package:test/test.dart'; import 'utils.dart'; @@ -330,4 +329,55 @@ void main() { equals('001.02.0003-01.dev+pre.002')); }); }); + + group('primary', () { + test('single', () { + expect( + _primary([ + '1.2.3', + ]).toString(), + '1.2.3', + ); + }); + + test('normal', () { + expect( + _primary([ + '1.2.3', + '1.2.2', + ]).toString(), + '1.2.3', + ); + }); + + test('all prerelease', () { + expect( + _primary([ + '1.2.2-dev.1', + '1.2.2-dev.2', + ]).toString(), + '1.2.2-dev.2', + ); + }); + + test('later prerelease', () { + expect( + _primary([ + '1.2.3', + '1.2.3-dev', + ]).toString(), + '1.2.3', + ); + }); + + test('empty', () { + expect( + _primary([]), + isNull, + ); + }); + }); } + +Version _primary(List input) => + Version.primary(input.map((e) => Version.parse(e)).toList()); From e2b4a8c19ab7ee4327afa057bb2ccdb31ebe0f4a Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Fri, 20 Nov 2020 08:30:52 -0800 Subject: [PATCH 063/115] Migrate to null safety (dart-lang/pub_semver#52) - Switch to a major version bump. - Reformat `.travis.yml`. Indent list elements to the same position as the containing key. This matches yaml style in other Google files. - Update SDK constraints to use the `2.11.0` dev SDKs. - Renames some variables with noise word "the" to match the field name and avoid the shadowing with `this.`. - Add override for analyzer package. Co-authored-by: Nate Bosch --- pkgs/pub_semver/.travis.yml | 21 +++------- pkgs/pub_semver/CHANGELOG.md | 5 ++- pkgs/pub_semver/lib/src/utils.dart | 6 +-- pkgs/pub_semver/lib/src/version.dart | 22 +++++----- .../lib/src/version_constraint.dart | 16 +++---- pkgs/pub_semver/lib/src/version_range.dart | 35 +++++++++------- pkgs/pub_semver/lib/src/version_union.dart | 32 +++++++------- pkgs/pub_semver/pubspec.yaml | 14 ++++--- pkgs/pub_semver/test/utils.dart | 42 +++++++++---------- pkgs/pub_semver/test/version_test.dart | 5 +-- 10 files changed, 96 insertions(+), 102 deletions(-) diff --git a/pkgs/pub_semver/.travis.yml b/pkgs/pub_semver/.travis.yml index 0e732d0e73..e40520c4d8 100644 --- a/pkgs/pub_semver/.travis.yml +++ b/pkgs/pub_semver/.travis.yml @@ -1,23 +1,12 @@ language: dart dart: - - dev - - 2.0.0 +- dev dart_task: - - test - -matrix: - include: - # Only validate formatting using the dev release - - dart: dev - dart_task: dartfmt - - dart: dev - dart_task: - dartanalyzer: --fatal-warnings --fatal-hints . - - dart: 2.0.0 - dart_task: - dartanalyzer: --fatal-warnings . +- test: -p vm,chrome +- dart_task: dartfmt +- dartanalyzer: --fatal-infos . # Only building master means that we don't run two builds for each pull request. branches: @@ -25,4 +14,4 @@ branches: cache: directories: - - $HOME/.pub-cache + - $HOME/.pub-cache diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 63f72851ce..371970723b 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,4 +1,7 @@ -# 1.4.5-dev +# 2.0.0-nullsafety.0 + +- Migrate to null safety. +- `Version.primary` now throws `StateError` if the `versions` argument is empty. # 1.4.4 diff --git a/pkgs/pub_semver/lib/src/utils.dart b/pkgs/pub_semver/lib/src/utils.dart index 60617f22e6..a9f714f028 100644 --- a/pkgs/pub_semver/lib/src/utils.dart +++ b/pkgs/pub_semver/lib/src/utils.dart @@ -19,7 +19,7 @@ bool allowsLower(VersionRange range1, VersionRange range2) { if (range1.min == null) return range2.min != null; if (range2.min == null) return false; - var comparison = range1.min.compareTo(range2.min); + var comparison = range1.min!.compareTo(range2.min!); if (comparison == -1) return true; if (comparison == 1) return false; return range1.includeMin && !range2.includeMin; @@ -30,7 +30,7 @@ bool allowsHigher(VersionRange range1, VersionRange range2) { if (range1.max == null) return range2.max != null; if (range2.max == null) return false; - var comparison = range1.max.compareTo(range2.max); + var comparison = range1.max!.compareTo(range2.max!); if (comparison == 1) return true; if (comparison == -1) return false; return range1.includeMax && !range2.includeMax; @@ -41,7 +41,7 @@ bool allowsHigher(VersionRange range1, VersionRange range2) { bool strictlyLower(VersionRange range1, VersionRange range2) { if (range1.max == null || range2.min == null) return false; - var comparison = range1.max.compareTo(range2.min); + var comparison = range1.max!.compareTo(range2.min!); if (comparison == -1) return true; if (comparison == 1) return false; return !range1.includeMax || !range2.includeMin; diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 314937dbfa..552b498352 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -92,8 +92,8 @@ class Version implements VersionConstraint, VersionRange { @override bool get includeMax => true; - Version._(this.major, this.minor, this.patch, String preRelease, String build, - this._text) + 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 ArgumentError('Major version must be non-negative.'); @@ -102,7 +102,8 @@ class Version implements VersionConstraint, VersionRange { } /// Creates a new [Version] object. - factory Version(int major, int minor, int patch, {String pre, String build}) { + factory Version(int major, int minor, int patch, + {String? pre, String? build}) { var text = '$major.$minor.$patch'; if (pre != null) text += '-$pre'; if (build != null) text += '+$build'; @@ -118,9 +119,9 @@ class Version implements VersionConstraint, VersionRange { } try { - var major = int.parse(match[1]); - var minor = int.parse(match[2]); - var patch = int.parse(match[3]); + var major = int.parse(match[1]!); + var minor = int.parse(match[2]!); + var patch = int.parse(match[3]!); var preRelease = match[5]; var build = match[8]; @@ -136,12 +137,11 @@ class Version implements VersionConstraint, VersionRange { /// This is the highest-numbered stable (non-prerelease) version. If there /// are no stable versions, it's just the highest-numbered version. /// - /// If [versions] is empty, returns `null`. + /// If [versions] is empty, throws a [StateError]. static Version primary(List versions) { - Version primary; - for (var version in versions) { - if (primary == null || - (!version.isPreRelease && primary.isPreRelease) || + var primary = versions.first; + for (var version in versions.skip(1)) { + if ((!version.isPreRelease && primary.isPreRelease) || (version.isPreRelease == primary.isPreRelease && version > primary)) { primary = version; } diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index ac39b6b183..6eb6c3a295 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -57,16 +57,16 @@ abstract class VersionConstraint { if (text == 'any') return any; // Try to parse and consume a version number. - Version matchVersion() { + Version? matchVersion() { var version = startVersion.firstMatch(text); if (version == null) return null; text = text.substring(version.end); - return Version.parse(version[0]); + return Version.parse(version[0]!); } // Try to parse and consume a comparison operator followed by a version. - VersionRange matchComparison() { + VersionRange? matchComparison() { var comparison = startComparison.firstMatch(text); if (comparison == null) return null; @@ -97,7 +97,7 @@ abstract class VersionConstraint { } // Try to parse the "^" operator followed by a version. - VersionConstraint matchCompatibleWith() { + VersionConstraint? matchCompatibleWith() { if (!text.startsWith(compatibleWithChar)) return null; text = text.substring(compatibleWithChar.length); @@ -120,9 +120,9 @@ abstract class VersionConstraint { var compatibleWith = matchCompatibleWith(); if (compatibleWith != null) return compatibleWith; - Version min; + Version? min; var includeMin = false; - Version max; + Version? max; var includeMax = false; for (;;) { @@ -137,7 +137,7 @@ abstract class VersionConstraint { } if (newRange.min != null) { - if (min == null || newRange.min > min) { + if (min == null || newRange.min! > min) { min = newRange.min; includeMin = newRange.includeMin; } else if (newRange.min == min && !newRange.includeMin) { @@ -146,7 +146,7 @@ abstract class VersionConstraint { } if (newRange.max != null) { - if (max == null || newRange.max < max) { + if (max == null || newRange.max! < max) { max = newRange.max; includeMax = newRange.includeMax; } else if (newRange.max == max && !newRange.includeMax) { diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 78cd6d0269..a2a63276a9 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -25,7 +25,7 @@ class VersionRange implements Comparable, VersionConstraint { /// /// This may be `null` in which case the range has no minimum end and allows /// any version less than the maximum. - final Version min; + final Version? min; /// The maximum end of the range. /// @@ -35,7 +35,7 @@ class VersionRange implements Comparable, VersionConstraint { /// /// This may be `null` in which case the range has no maximum end and allows /// any version greater than the minimum. - final Version max; + final Version? max; /// If `true` then [min] is allowed by the range. final bool includeMin; @@ -58,8 +58,8 @@ class VersionRange implements Comparable, VersionConstraint { /// pre-release versions of an exclusive [max]. Otherwise, it will use the /// default behavior for pre-release versions of [max]. factory VersionRange( - {Version min, - Version max, + {Version? min, + Version? max, bool includeMin = false, bool includeMax = false, bool alwaysIncludeMaxPreRelease = false}) { @@ -111,12 +111,12 @@ class VersionRange implements Comparable, VersionConstraint { @override bool allows(Version other) { if (min != null) { - if (other < min) return false; + if (other < min!) return false; if (!includeMin && other == min) return false; } if (max != null) { - if (other > max) return false; + if (other > max!) return false; if (!includeMax && other == max) return false; } @@ -167,7 +167,7 @@ class VersionRange implements Comparable, VersionConstraint { if (other is VersionRange) { // Intersect the two ranges. - Version intersectMin; + Version? intersectMin; bool intersectIncludeMin; if (allowsLower(this, other)) { if (strictlyLower(this, other)) return VersionConstraint.empty; @@ -179,7 +179,7 @@ class VersionRange implements Comparable, VersionConstraint { intersectIncludeMin = includeMin; } - Version intersectMax; + Version? intersectMax; bool intersectIncludeMax; if (allowsHigher(this, other)) { intersectMax = other.max; @@ -199,7 +199,7 @@ class VersionRange implements Comparable, VersionConstraint { // Because we already verified that the lower range isn't strictly // lower, there must be some overlap. assert(intersectIncludeMin && intersectIncludeMax); - return intersectMin; + return intersectMin!; } // If we got here, there is an actual range. @@ -251,7 +251,7 @@ class VersionRange implements Comparable, VersionConstraint { return VersionConstraint.unionOf([this, other]); } - Version unionMin; + Version? unionMin; bool unionIncludeMin; if (allowsLower(this, other)) { unionMin = min; @@ -261,7 +261,7 @@ class VersionRange implements Comparable, VersionConstraint { unionIncludeMin = other.includeMin; } - Version unionMax; + Version? unionMax; bool unionIncludeMax; if (allowsHigher(this, other)) { unionMax = max; @@ -326,7 +326,7 @@ class VersionRange implements Comparable, VersionConstraint { } else if (other is VersionRange) { if (!allowsAny(other)) return this; - VersionRange before; + VersionRange? before; if (!allowsLower(this, other)) { before = null; } else if (min == other.min) { @@ -342,7 +342,7 @@ class VersionRange implements Comparable, VersionConstraint { alwaysIncludeMaxPreRelease: true); } - VersionRange after; + VersionRange? after; if (!allowsHigher(this, other)) { after = null; } else if (max == other.max) { @@ -359,7 +359,7 @@ class VersionRange implements Comparable, VersionConstraint { } if (before == null && after == null) return VersionConstraint.empty; - if (before == null) return after; + if (before == null) return after!; if (after == null) return before; return VersionUnion.fromRanges([before, after]); } else if (other is VersionUnion) { @@ -404,7 +404,7 @@ class VersionRange implements Comparable, VersionConstraint { return 1; } - var result = min.compareTo(other.min); + var result = min!.compareTo(other.min!); if (result != 0) return result; if (includeMin != other.includeMin) return includeMin ? -1 : 1; @@ -420,7 +420,7 @@ class VersionRange implements Comparable, VersionConstraint { return -1; } - var result = max.compareTo(other.max); + var result = max!.compareTo(other.max!); if (result != 0) return result; if (includeMax != other.includeMax) return includeMax ? 1 : -1; return 0; @@ -430,10 +430,13 @@ class VersionRange implements Comparable, VersionConstraint { String toString() { var buffer = StringBuffer(); + final min = this.min; if (min != null) { buffer..write(includeMin ? '>=' : '>')..write(min); } + final max = this.max; + if (max != null) { if (min != null) buffer.write(' '); if (includeMax) { diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index 8a235220cf..24b82f4cc8 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -50,19 +50,19 @@ class VersionUnion implements VersionConstraint { // Because both lists of ranges are ordered by minimum version, we can // safely move through them linearly here. - ourRanges.moveNext(); - theirRanges.moveNext(); - while (ourRanges.current != null && theirRanges.current != null) { + var ourRangesMoved = ourRanges.moveNext(); + var theirRangesMoved = theirRanges.moveNext(); + while (ourRangesMoved && theirRangesMoved) { if (ourRanges.current.allowsAll(theirRanges.current)) { - theirRanges.moveNext(); + theirRangesMoved = theirRanges.moveNext(); } else { - ourRanges.moveNext(); + ourRangesMoved = ourRanges.moveNext(); } } // If our ranges have allowed all of their ranges, we'll have consumed all // of them. - return theirRanges.current == null; + return !theirRangesMoved; } @override @@ -72,9 +72,9 @@ class VersionUnion implements VersionConstraint { // Because both lists of ranges are ordered by minimum version, we can // safely move through them linearly here. - ourRanges.moveNext(); - theirRanges.moveNext(); - while (ourRanges.current != null && theirRanges.current != null) { + var ourRangesMoved = ourRanges.moveNext(); + var theirRangesMoved = theirRanges.moveNext(); + while (ourRangesMoved && theirRangesMoved) { if (ourRanges.current.allowsAny(theirRanges.current)) { return true; } @@ -82,9 +82,9 @@ class VersionUnion implements VersionConstraint { // Move the constraint with the lower max value forward. This ensures that // we keep both lists in sync as much as possible. if (allowsHigher(theirRanges.current, ourRanges.current)) { - ourRanges.moveNext(); + ourRangesMoved = ourRanges.moveNext(); } else { - theirRanges.moveNext(); + theirRangesMoved = theirRanges.moveNext(); } } @@ -99,9 +99,9 @@ class VersionUnion implements VersionConstraint { // Because both lists of ranges are ordered by minimum version, we can // safely move through them linearly here. var newRanges = []; - ourRanges.moveNext(); - theirRanges.moveNext(); - while (ourRanges.current != null && theirRanges.current != null) { + var ourRangesMoved = ourRanges.moveNext(); + var theirRangesMoved = theirRanges.moveNext(); + while (ourRangesMoved && theirRangesMoved) { var intersection = ourRanges.current.intersect(theirRanges.current); if (!intersection.isEmpty) newRanges.add(intersection as VersionRange); @@ -110,9 +110,9 @@ class VersionUnion implements VersionConstraint { // we keep both lists in sync as much as possible, and that large ranges // have a chance to match multiple small ranges that they contain. if (allowsHigher(theirRanges.current, ourRanges.current)) { - ourRanges.moveNext(); + ourRangesMoved = ourRanges.moveNext(); } else { - theirRanges.moveNext(); + theirRangesMoved = theirRanges.moveNext(); } } diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 78de107cb7..dc2d6ac0c1 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,16 +1,18 @@ name: pub_semver -version: 1.4.5-dev - +version: 2.0.0-nullsafety.0 description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. -homepage: https://github.com/dart-lang/pub_semver +repository: https://github.com/dart-lang/pub_semver environment: - sdk: '>=2.0.0 <3.0.0' + sdk: '>=2.12.0-0 <3.0.0' dependencies: - collection: ^1.0.0 + collection: ^1.15.0-nullsafety.2 dev_dependencies: - test: ^1.0.0 + test: ^1.16.0-nullsafety.1 + +dependency_overrides: + analyzer: any diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart index eb3358a984..595415abff 100644 --- a/pkgs/pub_semver/test/utils.dart +++ b/pkgs/pub_semver/test/utils.dart @@ -79,13 +79,13 @@ class _VersionConstraintMatcher implements Matcher { /// Gets a [Matcher] that validates that a [VersionConstraint] allows all /// given versions. Matcher allows(Version v1, - [Version v2, - Version v3, - Version v4, - Version v5, - Version v6, - Version v7, - Version v8]) { + [Version? v2, + Version? v3, + Version? v4, + Version? v5, + Version? v6, + Version? v7, + Version? v8]) { var versions = _makeVersionList(v1, v2, v3, v4, v5, v6, v7, v8); return _VersionConstraintMatcher(versions, true); } @@ -93,25 +93,25 @@ Matcher allows(Version v1, /// Gets a [Matcher] that validates that a [VersionConstraint] allows none of /// the given versions. Matcher doesNotAllow(Version v1, - [Version v2, - Version v3, - Version v4, - Version v5, - Version v6, - Version v7, - Version v8]) { + [Version? v2, + Version? v3, + Version? v4, + Version? v5, + Version? v6, + Version? v7, + Version? v8]) { var versions = _makeVersionList(v1, v2, v3, v4, v5, v6, v7, v8); return _VersionConstraintMatcher(versions, false); } List _makeVersionList(Version v1, - [Version v2, - Version v3, - Version v4, - Version v5, - Version v6, - Version v7, - Version v8]) { + [Version? v2, + Version? v3, + Version? v4, + Version? v5, + Version? v6, + Version? v7, + Version? v8]) { var versions = [v1]; if (v2 != null) versions.add(v2); if (v3 != null) versions.add(v3); diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index 70d277975c..6ff4b3e987 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -371,10 +371,7 @@ void main() { }); test('empty', () { - expect( - _primary([]), - isNull, - ); + expect(() => Version.primary([]), throwsStateError); }); }); } From 0adf2fb718ec0d260d746a541633f50ca43f0707 Mon Sep 17 00:00:00 2001 From: Alexander Thomas Date: Thu, 28 Jan 2021 16:23:31 +0100 Subject: [PATCH 064/115] Migrate GitHub Actions (dart-lang/pub_semver#53) --- .../.github/workflows/test-package.yml | 64 +++++++++++++++++++ pkgs/pub_semver/.travis.yml | 17 ----- 2 files changed, 64 insertions(+), 17 deletions(-) create mode 100644 pkgs/pub_semver/.github/workflows/test-package.yml delete mode 100644 pkgs/pub_semver/.travis.yml diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml new file mode 100644 index 0000000000..0a2a874338 --- /dev/null +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -0,0 +1,64 @@ +name: Dart CI + +on: + # Run on PRs and pushes to the default branch. + push: + branches: [ master ] + pull_request: + branches: [ master ] + schedule: + - cron: "0 0 * * 0" + +env: + PUB_ENVIRONMENT: bot.github + +jobs: + # Check code formatting and static analysis on a single OS (linux) + # against Dart dev. + analyze: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + sdk: [dev] + steps: + - uses: actions/checkout@v2 + - uses: dart-lang/setup-dart@v0.3 + with: + sdk: ${{ matrix.sdk }} + - id: install + name: Install dependencies + run: dart pub get + - name: Check formatting + run: dart format --output=none --set-exit-if-changed . + if: always() && steps.install.outcome == 'success' + - name: Analyze code + run: dart analyze --fatal-infos + if: always() && steps.install.outcome == 'success' + + # Run tests on a matrix consisting of two dimensions: + # 1. OS: ubuntu-latest, (macos-latest, windows-latest) + # 2. release channel: dev + test: + needs: analyze + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + # Add macos-latest and/or windows-latest if relevant for this package. + os: [ubuntu-latest] + sdk: [dev] + steps: + - uses: actions/checkout@v2 + - uses: dart-lang/setup-dart@v0.3 + with: + sdk: ${{ matrix.sdk }} + - id: install + name: Install dependencies + run: dart pub get + - name: Run VM tests + run: dart test --platform vm + if: always() && steps.install.outcome == 'success' + - name: Run Chrome tests + run: dart test --platform chrome + if: always() && steps.install.outcome == 'success' diff --git a/pkgs/pub_semver/.travis.yml b/pkgs/pub_semver/.travis.yml deleted file mode 100644 index e40520c4d8..0000000000 --- a/pkgs/pub_semver/.travis.yml +++ /dev/null @@ -1,17 +0,0 @@ -language: dart - -dart: -- dev - -dart_task: -- test: -p vm,chrome -- dart_task: dartfmt -- dartanalyzer: --fatal-infos . - -# Only building master means that we don't run two builds for each pull request. -branches: - only: [master] - -cache: - directories: - - $HOME/.pub-cache From 2d3b5e21dedc7384a1c4307aeef9ffed9b0e01f3 Mon Sep 17 00:00:00 2001 From: Jacob MacDonald Date: Fri, 5 Feb 2021 11:05:55 -0800 Subject: [PATCH 065/115] stable null safety release (dart-lang/pub_semver#54) --- pkgs/pub_semver/CHANGELOG.md | 4 ++++ pkgs/pub_semver/pubspec.yaml | 7 ++----- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 371970723b..5140fe2777 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,7 @@ +# 2.0.0 + +- Stable null safety release. + # 2.0.0-nullsafety.0 - Migrate to null safety. diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index dc2d6ac0c1..f628d38cf5 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 2.0.0-nullsafety.0 +version: 2.0.0 description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. @@ -9,10 +9,7 @@ environment: sdk: '>=2.12.0-0 <3.0.0' dependencies: - collection: ^1.15.0-nullsafety.2 + collection: ^1.15.0 dev_dependencies: test: ^1.16.0-nullsafety.1 - -dependency_overrides: - analyzer: any From 93dc30366a2aefc430d9b1a8313b3a5413a84e04 Mon Sep 17 00:00:00 2001 From: Franklin Yow <58489007+franklinyow@users.noreply.github.com> Date: Wed, 31 Mar 2021 15:56:53 -0700 Subject: [PATCH 066/115] Update LICENSE (dart-lang/pub_semver#55) --- pkgs/pub_semver/LICENSE | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/LICENSE b/pkgs/pub_semver/LICENSE index 5c60afea39..000cd7beca 100644 --- a/pkgs/pub_semver/LICENSE +++ b/pkgs/pub_semver/LICENSE @@ -1,4 +1,5 @@ -Copyright 2014, the Dart project authors. All rights reserved. +Copyright 2014, the Dart project authors. + Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: @@ -9,7 +10,7 @@ met: copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - * Neither the name of Google Inc. nor the names of its + * Neither the name of Google LLC nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. From b885a1ea2d046023b19559602e3a79a5660d3dbc Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Tue, 27 Apr 2021 16:38:44 -0700 Subject: [PATCH 067/115] Fix newly enforced lint (dart-lang/pub_semver#57) --- pkgs/pub_semver/test/utils.dart | 3 +-- pkgs/pub_semver/test/version_constraint_test.dart | 3 +-- pkgs/pub_semver/test/version_range_test.dart | 3 +-- pkgs/pub_semver/test/version_union_test.dart | 3 +-- 4 files changed, 4 insertions(+), 8 deletions(-) diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart index 595415abff..66f103eda7 100644 --- a/pkgs/pub_semver/test/utils.dart +++ b/pkgs/pub_semver/test/utils.dart @@ -2,9 +2,8 @@ // 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. -import 'package:test/test.dart'; - import 'package:pub_semver/pub_semver.dart'; +import 'package:test/test.dart'; /// Some stock example versions to use in tests. final v003 = Version.parse('0.0.3'); diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index c9d8e611bd..1434cfe8eb 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -2,9 +2,8 @@ // 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. -import 'package:test/test.dart'; - import 'package:pub_semver/pub_semver.dart'; +import 'package:test/test.dart'; import 'utils.dart'; diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index 67c7f351be..6e27c3a6f5 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -2,9 +2,8 @@ // 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. -import 'package:test/test.dart'; - import 'package:pub_semver/pub_semver.dart'; +import 'package:test/test.dart'; import 'utils.dart'; diff --git a/pkgs/pub_semver/test/version_union_test.dart b/pkgs/pub_semver/test/version_union_test.dart index 89f9a85534..857f10e87c 100644 --- a/pkgs/pub_semver/test/version_union_test.dart +++ b/pkgs/pub_semver/test/version_union_test.dart @@ -2,9 +2,8 @@ // 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. -import 'package:test/test.dart'; - import 'package:pub_semver/pub_semver.dart'; +import 'package:test/test.dart'; import 'utils.dart'; From 19d8ed4069f10bf1f46a18365a77fef2a85bf8e9 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Tue, 27 Apr 2021 16:40:55 -0700 Subject: [PATCH 068/115] Update CI (dart-lang/pub_semver#58) --- pkgs/pub_semver/.github/workflows/test-package.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 0a2a874338..cdc25d958a 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -23,7 +23,7 @@ jobs: sdk: [dev] steps: - uses: actions/checkout@v2 - - uses: dart-lang/setup-dart@v0.3 + - uses: dart-lang/setup-dart@v1.0 with: sdk: ${{ matrix.sdk }} - id: install @@ -47,10 +47,10 @@ jobs: matrix: # Add macos-latest and/or windows-latest if relevant for this package. os: [ubuntu-latest] - sdk: [dev] + sdk: [2.12.0, dev] steps: - uses: actions/checkout@v2 - - uses: dart-lang/setup-dart@v0.3 + - uses: dart-lang/setup-dart@v1.0 with: sdk: ${{ matrix.sdk }} - id: install From c27d9edc05f5707947a97cb5e3f23ca35d30fc27 Mon Sep 17 00:00:00 2001 From: Konstantin Scheglov Date: Fri, 3 Sep 2021 15:25:21 -0600 Subject: [PATCH 069/115] Fix pre-existing HintCode.UNNECESSARY_TYPE_CHECK_TRUE (dart-lang/pub_semver#60) --- pkgs/pub_semver/test/version_constraint_test.dart | 1 - 1 file changed, 1 deletion(-) diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart index 1434cfe8eb..4fbcbe0cb8 100644 --- a/pkgs/pub_semver/test/version_constraint_test.dart +++ b/pkgs/pub_semver/test/version_constraint_test.dart @@ -36,7 +36,6 @@ void main() { test('parses "any"', () { var constraint = VersionConstraint.parse('any'); - expect(constraint is VersionConstraint, isTrue); expect( constraint, allows(Version.parse('0.0.0'), Version.parse('1.2.3'), From 96dee58f0b60ca3dff64e5f0f047e4b730e86526 Mon Sep 17 00:00:00 2001 From: Jonas Finnemann Jensen Date: Fri, 10 Sep 2021 14:27:49 +0200 Subject: [PATCH 070/115] Annotate `Version` with `@sealed`. (dart-lang/pub_semver#49) --- pkgs/pub_semver/CHANGELOG.md | 4 ++++ pkgs/pub_semver/lib/src/version.dart | 2 ++ pkgs/pub_semver/pubspec.yaml | 3 ++- 3 files changed, 8 insertions(+), 1 deletion(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 5140fe2777..d53b9504c1 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,7 @@ +# 2.0.1-dev +- Annotated `Version` with `@sealed` to discourage users from implementing the + interface. + # 2.0.0 - Stable null safety release. diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 552b498352..73402af384 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -5,6 +5,7 @@ import 'dart:math' as math; import 'package:collection/collection.dart'; +import 'package:meta/meta.dart' show sealed; import 'patterns.dart'; import 'version_constraint.dart'; @@ -14,6 +15,7 @@ import 'version_range.dart'; final _equality = const IterableEquality(); /// A parsed semantic version number. +@sealed class Version implements VersionConstraint, VersionRange { /// No released version: i.e. "0.0.0". static Version get none => Version(0, 0, 0); diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index f628d38cf5..fce9bb0e2d 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 2.0.0 +version: 2.0.1-dev description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. @@ -10,6 +10,7 @@ environment: dependencies: collection: ^1.15.0 + meta: ^1.3.0 dev_dependencies: test: ^1.16.0-nullsafety.1 From 16371057d5eebf097f3d87e1aba4c7f96b7fe7dd Mon Sep 17 00:00:00 2001 From: Jonas Finnemann Jensen Date: Fri, 10 Sep 2021 14:32:44 +0200 Subject: [PATCH 071/115] Add `Version.canonicalizedVersion` to help scrub leading zeros. (dart-lang/pub_semver#50) --- pkgs/pub_semver/CHANGELOG.md | 4 +++- pkgs/pub_semver/lib/src/version.dart | 26 ++++++++++++++++++++++ pkgs/pub_semver/pubspec.yaml | 2 +- pkgs/pub_semver/test/version_test.dart | 30 ++++++++++++++++++++++++++ 4 files changed, 60 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index d53b9504c1..a2d5753ce7 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,4 +1,6 @@ -# 2.0.1-dev +# 2.1.0 +- Added `Version.canonicalizedVersion` to help scrub leading zeros and highlight + that `Version.toString()` preserves leading zeros. - Annotated `Version` with `@sealed` to discourage users from implementing the interface. diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index 73402af384..ba6ce8f789 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -321,9 +321,35 @@ class Version implements VersionConstraint, VersionRange { } } + /// Get non-canonical string representation of this [Version]. + /// + /// If created with [Version.parse], the string from which the version was + /// parsed is returned. Unlike the [canonicalizedVersion] this preserves + /// artifacts such as leading zeros. @override String toString() => _text; + /// Get a canonicalized string representation of this [Version]. + /// + /// Unlike [Version.toString()] this always returns a canonical string + /// representation of this [Version]. + /// + /// **Example** + /// ```dart + /// final v = Version.parse('01.02.03-01.dev+pre.02'); + /// + /// assert(v.toString() == '01.02.03-01.dev+pre.02'); + /// assert(v.canonicalizedVersion == '1.2.3-1.dev+pre.2'); + /// assert(Version.parse(v.canonicalizedVersion) == v); + /// ``` + String get canonicalizedVersion => Version( + major, + minor, + patch, + pre: preRelease.isNotEmpty ? preRelease.join('.') : null, + build: build.isNotEmpty ? build.join('.') : null, + ).toString(); + /// Compares a dot-separated component of two versions. /// /// This is used for the pre-release and build version parts. This follows diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index fce9bb0e2d..214f0cd9c0 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 2.0.1-dev +version: 2.1.0 description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index 6ff4b3e987..467d0b7d49 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -330,6 +330,36 @@ void main() { }); }); + group('canonicalizedVersion', () { + test('returns version string', () { + expect(Version(0, 0, 0).canonicalizedVersion, equals('0.0.0')); + expect(Version(12, 34, 56).canonicalizedVersion, equals('12.34.56')); + + expect(Version(1, 2, 3, pre: 'alpha.1').canonicalizedVersion, + equals('1.2.3-alpha.1')); + expect(Version(1, 2, 3, pre: 'x.7.z-92').canonicalizedVersion, + equals('1.2.3-x.7.z-92')); + + expect(Version(1, 2, 3, build: 'build.1').canonicalizedVersion, + equals('1.2.3+build.1')); + expect(Version(1, 2, 3, pre: 'pre', build: 'bui').canonicalizedVersion, + equals('1.2.3-pre+bui')); + }); + + test('discards leading zeroes', () { + expect(Version.parse('001.02.0003-01.dev+pre.002').canonicalizedVersion, + equals('1.2.3-1.dev+pre.2')); + }); + + test('example from documentation', () { + final v = Version.parse('01.02.03-01.dev+pre.02'); + + assert(v.toString() == '01.02.03-01.dev+pre.02'); + assert(v.canonicalizedVersion == '1.2.3-1.dev+pre.2'); + assert(Version.parse(v.canonicalizedVersion) == v); + }); + }); + group('primary', () { test('single', () { expect( From de5de03b9dbf04db865a8be89e27761296b7a46d Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Sat, 2 Oct 2021 20:57:54 -0700 Subject: [PATCH 072/115] Move to pkg:lints, small tweak to dependency constraints in pubspec (dart-lang/pub_semver#62) Also, dart format --- pkgs/pub_semver/CHANGELOG.md | 2 ++ pkgs/pub_semver/analysis_options.yaml | 2 +- pkgs/pub_semver/lib/src/version_range.dart | 8 ++++++-- pkgs/pub_semver/pubspec.yaml | 7 ++++--- 4 files changed, 13 insertions(+), 6 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index a2d5753ce7..ae26139ca2 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,5 @@ +# 2.1.1-dev + # 2.1.0 - Added `Version.canonicalizedVersion` to help scrub leading zeros and highlight that `Version.toString()` preserves leading zeros. diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml index d73e8049ee..a5aacab9aa 100644 --- a/pkgs/pub_semver/analysis_options.yaml +++ b/pkgs/pub_semver/analysis_options.yaml @@ -1,4 +1,4 @@ -include: package:pedantic/analysis_options.yaml +include: package:lints/recommended.yaml analyzer: strong-mode: diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index a2a63276a9..9431b09bb5 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -432,7 +432,9 @@ class VersionRange implements Comparable, VersionConstraint { final min = this.min; if (min != null) { - buffer..write(includeMin ? '>=' : '>')..write(min); + buffer + ..write(includeMin ? '>=' : '>') + ..write(min); } final max = this.max; @@ -440,7 +442,9 @@ class VersionRange implements Comparable, VersionConstraint { if (max != null) { if (min != null) buffer.write(' '); if (includeMax) { - buffer..write('<=')..write(max); + buffer + ..write('<=') + ..write(max); } else { buffer.write('<'); if (max.isFirstPreRelease) { diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 214f0cd9c0..ca45a9e8fc 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,16 +1,17 @@ name: pub_semver -version: 2.1.0 +version: 2.1.1-dev description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. repository: https://github.com/dart-lang/pub_semver environment: - sdk: '>=2.12.0-0 <3.0.0' + sdk: '>=2.12.0 <3.0.0' dependencies: collection: ^1.15.0 meta: ^1.3.0 dev_dependencies: - test: ^1.16.0-nullsafety.1 + lints: ^1.0.0 + test: ^1.16.0 From 3856eb97e7312d5eb661fd5759c59c31a92ef303 Mon Sep 17 00:00:00 2001 From: Greg Spencer Date: Wed, 10 Nov 2021 09:55:27 -0800 Subject: [PATCH 073/115] Fix RegExp for version pattern (dart-lang/pub_semver#63) Escape the `.` character instead of allowing any character in between the digits. --- pkgs/pub_semver/CHANGELOG.md | 5 ++++- pkgs/pub_semver/lib/src/patterns.dart | 2 +- pkgs/pub_semver/pubspec.yaml | 2 +- pkgs/pub_semver/test/version_test.dart | 1 + 4 files changed, 7 insertions(+), 3 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index ae26139ca2..6f0d45bd2d 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,4 +1,7 @@ -# 2.1.1-dev +# 2.1.1 + +- Fixed the version parsing pattern to only accept dots between version + components. # 2.1.0 - Added `Version.canonicalizedVersion` to help scrub leading zeros and highlight diff --git a/pkgs/pub_semver/lib/src/patterns.dart b/pkgs/pub_semver/lib/src/patterns.dart index d5f1897113..03119acf97 100644 --- a/pkgs/pub_semver/lib/src/patterns.dart +++ b/pkgs/pub_semver/lib/src/patterns.dart @@ -4,7 +4,7 @@ /// Regex that matches a version number at the beginning of a string. final startVersion = RegExp(r'^' // Start at beginning. - r'(\d+).(\d+).(\d+)' // Version number. + r'(\d+)\.(\d+)\.(\d+)' // Version number. r'(-([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?' // Pre-release. r'(\+([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?'); // Build. diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index ca45a9e8fc..99392f5d6d 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 2.1.1-dev +version: 2.1.1 description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index 467d0b7d49..2979706b5f 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -300,6 +300,7 @@ void main() { equals(Version(1, 0, 0, pre: 'rc-1', build: 'build-1'))); expect(() => Version.parse('1.0'), throwsFormatException); + expect(() => Version.parse('1a2b3'), throwsFormatException); expect(() => Version.parse('1.2.3.4'), throwsFormatException); expect(() => Version.parse('1234'), throwsFormatException); expect(() => Version.parse('-2.3.4'), throwsFormatException); From d3190c6843c6fd48a99a35389c30923bbebf672e Mon Sep 17 00:00:00 2001 From: Devon Carew Date: Tue, 1 Mar 2022 10:06:13 -0800 Subject: [PATCH 074/115] Update pubspec.yaml (dart-lang/pub_semver#64) --- pkgs/pub_semver/pubspec.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 99392f5d6d..aa7ab52c8e 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -6,7 +6,7 @@ description: >- repository: https://github.com/dart-lang/pub_semver environment: - sdk: '>=2.12.0 <3.0.0' + sdk: '>=2.12.0 <3.0.0' dependencies: collection: ^1.15.0 From 719d6abbf04696fdf3cae1933fabb4335af9699c Mon Sep 17 00:00:00 2001 From: Devon Carew Date: Mon, 7 Mar 2022 16:15:36 -0800 Subject: [PATCH 075/115] Update README.md (dart-lang/pub_semver#65) --- pkgs/pub_semver/README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pkgs/pub_semver/README.md b/pkgs/pub_semver/README.md index 5e0c36cd85..8282501d6a 100644 --- a/pkgs/pub_semver/README.md +++ b/pkgs/pub_semver/README.md @@ -1,3 +1,6 @@ +[![Dart CI](https://github.com/dart-lang/pub_semver/actions/workflows/test-package.yml/badge.svg)](https://github.com/dart-lang/pub_semver/actions/workflows/test-package.yml) +[![Pub](https://img.shields.io/pub/v/pub_semver.svg)](https://pub.dev/packages/pub_semver) + Handles version numbers and version constraints in the same way that [pub][] does. The semantics here very closely follow the [Semantic Versioning spec version 2.0.0-rc.1][semver]. It differs from semver From 6eab75df7cd02175c73ef9b7643592074f96cd71 Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Mon, 1 Aug 2022 08:56:35 -0700 Subject: [PATCH 076/115] Drop invariant_booleans (dart-lang/pub_semver#67) --- pkgs/pub_semver/analysis_options.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml index a5aacab9aa..2a5cecd36e 100644 --- a/pkgs/pub_semver/analysis_options.yaml +++ b/pkgs/pub_semver/analysis_options.yaml @@ -28,7 +28,6 @@ linter: - file_names - hash_and_equals - implementation_imports - - invariant_booleans - iterable_contains_unrelated_type - join_return_with_assignment - list_remove_unrelated_type From b2f885ff8fe7fa8f695aba40b2f17c4367376121 Mon Sep 17 00:00:00 2001 From: Devon Carew Date: Tue, 4 Oct 2022 09:40:27 -0700 Subject: [PATCH 077/115] update the CI; update readme (dart-lang/pub_semver#69) * update the CI; update readme * fix setup-dart version --- pkgs/pub_semver/.github/dependabot.yaml | 8 ++++++++ pkgs/pub_semver/.github/workflows/test-package.yml | 8 ++++---- pkgs/pub_semver/CHANGELOG.md | 4 ++++ pkgs/pub_semver/README.md | 7 ++++++- pkgs/pub_semver/analysis_options.yaml | 5 +++-- pkgs/pub_semver/lib/src/version_union.dart | 4 ++-- pkgs/pub_semver/pubspec.yaml | 2 +- 7 files changed, 28 insertions(+), 10 deletions(-) create mode 100644 pkgs/pub_semver/.github/dependabot.yaml diff --git a/pkgs/pub_semver/.github/dependabot.yaml b/pkgs/pub_semver/.github/dependabot.yaml new file mode 100644 index 0000000000..214481934b --- /dev/null +++ b/pkgs/pub_semver/.github/dependabot.yaml @@ -0,0 +1,8 @@ +# Dependabot configuration file. +version: 2 + +updates: + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "monthly" diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index cdc25d958a..1f5521683e 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,8 +22,8 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@v2 - - uses: dart-lang/setup-dart@v1.0 + - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b + - uses: dart-lang/setup-dart@6a218f2413a3e78e9087f638a238f6b40893203d with: sdk: ${{ matrix.sdk }} - id: install @@ -49,8 +49,8 @@ jobs: os: [ubuntu-latest] sdk: [2.12.0, dev] steps: - - uses: actions/checkout@v2 - - uses: dart-lang/setup-dart@v1.0 + - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b + - uses: dart-lang/setup-dart@6a218f2413a3e78e9087f638a238f6b40893203d with: sdk: ${{ matrix.sdk }} - id: install diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 6f0d45bd2d..68c2a702ca 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,7 @@ +# 2.1.1-dev + +- Add markdown badges to the readme. + # 2.1.1 - Fixed the version parsing pattern to only accept dots between version diff --git a/pkgs/pub_semver/README.md b/pkgs/pub_semver/README.md index 8282501d6a..ad0740ce0e 100644 --- a/pkgs/pub_semver/README.md +++ b/pkgs/pub_semver/README.md @@ -1,8 +1,13 @@ [![Dart CI](https://github.com/dart-lang/pub_semver/actions/workflows/test-package.yml/badge.svg)](https://github.com/dart-lang/pub_semver/actions/workflows/test-package.yml) [![Pub](https://img.shields.io/pub/v/pub_semver.svg)](https://pub.dev/packages/pub_semver) +[![package publisher](https://img.shields.io/pub/publisher/pub_semver.svg)](https://pub.dev/packages/pub_semver/publisher) Handles version numbers and version constraints in the same way that [pub][] -does. The semantics here very closely follow the +does. + +## Semantics + +The semantics here very closely follow the [Semantic Versioning spec version 2.0.0-rc.1][semver]. It differs from semver in a few corner cases: diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml index 2a5cecd36e..0569680723 100644 --- a/pkgs/pub_semver/analysis_options.yaml +++ b/pkgs/pub_semver/analysis_options.yaml @@ -1,8 +1,9 @@ include: package:lints/recommended.yaml analyzer: - strong-mode: - implicit-casts: false + language: + strict-casts: true + strict-inference: true linter: rules: diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index 24b82f4cc8..69ae03413b 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -214,10 +214,10 @@ class VersionUnion implements VersionConstraint { @override bool operator ==(Object other) => other is VersionUnion && - const ListEquality().equals(ranges, other.ranges); + const ListEquality().equals(ranges, other.ranges); @override - int get hashCode => const ListEquality().hash(ranges); + int get hashCode => const ListEquality().hash(ranges); @override String toString() => ranges.join(' or '); diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index aa7ab52c8e..aa60fdff61 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 2.1.1 +version: 2.1.2-dev description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. From 3e69e5a83c6d2a52736e1e6d96d66ecfb4d2f3ea Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 4 Oct 2022 09:56:22 -0700 Subject: [PATCH 078/115] Bump actions/checkout from 3.0.2 to 3.1.0 (dart-lang/pub_semver#70) Bumps [actions/checkout](https://github.com/actions/checkout) from 3.0.2 to 3.1.0. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/2541b1294d2704b0964813337f33b291d3f8596b...93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 1f5521683e..68f255c741 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b + - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 - uses: dart-lang/setup-dart@6a218f2413a3e78e9087f638a238f6b40893203d with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [2.12.0, dev] steps: - - uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b + - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 - uses: dart-lang/setup-dart@6a218f2413a3e78e9087f638a238f6b40893203d with: sdk: ${{ matrix.sdk }} From 30eceda0feb980020c4cac482c91b021b31cd326 Mon Sep 17 00:00:00 2001 From: Michael Thomsen Date: Thu, 6 Oct 2022 12:54:31 +0200 Subject: [PATCH 079/115] Refactor away from deprecated error (dart-lang/pub_semver#72) * Refactor away from deprecated error `FallThroughError` is deprecated, and scheduled for removal in 3.0 * Update version_constraint.dart --- pkgs/pub_semver/lib/src/version_constraint.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 6eb6c3a295..50d7c77993 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -93,7 +93,7 @@ abstract class VersionConstraint { case '>': return VersionRange(min: version, includeMin: false); } - throw FallThroughError(); + throw UnsupportedError(op!); } // Try to parse the "^" operator followed by a version. From d3770d868327dbee96909037b071a4d1486853dc Mon Sep 17 00:00:00 2001 From: Devon Carew Date: Fri, 14 Oct 2022 17:54:30 +0000 Subject: [PATCH 080/115] prep for publishing (dart-lang/pub_semver#73) --- pkgs/pub_semver/CHANGELOG.md | 2 +- pkgs/pub_semver/pubspec.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 68c2a702ca..b0346329f0 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,4 +1,4 @@ -# 2.1.1-dev +# 2.1.2 - Add markdown badges to the readme. diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index aa60fdff61..623606faf7 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 2.1.2-dev +version: 2.1.2 description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. From e9949575add8301db15880ad60d43c36b1dfb79a Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Mon, 7 Nov 2022 09:53:02 -0800 Subject: [PATCH 081/115] update and fix lints, bump min SDK (dart-lang/pub_semver#74) --- .../.github/workflows/test-package.yml | 2 +- pkgs/pub_semver/CHANGELOG.md | 8 +-- pkgs/pub_semver/analysis_options.yaml | 51 +++++++++---------- pkgs/pub_semver/lib/src/version.dart | 23 +++++---- .../lib/src/version_constraint.dart | 7 +-- pkgs/pub_semver/lib/src/version_range.dart | 6 +-- pkgs/pub_semver/lib/src/version_union.dart | 4 +- pkgs/pub_semver/pubspec.yaml | 6 +-- pkgs/pub_semver/test/utils.dart | 6 +-- pkgs/pub_semver/test/version_range_test.dart | 5 +- pkgs/pub_semver/test/version_test.dart | 2 +- 11 files changed, 55 insertions(+), 65 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 68f255c741..5c5b39d11c 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -47,7 +47,7 @@ jobs: matrix: # Add macos-latest and/or windows-latest if relevant for this package. os: [ubuntu-latest] - sdk: [2.12.0, dev] + sdk: [2.17.0, dev] steps: - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 - uses: dart-lang/setup-dart@6a218f2413a3e78e9087f638a238f6b40893203d diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index b0346329f0..e23ce1030a 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,7 @@ +# 2.1.3-dev + +- Require Dart 2.17. + # 2.1.2 - Add markdown badges to the readme. @@ -16,10 +20,6 @@ # 2.0.0 - Stable null safety release. - -# 2.0.0-nullsafety.0 - -- Migrate to null safety. - `Version.primary` now throws `StateError` if the `versions` argument is empty. # 1.4.4 diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml index 0569680723..56d7c9061c 100644 --- a/pkgs/pub_semver/analysis_options.yaml +++ b/pkgs/pub_semver/analysis_options.yaml @@ -1,58 +1,55 @@ +# https://dart.dev/guides/language/analysis-options include: package:lints/recommended.yaml analyzer: language: strict-casts: true strict-inference: true + strict-raw-types: true linter: rules: + - always_declare_return_types - avoid_bool_literals_in_conditional_expressions + - avoid_catching_errors - avoid_classes_with_only_static_members - - avoid_function_literals_in_foreach_calls - - avoid_renaming_method_parameters + - avoid_dynamic_calls + - avoid_private_typedef_functions + - avoid_redundant_argument_values - avoid_returning_null - avoid_returning_null_for_future - - avoid_returning_null_for_void - avoid_returning_this - - avoid_single_cascade_in_expression_statements - avoid_unused_constructor_parameters - - await_only_futures - - camel_case_types + - avoid_void_async - cancel_subscriptions - cascade_invocations - comment_references - - constant_identifier_names - - control_flow_in_finally - directives_ordering - - empty_statements - - file_names - - hash_and_equals - - implementation_imports - - iterable_contains_unrelated_type - join_return_with_assignment - - list_remove_unrelated_type + - lines_longer_than_80_chars - literal_only_boolean_expressions + - missing_whitespace_between_adjacent_strings - no_adjacent_strings_in_list - - non_constant_identifier_names + - no_runtimeType_toString + - omit_local_variable_types - only_throw_errors - - overridden_fields - package_api_docs - - package_names - - package_prefixed_library_names + - prefer_asserts_in_initializer_lists - prefer_const_constructors - #- prefer_final_locals - - prefer_initializing_formals - - prefer_interpolation_to_compose_strings - - prefer_null_aware_operators - - prefer_typing_uninitialized_variables + - prefer_const_declarations + - prefer_expression_function_bodies + - prefer_relative_imports + - prefer_single_quotes + - sort_pub_dependencies - test_types_in_equals - throw_in_finally + - type_annotate_public_apis + - unawaited_futures - unnecessary_await_in_return - - unnecessary_brace_in_string_interps - - unnecessary_getters_setters - unnecessary_lambdas - - unnecessary_null_aware_assignments - unnecessary_parenthesis - unnecessary_statements - - void_checks + - use_if_null_to_convert_nulls_to_bools + - use_raw_strings + - use_string_buffers + - use_super_parameters diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index ba6ce8f789..f9e5360870 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -12,7 +12,7 @@ import 'version_constraint.dart'; import 'version_range.dart'; /// The equality operator to use for comparing version components. -final _equality = const IterableEquality(); +const _equality = IterableEquality(); /// A parsed semantic version number. @sealed @@ -70,14 +70,14 @@ class Version implements VersionConstraint, VersionRange { /// This is split into a list of components, each of which may be either a /// string or a non-negative integer. It may also be empty, indicating that /// this version has no pre-release identifier. - final List preRelease; + final List preRelease; /// The build identifier: "foo" in "1.2.3+foo". /// /// This is split into a list of components, each of which may be either a /// string or a non-negative integer. It may also be empty, indicating that /// this version has no build identifier. - final List build; + final List build; /// The original string representation of the version number. /// @@ -96,7 +96,7 @@ class Version implements VersionConstraint, VersionRange { Version._(this.major, this.minor, this.patch, String? preRelease, String? build, this._text) - : preRelease = preRelease == null ? [] : _splitParts(preRelease), + : preRelease = preRelease == null ? [] : _splitParts(preRelease), build = build == null ? [] : _splitParts(build) { if (major < 0) throw ArgumentError('Major version must be non-negative.'); if (minor < 0) throw ArgumentError('Minor version must be non-negative.'); @@ -154,12 +154,13 @@ class Version implements VersionConstraint, VersionRange { /// Splits a string of dot-delimited identifiers into their component parts. /// /// Identifiers that are numeric are converted to numbers. - static List _splitParts(String text) { - return text.split('.').map((part) { - // Return an integer part if possible, otherwise return the string as-is - return int.tryParse(part) ?? part; - }).toList(); - } + static List _splitParts(String text) => text + .split('.') + .map((part) => + // Return an integer part if possible, otherwise return the string + // as-is + int.tryParse(part) ?? part) + .toList(); @override bool operator ==(Object other) => @@ -354,7 +355,7 @@ class Version implements VersionConstraint, VersionRange { /// /// 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) { + int _compareLists(List a, List b) { 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; diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 50d7c77993..3bde4911b0 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -84,14 +84,11 @@ abstract class VersionConstraint { case '<=': return VersionRange(max: version, includeMax: true); case '<': - return VersionRange( - max: version, - includeMax: false, - alwaysIncludeMaxPreRelease: true); + return VersionRange(max: version, alwaysIncludeMaxPreRelease: true); case '>=': return VersionRange(min: version, includeMin: true); case '>': - return VersionRange(min: version, includeMin: false); + return VersionRange(min: version); } throw UnsupportedError(op!); } diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart index 9431b09bb5..6f2ed54b01 100644 --- a/pkgs/pub_semver/lib/src/version_range.dart +++ b/pkgs/pub_semver/lib/src/version_range.dart @@ -85,7 +85,7 @@ class VersionRange implements Comparable, VersionConstraint { VersionRange._(this.min, this.max, this.includeMin, this.includeMax); @override - bool operator ==(other) { + bool operator ==(Object other) { if (other is! VersionRange) return false; return min == other.min && @@ -294,7 +294,6 @@ class VersionRange implements Comparable, VersionConstraint { return VersionRange( min: min, max: max, - includeMin: false, includeMax: includeMax, alwaysIncludeMaxPreRelease: true); } @@ -305,7 +304,6 @@ class VersionRange implements Comparable, VersionConstraint { min: min, max: max, includeMin: includeMin, - includeMax: false, alwaysIncludeMaxPreRelease: true); } @@ -314,12 +312,10 @@ class VersionRange implements Comparable, VersionConstraint { min: min, max: other, includeMin: includeMin, - includeMax: false, alwaysIncludeMaxPreRelease: true), VersionRange( min: other, max: max, - includeMin: false, includeMax: includeMax, alwaysIncludeMaxPreRelease: true) ]); diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart index 69ae03413b..844d3b8eff 100644 --- a/pkgs/pub_semver/lib/src/version_union.dart +++ b/pkgs/pub_semver/lib/src/version_union.dart @@ -35,8 +35,8 @@ class VersionUnion implements VersionConstraint { /// /// It's up to the caller to ensure that the invariants described in [ranges] /// are maintained. They are not verified by this constructor. To - /// automatically ensure that they're maintained, use [new - /// VersionConstraint.unionOf] instead. + /// automatically ensure that they're maintained, use + /// [VersionConstraint.unionOf] instead. VersionUnion.fromRanges(this.ranges); @override diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 623606faf7..bac8775730 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,17 +1,17 @@ name: pub_semver -version: 2.1.2 +version: 2.1.3-dev description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. repository: https://github.com/dart-lang/pub_semver environment: - sdk: '>=2.12.0 <3.0.0' + sdk: '>=2.17.0 <3.0.0' dependencies: collection: ^1.15.0 meta: ^1.3.0 dev_dependencies: - lints: ^1.0.0 + lints: ^2.0.0 test: ^1.16.0 diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart index 66f103eda7..bd7aa8f8f0 100644 --- a/pkgs/pub_semver/test/utils.dart +++ b/pkgs/pub_semver/test/utils.dart @@ -34,7 +34,7 @@ class _VersionConstraintMatcher implements Matcher { _VersionConstraintMatcher(this._expected, this._allow); @override - bool matches(item, Map matchState) => + bool matches(dynamic item, Map matchState) => (item is VersionConstraint) && _expected.every((version) => item.allows(version) == _allow); @@ -46,8 +46,8 @@ class _VersionConstraintMatcher implements Matcher { } @override - Description describeMismatch( - item, Description mismatchDescription, Map matchState, bool verbose) { + Description describeMismatch(dynamic item, Description mismatchDescription, + Map matchState, bool verbose) { if (item is! VersionConstraint) { mismatchDescription.add('was not a VersionConstraint'); return mismatchDescription; diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart index 6e27c3a6f5..5978df0c78 100644 --- a/pkgs/pub_semver/test/version_range_test.dart +++ b/pkgs/pub_semver/test/version_range_test.dart @@ -961,12 +961,11 @@ void main() { test('includeMin comes before !includeMin', () { _expectComparesSmaller( VersionRange(min: v003, max: v080, includeMin: true), - VersionRange(min: v003, max: v080, includeMin: false)); + VersionRange(min: v003, max: v080)); }); test('includeMax comes after !includeMax', () { - _expectComparesSmaller( - VersionRange(min: v003, max: v080, includeMax: false), + _expectComparesSmaller(VersionRange(min: v003, max: v080), VersionRange(min: v003, max: v080, includeMax: true)); }); diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart index 2979706b5f..d7f1197c8a 100644 --- a/pkgs/pub_semver/test/version_test.dart +++ b/pkgs/pub_semver/test/version_test.dart @@ -408,4 +408,4 @@ void main() { } Version _primary(List input) => - Version.primary(input.map((e) => Version.parse(e)).toList()); + Version.primary(input.map(Version.parse).toList()); From 9c7bb2019aff54ae452b2da8c5b809e4faf4cc51 Mon Sep 17 00:00:00 2001 From: Devon Carew Date: Fri, 11 Nov 2022 16:18:49 -0800 Subject: [PATCH 082/115] rev to 2.1.3 in preparation for release (dart-lang/pub_semver#75) * rev to 2.1.3 in preparation for release * Update CHANGELOG.md Co-authored-by: Kevin Moore Co-authored-by: Kevin Moore --- pkgs/pub_semver/CHANGELOG.md | 5 ++++- pkgs/pub_semver/pubspec.yaml | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index e23ce1030a..8c394e3468 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,5 +1,8 @@ -# 2.1.3-dev +# 2.1.3 +- Add type parameters to the signatures of the `Version.preRelease` and + `Version.build` fields (`List` ==> `List`). + [#74](https://github.com/dart-lang/pub_semver/pull/74). - Require Dart 2.17. # 2.1.2 diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index bac8775730..e7906a70bb 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 2.1.3-dev +version: 2.1.3 description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. From e6420799abadd1bc3d9a6638480aca4fd09adf7c Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 3 Jan 2023 10:12:16 -0800 Subject: [PATCH 083/115] Bump actions/checkout from 3.1.0 to 3.2.0 (dart-lang/pub_semver#76) Bumps [actions/checkout](https://github.com/actions/checkout) from 3.1.0 to 3.2.0. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8...755da8c3cf115ac066823e79a1e1788f8940201b) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 5c5b39d11c..70142f9e56 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 + - uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b - uses: dart-lang/setup-dart@6a218f2413a3e78e9087f638a238f6b40893203d with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [2.17.0, dev] steps: - - uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 + - uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b - uses: dart-lang/setup-dart@6a218f2413a3e78e9087f638a238f6b40893203d with: sdk: ${{ matrix.sdk }} From 8e570cac2c4575ddce001ba6d0eeb3452c2e8a92 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 1 Feb 2023 08:07:47 -0800 Subject: [PATCH 084/115] Bump dart-lang/setup-dart from 1.3 to 1.4 (dart-lang/pub_semver#79) Bumps [dart-lang/setup-dart](https://github.com/dart-lang/setup-dart) from 1.3 to 1.4. - [Release notes](https://github.com/dart-lang/setup-dart/releases) - [Changelog](https://github.com/dart-lang/setup-dart/blob/main/CHANGELOG.md) - [Commits](https://github.com/dart-lang/setup-dart/compare/6a218f2413a3e78e9087f638a238f6b40893203d...a57a6c04cf7d4840e88432aad6281d1e125f0d46) --- updated-dependencies: - dependency-name: dart-lang/setup-dart dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 70142f9e56..e0871c5aae 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -23,7 +23,7 @@ jobs: sdk: [dev] steps: - uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b - - uses: dart-lang/setup-dart@6a218f2413a3e78e9087f638a238f6b40893203d + - uses: dart-lang/setup-dart@a57a6c04cf7d4840e88432aad6281d1e125f0d46 with: sdk: ${{ matrix.sdk }} - id: install @@ -50,7 +50,7 @@ jobs: sdk: [2.17.0, dev] steps: - uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b - - uses: dart-lang/setup-dart@6a218f2413a3e78e9087f638a238f6b40893203d + - uses: dart-lang/setup-dart@a57a6c04cf7d4840e88432aad6281d1e125f0d46 with: sdk: ${{ matrix.sdk }} - id: install From 1fd7a318bb0279afbf247048e0de9a04f9feaa76 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 1 Feb 2023 08:33:54 -0800 Subject: [PATCH 085/115] Bump actions/checkout from 3.2.0 to 3.3.0 (dart-lang/pub_semver#78) Bumps [actions/checkout](https://github.com/actions/checkout) from 3.2.0 to 3.3.0. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/755da8c3cf115ac066823e79a1e1788f8940201b...ac593985615ec2ede58e132d2e21d2b1cbd6127c) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index e0871c5aae..5a3d9cfe1a 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b + - uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c - uses: dart-lang/setup-dart@a57a6c04cf7d4840e88432aad6281d1e125f0d46 with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [2.17.0, dev] steps: - - uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b + - uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c - uses: dart-lang/setup-dart@a57a6c04cf7d4840e88432aad6281d1e125f0d46 with: sdk: ${{ matrix.sdk }} From 10e2a107dc320a25301f2108109a57b11819546d Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Sun, 12 Feb 2023 17:07:35 -0800 Subject: [PATCH 086/115] Fix new type error, use dart_flutter_team_lints (dart-lang/pub_semver#80) --- pkgs/pub_semver/analysis_options.yaml | 18 +----------------- pkgs/pub_semver/lib/src/version.dart | 2 +- pkgs/pub_semver/pubspec.yaml | 4 ++-- 3 files changed, 4 insertions(+), 20 deletions(-) diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml index 56d7c9061c..210af85b9d 100644 --- a/pkgs/pub_semver/analysis_options.yaml +++ b/pkgs/pub_semver/analysis_options.yaml @@ -1,5 +1,5 @@ # https://dart.dev/guides/language/analysis-options -include: package:lints/recommended.yaml +include: package:dart_flutter_team_lints/analysis_options.yaml analyzer: language: @@ -9,11 +9,8 @@ analyzer: linter: rules: - - always_declare_return_types - avoid_bool_literals_in_conditional_expressions - - avoid_catching_errors - avoid_classes_with_only_static_members - - avoid_dynamic_calls - avoid_private_typedef_functions - avoid_redundant_argument_values - avoid_returning_null @@ -24,31 +21,18 @@ linter: - cancel_subscriptions - cascade_invocations - comment_references - - directives_ordering - join_return_with_assignment - - lines_longer_than_80_chars - literal_only_boolean_expressions - missing_whitespace_between_adjacent_strings - no_adjacent_strings_in_list - no_runtimeType_toString - - omit_local_variable_types - - only_throw_errors - package_api_docs - - prefer_asserts_in_initializer_lists - prefer_const_constructors - prefer_const_declarations - prefer_expression_function_bodies - prefer_relative_imports - - prefer_single_quotes - - sort_pub_dependencies - test_types_in_equals - - throw_in_finally - - type_annotate_public_apis - - unawaited_futures - unnecessary_await_in_return - - unnecessary_lambdas - - unnecessary_parenthesis - - unnecessary_statements - use_if_null_to_convert_nulls_to_bools - use_raw_strings - use_string_buffers diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart index f9e5360870..90f3d535fd 100644 --- a/pkgs/pub_semver/lib/src/version.dart +++ b/pkgs/pub_semver/lib/src/version.dart @@ -12,7 +12,7 @@ import 'version_constraint.dart'; import 'version_range.dart'; /// The equality operator to use for comparing version components. -const _equality = IterableEquality(); +const _equality = IterableEquality(); /// A parsed semantic version number. @sealed diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index e7906a70bb..990cf8ecab 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 2.1.3 +version: 2.1.4-dev description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. @@ -13,5 +13,5 @@ dependencies: meta: ^1.3.0 dev_dependencies: - lints: ^2.0.0 + dart_flutter_team_lints: ^0.1.0 test: ^1.16.0 From 6c18c52be0c153b82831a6e9e2931ab103061b8d Mon Sep 17 00:00:00 2001 From: Devon Carew Date: Sun, 12 Feb 2023 17:16:27 -0800 Subject: [PATCH 087/115] Update CHANGELOG.md (dart-lang/pub_semver#81) --- pkgs/pub_semver/CHANGELOG.md | 51 +++++++++++++++++++----------------- 1 file changed, 27 insertions(+), 24 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 8c394e3468..057895a90e 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,31 +1,34 @@ -# 2.1.3 +## 2.1.4-dev + +## 2.1.3 - Add type parameters to the signatures of the `Version.preRelease` and `Version.build` fields (`List` ==> `List`). [#74](https://github.com/dart-lang/pub_semver/pull/74). - Require Dart 2.17. -# 2.1.2 +## 2.1.2 - Add markdown badges to the readme. -# 2.1.1 +## 2.1.1 - Fixed the version parsing pattern to only accept dots between version components. -# 2.1.0 +## 2.1.0 + - Added `Version.canonicalizedVersion` to help scrub leading zeros and highlight that `Version.toString()` preserves leading zeros. - Annotated `Version` with `@sealed` to discourage users from implementing the interface. -# 2.0.0 +## 2.0.0 - Stable null safety release. - `Version.primary` now throws `StateError` if the `versions` argument is empty. -# 1.4.4 +## 1.4.4 - Fix a bug of `VersionRange.union` where ranges bounded at infinity would get combined wrongly. @@ -35,16 +38,16 @@ - Update Dart SDK constraint to `>=2.0.0 <3.0.0`. - Update `package:collection` constraint to `^1.0.0`. -# 1.4.2 +## 1.4.2 * Set max SDK version to `<3.0.0`. -# 1.4.1 +## 1.4.1 * Fix a bug where there upper bound of a version range with a build identifier could accidentally be rewritten. -# 1.4.0 +## 1.4.0 * Add a `Version.firstPreRelease` getter that returns the first possible pre-release of a version. @@ -66,41 +69,41 @@ disables the replacement described above and allows users to create ranges that do include the pre-release versions of an exclusive max version. -# 1.3.7 +## 1.3.7 * Fix more bugs with `VersionRange.intersect()`, `VersionRange.difference()`, and `VersionRange.union()` involving version ranges with pre-release maximums. -# 1.3.6 +## 1.3.6 * Fix a bug where constraints that only allowed pre-release versions would be parsed as empty constraints. -# 1.3.5 +## 1.3.5 * Fix a bug where `VersionRange.intersect()` would return incorrect results for pre-release versions with the same base version number as release versions. -# 1.3.4 +## 1.3.4 * Fix a bug where `VersionRange.allowsAll()`, `VersionRange.allowsAny()`, and `VersionRange.difference()` would return incorrect results for pre-release versions with the same base version number as release versions. -# 1.3.3 +## 1.3.3 * Fix a bug where `VersionRange.difference()` with a union constraint that covered the entire range would crash. -# 1.3.2 +## 1.3.2 * Fix a checked-mode error in `VersionRange.difference()`. -# 1.3.1 +## 1.3.1 * Fix a new strong mode error. -# 1.3.0 +## 1.3.0 * Make the `VersionUnion` class public. This was previously used internally to implement `new VersionConstraint.unionOf()` and `VersionConstraint.union()`. @@ -112,21 +115,21 @@ * Make `VersionRange` implement `Comparable`. Ranges are ordered first by lower bound, then by upper bound. -# 1.2.4 +## 1.2.4 * Fix all remaining strong mode warnings. -# 1.2.3 +## 1.2.3 * Addressed three strong mode warnings. -# 1.2.2 +## 1.2.2 * Make the package analyze under strong mode and compile with the DDC (Dart Dev Compiler). Fix two issues with a private subclass of `VersionConstraint` having different types for overridden methods. -# 1.2.1 +## 1.2.1 * Allow version ranges like `>=1.2.3-dev.1 <1.2.3` to match pre-release versions of `1.2.3`. Previously, these didn't match, since the pre-release versions had @@ -134,7 +137,7 @@ added if they also have the same major, minor, and patch numbers as the min *and* the min is also a pre-release version. -# 1.2.0 +## 1.2.0 * Add a `VersionConstraint.union()` method and a `new VersionConstraint.unionOf()` constructor. These each return a constraint that @@ -148,7 +151,7 @@ * `Version` now implements `VersionRange`. -# 1.1.0 +## 1.1.0 * Add support for the `^` operator for compatible versions according to pub's notion of compatibility. `^1.2.3` is equivalent to `>=1.2.3 <2.0.0`; `^0.1.2` @@ -162,6 +165,6 @@ * Add a custom `VersionRange.hashCode` to make it properly hashable. -# 1.0.0 +## 1.0.0 * Initial release. From e658a4052df7d9b8b3976efff8d0c879d49430b0 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 3 Apr 2023 15:33:00 -0700 Subject: [PATCH 088/115] Bump actions/checkout from 3.3.0 to 3.5.0 (dart-lang/pub_semver#83) Bumps [actions/checkout](https://github.com/actions/checkout) from 3.3.0 to 3.5.0. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/ac593985615ec2ede58e132d2e21d2b1cbd6127c...8f4b7f84864484a7bf31766abe9204da3cbe65b3) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 5a3d9cfe1a..c337221712 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c + - uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 - uses: dart-lang/setup-dart@a57a6c04cf7d4840e88432aad6281d1e125f0d46 with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [2.17.0, dev] steps: - - uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c + - uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 - uses: dart-lang/setup-dart@a57a6c04cf7d4840e88432aad6281d1e125f0d46 with: sdk: ${{ matrix.sdk }} From b6822a17b839f80d9c655d023177675f6500a519 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 3 Apr 2023 15:55:25 -0700 Subject: [PATCH 089/115] Bump dart-lang/setup-dart from 1.4.0 to 1.5.0 (dart-lang/pub_semver#82) Bumps [dart-lang/setup-dart](https://github.com/dart-lang/setup-dart) from 1.4.0 to 1.5.0. - [Release notes](https://github.com/dart-lang/setup-dart/releases) - [Changelog](https://github.com/dart-lang/setup-dart/blob/main/CHANGELOG.md) - [Commits](https://github.com/dart-lang/setup-dart/compare/a57a6c04cf7d4840e88432aad6281d1e125f0d46...d6a63dab3335f427404425de0fbfed4686d93c4f) --- updated-dependencies: - dependency-name: dart-lang/setup-dart dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index c337221712..35a98b0c1d 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -23,7 +23,7 @@ jobs: sdk: [dev] steps: - uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 - - uses: dart-lang/setup-dart@a57a6c04cf7d4840e88432aad6281d1e125f0d46 + - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f with: sdk: ${{ matrix.sdk }} - id: install @@ -50,7 +50,7 @@ jobs: sdk: [2.17.0, dev] steps: - uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 - - uses: dart-lang/setup-dart@a57a6c04cf7d4840e88432aad6281d1e125f0d46 + - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f with: sdk: ${{ matrix.sdk }} - id: install From 269838e6f53a4fe58e7603ad89fc0701ac84f098 Mon Sep 17 00:00:00 2001 From: Jonas Finnemann Jensen Date: Thu, 4 May 2023 14:33:15 +0200 Subject: [PATCH 090/115] Prepare release with topics (dart-lang/pub_semver#86) --- pkgs/pub_semver/CHANGELOG.md | 4 +++- pkgs/pub_semver/pubspec.yaml | 5 ++++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 057895a90e..e5db489520 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,4 +1,6 @@ -## 2.1.4-dev +## 2.1.4 + +- Added topics to `pubspec.yaml`. ## 2.1.3 diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 990cf8ecab..219e996555 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,9 +1,12 @@ name: pub_semver -version: 2.1.4-dev +version: 2.1.4 description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. repository: https://github.com/dart-lang/pub_semver +topics: + - dart-pub + - semver environment: sdk: '>=2.17.0 <3.0.0' From dde204efa4281fc2253ce055683bb6fda8378996 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 8 May 2023 12:24:18 -0700 Subject: [PATCH 091/115] Bump actions/checkout from 3.5.0 to 3.5.2 (dart-lang/pub_semver#85) Bumps [actions/checkout](https://github.com/actions/checkout) from 3.5.0 to 3.5.2. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/8f4b7f84864484a7bf31766abe9204da3cbe65b3...8e5e7e5ab8b370d6c329ec480221332ada57f0ab) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 35a98b0c1d..4bad718a01 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 + - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [2.17.0, dev] steps: - - uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 + - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f with: sdk: ${{ matrix.sdk }} From c88be35329e7f12d5645c245b38149fd8b3a75ff Mon Sep 17 00:00:00 2001 From: Devon Carew Date: Mon, 22 May 2023 09:20:23 -0700 Subject: [PATCH 092/115] blast_repo fixes (dart-lang/pub_semver#87) dependabot --- pkgs/pub_semver/.github/dependabot.yaml | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/pkgs/pub_semver/.github/dependabot.yaml b/pkgs/pub_semver/.github/dependabot.yaml index 214481934b..439e796b48 100644 --- a/pkgs/pub_semver/.github/dependabot.yaml +++ b/pkgs/pub_semver/.github/dependabot.yaml @@ -2,7 +2,9 @@ version: 2 updates: - - package-ecosystem: "github-actions" - directory: "/" + - package-ecosystem: github-actions + directory: / schedule: - interval: "monthly" + interval: monthly + labels: + - autosubmit From 6257e94c9650af5f1f66a5664a70e71afae28cce Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Wed, 31 May 2023 13:29:08 -0700 Subject: [PATCH 093/115] Bump lints, require Dart 3.0 (dart-lang/pub_semver#89) --- .../.github/workflows/test-package.yml | 2 +- pkgs/pub_semver/CHANGELOG.md | 4 ++++ .../lib/src/version_constraint.dart | 20 ++++++++----------- pkgs/pub_semver/pubspec.yaml | 6 +++--- 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 4bad718a01..6e9fc3911c 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -47,7 +47,7 @@ jobs: matrix: # Add macos-latest and/or windows-latest if relevant for this package. os: [ubuntu-latest] - sdk: [2.17.0, dev] + sdk: [3.0.0, dev] steps: - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index e5db489520..33899354f8 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,3 +1,7 @@ +## 2.1.5-wip + +- Require Dart `3.0.0`. + ## 2.1.4 - Added topics to `pubspec.yaml`. diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart index 3bde4911b0..948118ef3b 100644 --- a/pkgs/pub_semver/lib/src/version_constraint.dart +++ b/pkgs/pub_semver/lib/src/version_constraint.dart @@ -70,7 +70,7 @@ abstract class VersionConstraint { var comparison = startComparison.firstMatch(text); if (comparison == null) return null; - var op = comparison[0]; + var op = comparison[0]!; text = text.substring(comparison.end); skipWhitespace(); @@ -80,17 +80,13 @@ abstract class VersionConstraint { '"$originalText", got "$text".'); } - switch (op) { - case '<=': - return VersionRange(max: version, includeMax: true); - case '<': - return VersionRange(max: version, alwaysIncludeMaxPreRelease: true); - case '>=': - return VersionRange(min: version, includeMin: true); - case '>': - return VersionRange(min: version); - } - throw UnsupportedError(op!); + return switch (op) { + '<=' => VersionRange(max: version, includeMax: true), + '<' => VersionRange(max: version, alwaysIncludeMaxPreRelease: true), + '>=' => VersionRange(min: version, includeMin: true), + '>' => VersionRange(min: version), + _ => throw UnsupportedError(op), + }; } // Try to parse the "^" operator followed by a version. diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 219e996555..72ffdfe287 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 2.1.4 +version: 2.1.5-wip description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. @@ -9,12 +9,12 @@ topics: - semver environment: - sdk: '>=2.17.0 <3.0.0' + sdk: ^3.0.0 dependencies: collection: ^1.15.0 meta: ^1.3.0 dev_dependencies: - dart_flutter_team_lints: ^0.1.0 + dart_flutter_team_lints: ^1.0.0 test: ^1.16.0 From b2fcb7e4af3368c381af56986c35db3b1143cade Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sat, 1 Jul 2023 16:09:12 +0000 Subject: [PATCH 094/115] Bump actions/checkout from 3.5.2 to 3.5.3 (dart-lang/pub_semver#90) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [actions/checkout](https://github.com/actions/checkout) from 3.5.2 to 3.5.3.
Release notes

Sourced from actions/checkout's releases.

v3.5.3

What's Changed

New Contributors

Full Changelog: https://github.com/actions/checkout/compare/v3...v3.5.3

Changelog

Sourced from actions/checkout's changelog.

Changelog

v3.5.3

v3.5.2

v3.5.1

v3.5.0

v3.4.0

v3.3.0

v3.2.0

v3.1.0

v3.0.2

v3.0.1

v3.0.0

v2.3.1

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/checkout&package-manager=github_actions&previous-version=3.5.2&new-version=3.5.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 6e9fc3911c..7ad5f74e00 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab + - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [3.0.0, dev] steps: - - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab + - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f with: sdk: ${{ matrix.sdk }} From ac53d454e8f834872e6c6d5ce271d2a6187b13f5 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 1 Sep 2023 16:58:45 +0000 Subject: [PATCH 095/115] Bump actions/checkout from 3.5.3 to 3.6.0 (dart-lang/pub_semver#91) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [actions/checkout](https://github.com/actions/checkout) from 3.5.3 to 3.6.0.
Release notes

Sourced from actions/checkout's releases.

v3.6.0

What's Changed

New Contributors

Full Changelog: https://github.com/actions/checkout/compare/v3.5.3...v3.6.0

Changelog

Sourced from actions/checkout's changelog.

Changelog

v3.6.0

v3.5.3

v3.5.2

v3.5.1

v3.5.0

v3.4.0

v3.3.0

v3.2.0

v3.1.0

v3.0.2

v3.0.1

v3.0.0

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/checkout&package-manager=github_actions&previous-version=3.5.3&new-version=3.6.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 7ad5f74e00..24d44c9ac1 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 + - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [3.0.0, dev] steps: - - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 + - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f with: sdk: ${{ matrix.sdk }} From fd5db62e368e79da2e597d085a0b99dc86d2640d Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sun, 1 Oct 2023 16:41:17 +0000 Subject: [PATCH 096/115] Bump actions/checkout from 3.6.0 to 4.1.0 (dart-lang/pub_semver#92) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [actions/checkout](https://github.com/actions/checkout) from 3.6.0 to 4.1.0.
Release notes

Sourced from actions/checkout's releases.

v4.1.0

What's Changed

New Contributors

Full Changelog: https://github.com/actions/checkout/compare/v4.0.0...v4.1.0

v4.0.0

What's Changed

New Contributors

Full Changelog: https://github.com/actions/checkout/compare/v3...v4.0.0

Changelog

Sourced from actions/checkout's changelog.

Changelog

v4.1.0

v4.0.0

v3.6.0

v3.5.3

v3.5.2

v3.5.1

v3.5.0

v3.4.0

v3.3.0

v3.2.0

v3.1.0

v3.0.2

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/checkout&package-manager=github_actions&previous-version=3.6.0&new-version=4.1.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 24d44c9ac1..585fbb43a4 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 + - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [3.0.0, dev] steps: - - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 + - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f with: sdk: ${{ matrix.sdk }} From 10ed16c388fc86a422fc0320e7a757bc16664dcb Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 2 Oct 2023 18:38:43 +0000 Subject: [PATCH 097/115] Bump dart-lang/setup-dart from 1.5.0 to 1.5.1 (dart-lang/pub_semver#93) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [dart-lang/setup-dart](https://github.com/dart-lang/setup-dart) from 1.5.0 to 1.5.1.
Release notes

Sourced from dart-lang/setup-dart's releases.

v1.5.1

  • No longer test the setup-dart action on pre-2.12 SDKs.
  • Upgrade JS interop code to use extension types (the new name for inline classes).
  • The upcoming rename of the be channel to main is now supported with forward compatibility that switches when the rename happens.
Changelog

Sourced from dart-lang/setup-dart's changelog.

v1.6.0

  • Enable provisioning of the latest Dart SDK patch release by specifying just the major and minor version (e.g. 3.2).

v1.5.1

  • No longer test the setup-dart action on pre-2.12 SDKs.
  • Upgrade JS interop code to use extension types (the new name for inline classes).
  • The upcoming rename of the be channel to main is now supported with forward compatibility that switches when the rename happens.

v1.5.0

  • Re-wrote the implementation of the action into Dart.
  • Auto-detect the platform architecture (x64, ia32, arm, arm64).
  • Improved the caching and download resilience of the sdk.
  • Added a new action output: dart-version - the installed version of the sdk.

v1.4.0

  • Automatically create OIDC token for pub.dev.
  • Add a reusable workflow for publishing.

v1.3.0

  • The install location of the Dart SDK is now available in an environment variable, DART_HOME (dart-lang/pub_semver#43).
  • Fixed an issue where cached downloads could lead to unzip issues on self-hosted runners (dart-lang/pub_semver#35).

v1.2.0

  • Fixed a path issue impacting git dependencies on Windows.

v1.1.0

  • Added a flavor option setup.sh to allow downloading unpublished builds.

v1.0.0

  • Promoted to 1.0 stable.

v0.5

  • Fixed a Windows pub global activate path issue.

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=dart-lang/setup-dart&package-manager=github_actions&previous-version=1.5.0&new-version=1.5.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 585fbb43a4..657b236dbb 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -23,7 +23,7 @@ jobs: sdk: [dev] steps: - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 - - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f + - uses: dart-lang/setup-dart@8a4b97ea2017cc079571daec46542f76189836b1 with: sdk: ${{ matrix.sdk }} - id: install @@ -50,7 +50,7 @@ jobs: sdk: [3.0.0, dev] steps: - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 - - uses: dart-lang/setup-dart@d6a63dab3335f427404425de0fbfed4686d93c4f + - uses: dart-lang/setup-dart@8a4b97ea2017cc079571daec46542f76189836b1 with: sdk: ${{ matrix.sdk }} - id: install From 393f66316ab720162883d5ab70cfc8eb7f8902e4 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 1 Nov 2023 16:29:05 +0000 Subject: [PATCH 098/115] Bump dart-lang/setup-dart from 1.5.1 to 1.6.0 (dart-lang/pub_semver#94) Bumps [dart-lang/setup-dart](https://github.com/dart-lang/setup-dart) from 1.5.1 to 1.6.0.
Release notes

Sourced from dart-lang/setup-dart's releases.

v1.6.0

  • Enable provisioning of the latest Dart SDK patch release by specifying just the major and minor version (e.g. 3.2).
Changelog

Sourced from dart-lang/setup-dart's changelog.

v1.6.0

  • Enable provisioning of the latest Dart SDK patch release by specifying just the major and minor version (e.g. 3.2).

v1.5.1

  • No longer test the setup-dart action on pre-2.12 SDKs.
  • Upgrade JS interop code to use extension types (the new name for inline classes).
  • The upcoming rename of the be channel to main is now supported with forward compatibility that switches when the rename happens.

v1.5.0

  • Re-wrote the implementation of the action into Dart.
  • Auto-detect the platform architecture (x64, ia32, arm, arm64).
  • Improved the caching and download resilience of the sdk.
  • Added a new action output: dart-version - the installed version of the sdk.

v1.4.0

  • Automatically create OIDC token for pub.dev.
  • Add a reusable workflow for publishing.

v1.3.0

  • The install location of the Dart SDK is now available in an environment variable, DART_HOME (dart-lang/pub_semver#43).
  • Fixed an issue where cached downloads could lead to unzip issues on self-hosted runners (dart-lang/pub_semver#35).

v1.2.0

  • Fixed a path issue impacting git dependencies on Windows.

v1.1.0

  • Added a flavor option setup.sh to allow downloading unpublished builds.

v1.0.0

  • Promoted to 1.0 stable.

v0.5

  • Fixed a Windows pub global activate path issue.

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=dart-lang/setup-dart&package-manager=github_actions&previous-version=1.5.1&new-version=1.6.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 657b236dbb..86a16617d1 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -23,7 +23,7 @@ jobs: sdk: [dev] steps: - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 - - uses: dart-lang/setup-dart@8a4b97ea2017cc079571daec46542f76189836b1 + - uses: dart-lang/setup-dart@b64355ae6ca0b5d484f0106a033dd1388965d06d with: sdk: ${{ matrix.sdk }} - id: install @@ -50,7 +50,7 @@ jobs: sdk: [3.0.0, dev] steps: - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 - - uses: dart-lang/setup-dart@8a4b97ea2017cc079571daec46542f76189836b1 + - uses: dart-lang/setup-dart@b64355ae6ca0b5d484f0106a033dd1388965d06d with: sdk: ${{ matrix.sdk }} - id: install From edc6bb398595da7800c5b8d4fd1bb08127f0ea60 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 1 Nov 2023 16:32:55 +0000 Subject: [PATCH 099/115] Bump actions/checkout from 4.1.0 to 4.1.1 (dart-lang/pub_semver#95) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.0 to 4.1.1.
Release notes

Sourced from actions/checkout's releases.

v4.1.1

What's Changed

New Contributors

Full Changelog: https://github.com/actions/checkout/compare/v4.1.0...v4.1.1

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/checkout&package-manager=github_actions&previous-version=4.1.0&new-version=4.1.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 86a16617d1..4cb7d3a73d 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 + - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 - uses: dart-lang/setup-dart@b64355ae6ca0b5d484f0106a033dd1388965d06d with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [3.0.0, dev] steps: - - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 + - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 - uses: dart-lang/setup-dart@b64355ae6ca0b5d484f0106a033dd1388965d06d with: sdk: ${{ matrix.sdk }} From 6a6f22d52cd0ac65af7ae8f7804404d03be3570d Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Mon, 4 Dec 2023 10:34:15 -0800 Subject: [PATCH 100/115] drop outdated lints (dart-lang/pub_semver#96) --- pkgs/pub_semver/analysis_options.yaml | 7 ------- pkgs/pub_semver/pubspec.yaml | 2 +- 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml index 210af85b9d..01270cd054 100644 --- a/pkgs/pub_semver/analysis_options.yaml +++ b/pkgs/pub_semver/analysis_options.yaml @@ -13,27 +13,20 @@ linter: - avoid_classes_with_only_static_members - avoid_private_typedef_functions - avoid_redundant_argument_values - - avoid_returning_null - - avoid_returning_null_for_future - avoid_returning_this - avoid_unused_constructor_parameters - avoid_void_async - cancel_subscriptions - cascade_invocations - - comment_references - join_return_with_assignment - literal_only_boolean_expressions - missing_whitespace_between_adjacent_strings - no_adjacent_strings_in_list - no_runtimeType_toString - package_api_docs - - prefer_const_constructors - prefer_const_declarations - prefer_expression_function_bodies - - prefer_relative_imports - - test_types_in_equals - unnecessary_await_in_return - use_if_null_to_convert_nulls_to_bools - use_raw_strings - use_string_buffers - - use_super_parameters diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 72ffdfe287..9d23664d5e 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -16,5 +16,5 @@ dependencies: meta: ^1.3.0 dev_dependencies: - dart_flutter_team_lints: ^1.0.0 + dart_flutter_team_lints: ^2.0.0 test: ^1.16.0 From 7dd06254eb67095a0e15ffe8438e38f88865bb7d Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 1 Feb 2024 16:28:03 +0000 Subject: [PATCH 101/115] Bump dart-lang/setup-dart from 1.6.0 to 1.6.2 (dart-lang/pub_semver#98) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [dart-lang/setup-dart](https://github.com/dart-lang/setup-dart) from 1.6.0 to 1.6.2.
Release notes

Sourced from dart-lang/setup-dart's releases.

v1.6.2

v1.6.1

  • Updated the google storage url for main channel releases.
Changelog

Sourced from dart-lang/setup-dart's changelog.

v1.6.2

v1.6.1

  • Updated the google storage url for main channel releases.

v1.6.0

  • Enable provisioning of the latest Dart SDK patch release by specifying just the major and minor version (e.g. 3.2).

v1.5.1

  • No longer test the setup-dart action on pre-2.12 SDKs.
  • Upgrade JS interop code to use extension types (the new name for inline classes).
  • The upcoming rename of the be channel to main is now supported with forward compatibility that switches when the rename happens.

v1.5.0

  • Re-wrote the implementation of the action into Dart.
  • Auto-detect the platform architecture (x64, ia32, arm, arm64).
  • Improved the caching and download resilience of the sdk.
  • Added a new action output: dart-version - the installed version of the sdk.

v1.4.0

  • Automatically create OIDC token for pub.dev.
  • Add a reusable workflow for publishing.

v1.3.0

  • The install location of the Dart SDK is now available in an environment variable, DART_HOME (dart-lang/pub_semver#43).
  • Fixed an issue where cached downloads could lead to unzip issues on self-hosted runners (dart-lang/pub_semver#35).

v1.2.0

  • Fixed a path issue impacting git dependencies on Windows.

v1.1.0

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=dart-lang/setup-dart&package-manager=github_actions&previous-version=1.6.0&new-version=1.6.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 4cb7d3a73d..4e4e97d8db 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -23,7 +23,7 @@ jobs: sdk: [dev] steps: - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 - - uses: dart-lang/setup-dart@b64355ae6ca0b5d484f0106a033dd1388965d06d + - uses: dart-lang/setup-dart@fedb1266e91cf51be2fdb382869461a434b920a3 with: sdk: ${{ matrix.sdk }} - id: install @@ -50,7 +50,7 @@ jobs: sdk: [3.0.0, dev] steps: - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 - - uses: dart-lang/setup-dart@b64355ae6ca0b5d484f0106a033dd1388965d06d + - uses: dart-lang/setup-dart@fedb1266e91cf51be2fdb382869461a434b920a3 with: sdk: ${{ matrix.sdk }} - id: install From c935922faac33286bbd669d2536bbe109b418c6a Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 1 Apr 2024 16:53:28 +0000 Subject: [PATCH 102/115] Bump actions/checkout from 4.1.1 to 4.1.2 (dart-lang/pub_semver#99) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.1 to 4.1.2.
Release notes

Sourced from actions/checkout's releases.

v4.1.2

We are investigating the following issue with this release and have rolled-back the v4 tag to point to v4.1.1

What's Changed

New Contributors

Full Changelog: https://github.com/actions/checkout/compare/v4.1.1...v4.1.2

Changelog

Sourced from actions/checkout's changelog.

Changelog

v4.1.2

v4.1.1

v4.1.0

v4.0.0

v3.6.0

v3.5.3

v3.5.2

v3.5.1

v3.5.0

v3.4.0

v3.3.0

v3.2.0

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/checkout&package-manager=github_actions&previous-version=4.1.1&new-version=4.1.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 4e4e97d8db..8f1b1a6919 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 + - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633 - uses: dart-lang/setup-dart@fedb1266e91cf51be2fdb382869461a434b920a3 with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [3.0.0, dev] steps: - - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 + - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633 - uses: dart-lang/setup-dart@fedb1266e91cf51be2fdb382869461a434b920a3 with: sdk: ${{ matrix.sdk }} From 024cb7f18a836f91d7ed7a9d4a58e5b648b269bf Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 1 May 2024 16:13:05 +0000 Subject: [PATCH 103/115] Bump dart-lang/setup-dart from 1.6.2 to 1.6.4 (dart-lang/pub_semver#100) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [dart-lang/setup-dart](https://github.com/dart-lang/setup-dart) from 1.6.2 to 1.6.4.
Release notes

Sourced from dart-lang/setup-dart's releases.

v1.6.4

  • Rebuild JS code to include changes from v1.6.3

v1.6.3

Changelog

Sourced from dart-lang/setup-dart's changelog.

v1.6.4

  • Rebuild JS code.

v1.6.3

v1.6.2

v1.6.1

  • Updated the google storage url for main channel releases.

v1.6.0

  • Enable provisioning of the latest Dart SDK patch release by specifying just the major and minor version (e.g. 3.2).

v1.5.1

  • No longer test the setup-dart action on pre-2.12 SDKs.
  • Upgrade JS interop code to use extension types (the new name for inline classes).
  • The upcoming rename of the be channel to main is now supported with forward compatibility that switches when the rename happens.

v1.5.0

  • Re-wrote the implementation of the action into Dart.
  • Auto-detect the platform architecture (x64, ia32, arm, arm64).
  • Improved the caching and download resilience of the sdk.
  • Added a new action output: dart-version - the installed version of the sdk.

v1.4.0

  • Automatically create OIDC token for pub.dev.
  • Add a reusable workflow for publishing.

v1.3.0

  • The install location of the Dart SDK is now available

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=dart-lang/setup-dart&package-manager=github_actions&previous-version=1.6.2&new-version=1.6.4)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 8f1b1a6919..b14a4082a4 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -23,7 +23,7 @@ jobs: sdk: [dev] steps: - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633 - - uses: dart-lang/setup-dart@fedb1266e91cf51be2fdb382869461a434b920a3 + - uses: dart-lang/setup-dart@f0ead981b4d9a35b37f30d36160575d60931ec30 with: sdk: ${{ matrix.sdk }} - id: install @@ -50,7 +50,7 @@ jobs: sdk: [3.0.0, dev] steps: - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633 - - uses: dart-lang/setup-dart@fedb1266e91cf51be2fdb382869461a434b920a3 + - uses: dart-lang/setup-dart@f0ead981b4d9a35b37f30d36160575d60931ec30 with: sdk: ${{ matrix.sdk }} - id: install From 08beee08466d0005308d1f28b06c2cc29b9a4bdf Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 1 May 2024 17:35:04 +0000 Subject: [PATCH 104/115] Bump actions/checkout from 4.1.2 to 4.1.4 (dart-lang/pub_semver#101) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.2 to 4.1.4.
Release notes

Sourced from actions/checkout's releases.

v4.1.4

What's Changed

Full Changelog: https://github.com/actions/checkout/compare/v4.1.3...v4.1.4

v4.1.3

What's Changed

Full Changelog: https://github.com/actions/checkout/compare/v4.1.2...v4.1.3

Changelog

Sourced from actions/checkout's changelog.

Changelog

v4.1.4

v4.1.3

v4.1.2

v4.1.1

v4.1.0

v4.0.0

v3.6.0

v3.5.3

v3.5.2

v3.5.1

v3.5.0

v3.4.0

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/checkout&package-manager=github_actions&previous-version=4.1.2&new-version=4.1.4)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index b14a4082a4..97fdf914e7 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633 + - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b - uses: dart-lang/setup-dart@f0ead981b4d9a35b37f30d36160575d60931ec30 with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [3.0.0, dev] steps: - - uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633 + - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b - uses: dart-lang/setup-dart@f0ead981b4d9a35b37f30d36160575d60931ec30 with: sdk: ${{ matrix.sdk }} From 926b830ea5db08162b62a4b94dceae948965e284 Mon Sep 17 00:00:00 2001 From: Devon Carew Date: Thu, 9 May 2024 13:46:52 -0700 Subject: [PATCH 105/115] blast_repo fixes (dart-lang/pub_semver#102) dependabot --- pkgs/pub_semver/.github/dependabot.yaml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pkgs/pub_semver/.github/dependabot.yaml b/pkgs/pub_semver/.github/dependabot.yaml index 439e796b48..bf6b38a4d8 100644 --- a/pkgs/pub_semver/.github/dependabot.yaml +++ b/pkgs/pub_semver/.github/dependabot.yaml @@ -8,3 +8,7 @@ updates: interval: monthly labels: - autosubmit + groups: + github-actions: + patterns: + - "*" From fcd421b629605bf0e2ff028caa13c0773a1d4f81 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 9 May 2024 20:54:37 +0000 Subject: [PATCH 106/115] Bump actions/checkout from 4.1.4 to 4.1.5 in the github-actions group (dart-lang/pub_semver#103) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps the github-actions group with 1 update: [actions/checkout](https://github.com/actions/checkout). Updates `actions/checkout` from 4.1.4 to 4.1.5
Release notes

Sourced from actions/checkout's releases.

v4.1.5

What's Changed

Full Changelog: https://github.com/actions/checkout/compare/v4.1.4...v4.1.5

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/checkout&package-manager=github_actions&previous-version=4.1.4&new-version=4.1.5)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore major version` will close this group update PR and stop Dependabot creating any more for the specific dependency's major version (unless you unignore this specific dependency's major version or upgrade to it yourself) - `@dependabot ignore minor version` will close this group update PR and stop Dependabot creating any more for the specific dependency's minor version (unless you unignore this specific dependency's minor version or upgrade to it yourself) - `@dependabot ignore ` will close this group update PR and stop Dependabot creating any more for the specific dependency (unless you unignore this specific dependency or upgrade to it yourself) - `@dependabot unignore ` will remove all of the ignore conditions of the specified dependency - `@dependabot unignore ` will remove the ignore condition of the specified dependency and ignore conditions
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 97fdf914e7..05335028c3 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b - uses: dart-lang/setup-dart@f0ead981b4d9a35b37f30d36160575d60931ec30 with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [3.0.0, dev] steps: - - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b + - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b - uses: dart-lang/setup-dart@f0ead981b4d9a35b37f30d36160575d60931ec30 with: sdk: ${{ matrix.sdk }} From b79ef033b574645675cca056dc0bbb7bf9db6624 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sat, 1 Jun 2024 16:24:22 +0000 Subject: [PATCH 107/115] Bump actions/checkout from 4.1.5 to 4.1.6 in the github-actions group (dart-lang/pub_semver#104) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps the github-actions group with 1 update: [actions/checkout](https://github.com/actions/checkout). Updates `actions/checkout` from 4.1.5 to 4.1.6
Release notes

Sourced from actions/checkout's releases.

v4.1.6

What's Changed

Full Changelog: https://github.com/actions/checkout/compare/v4.1.5...v4.1.6

Changelog

Sourced from actions/checkout's changelog.

Changelog

v4.1.6

v4.1.5

v4.1.4

v4.1.3

v4.1.2

v4.1.1

v4.1.0

v4.0.0

v3.6.0

v3.5.3

v3.5.2

v3.5.1

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/checkout&package-manager=github_actions&previous-version=4.1.5&new-version=4.1.6)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore major version` will close this group update PR and stop Dependabot creating any more for the specific dependency's major version (unless you unignore this specific dependency's major version or upgrade to it yourself) - `@dependabot ignore minor version` will close this group update PR and stop Dependabot creating any more for the specific dependency's minor version (unless you unignore this specific dependency's minor version or upgrade to it yourself) - `@dependabot ignore ` will close this group update PR and stop Dependabot creating any more for the specific dependency (unless you unignore this specific dependency or upgrade to it yourself) - `@dependabot unignore ` will remove all of the ignore conditions of the specified dependency - `@dependabot unignore ` will remove the ignore condition of the specified dependency and ignore conditions
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 05335028c3..58a2061ed6 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b + - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 - uses: dart-lang/setup-dart@f0ead981b4d9a35b37f30d36160575d60931ec30 with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [3.0.0, dev] steps: - - uses: actions/checkout@44c2b7a8a4ea60a981eaca3cf939b5f4305c123b + - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 - uses: dart-lang/setup-dart@f0ead981b4d9a35b37f30d36160575d60931ec30 with: sdk: ${{ matrix.sdk }} From 2655d2abe08d920d4c993e62452c0b934263abdf Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Thu, 20 Jun 2024 09:23:26 -0700 Subject: [PATCH 108/115] bump lints and SDK dep, test wasm (dart-lang/pub_semver#105) --- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- pkgs/pub_semver/CHANGELOG.md | 2 +- pkgs/pub_semver/pubspec.yaml | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 58a2061ed6..da7fb292b8 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -47,7 +47,7 @@ jobs: matrix: # Add macos-latest and/or windows-latest if relevant for this package. os: [ubuntu-latest] - sdk: [3.0.0, dev] + sdk: [3.4, dev] steps: - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 - uses: dart-lang/setup-dart@f0ead981b4d9a35b37f30d36160575d60931ec30 @@ -60,5 +60,5 @@ jobs: run: dart test --platform vm if: always() && steps.install.outcome == 'success' - name: Run Chrome tests - run: dart test --platform chrome + run: dart test --platform chrome --compiler dart2js,dart2wasm if: always() && steps.install.outcome == 'success' diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 33899354f8..83474d265b 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,6 +1,6 @@ ## 2.1.5-wip -- Require Dart `3.0.0`. +- Require Dart `3.4.0`. ## 2.1.4 diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 9d23664d5e..5a061bec71 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -9,12 +9,12 @@ topics: - semver environment: - sdk: ^3.0.0 + sdk: ^3.4.0 dependencies: collection: ^1.15.0 meta: ^1.3.0 dev_dependencies: - dart_flutter_team_lints: ^2.0.0 + dart_flutter_team_lints: ^3.0.0 test: ^1.16.0 From e10cad5239dd2706a810530d55f9dbe62005e5c3 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 1 Jul 2024 16:50:00 +0000 Subject: [PATCH 109/115] Bump the github-actions group with 2 updates (dart-lang/pub_semver#106) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps the github-actions group with 2 updates: [actions/checkout](https://github.com/actions/checkout) and [dart-lang/setup-dart](https://github.com/dart-lang/setup-dart). Updates `actions/checkout` from 4.1.6 to 4.1.7
Release notes

Sourced from actions/checkout's releases.

v4.1.7

What's Changed

New Contributors

Full Changelog: https://github.com/actions/checkout/compare/v4.1.6...v4.1.7

Changelog

Sourced from actions/checkout's changelog.

Changelog

v4.1.7

v4.1.6

v4.1.5

v4.1.4

v4.1.3

v4.1.2

v4.1.1

v4.1.0

v4.0.0

v3.6.0

v3.5.3

... (truncated)

Commits

Updates `dart-lang/setup-dart` from 1.6.4 to 1.6.5
Release notes

Sourced from dart-lang/setup-dart's releases.

v1.6.5

dart-lang/pub_semver#118: dart-lang/setup-dartdart-lang/pub_semver#118

Changelog

Sourced from dart-lang/setup-dart's changelog.

v1.6.5

dart-lang/pub_semver#118: dart-lang/setup-dartdart-lang/pub_semver#118

v1.6.4

  • Rebuild JS code.

v1.6.3

v1.6.2

v1.6.1

  • Updated the google storage url for main channel releases.

v1.6.0

  • Enable provisioning of the latest Dart SDK patch release by specifying just the major and minor version (e.g. 3.2).

v1.5.1

  • No longer test the setup-dart action on pre-2.12 SDKs.
  • Upgrade JS interop code to use extension types (the new name for inline classes).
  • The upcoming rename of the be channel to main is now supported with forward compatibility that switches when the rename happens.

v1.5.0

  • Re-wrote the implementation of the action into Dart.
  • Auto-detect the platform architecture (x64, ia32, arm, arm64).
  • Improved the caching and download resilience of the sdk.
  • Added a new action output: dart-version - the installed version of the sdk.

v1.4.0

... (truncated)

Commits

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore major version` will close this group update PR and stop Dependabot creating any more for the specific dependency's major version (unless you unignore this specific dependency's major version or upgrade to it yourself) - `@dependabot ignore minor version` will close this group update PR and stop Dependabot creating any more for the specific dependency's minor version (unless you unignore this specific dependency's minor version or upgrade to it yourself) - `@dependabot ignore ` will close this group update PR and stop Dependabot creating any more for the specific dependency (unless you unignore this specific dependency or upgrade to it yourself) - `@dependabot unignore ` will remove all of the ignore conditions of the specified dependency - `@dependabot unignore ` will remove the ignore condition of the specified dependency and ignore conditions
--- pkgs/pub_semver/.github/workflows/test-package.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index da7fb292b8..30b09ad7d5 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,8 +22,8 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 - - uses: dart-lang/setup-dart@f0ead981b4d9a35b37f30d36160575d60931ec30 + - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 + - uses: dart-lang/setup-dart@0a8a0fc875eb934c15d08629302413c671d3f672 with: sdk: ${{ matrix.sdk }} - id: install @@ -49,8 +49,8 @@ jobs: os: [ubuntu-latest] sdk: [3.4, dev] steps: - - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 - - uses: dart-lang/setup-dart@f0ead981b4d9a35b37f30d36160575d60931ec30 + - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 + - uses: dart-lang/setup-dart@0a8a0fc875eb934c15d08629302413c671d3f672 with: sdk: ${{ matrix.sdk }} - id: install From dd0c0848f1b5749bae36aa72e03306182a077f21 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 1 Oct 2024 16:05:54 +0000 Subject: [PATCH 110/115] Bump actions/checkout from 4.1.7 to 4.2.0 in the github-actions group (dart-lang/pub_semver#107) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps the github-actions group with 1 update: [actions/checkout](https://github.com/actions/checkout). Updates `actions/checkout` from 4.1.7 to 4.2.0
Release notes

Sourced from actions/checkout's releases.

v4.2.0

What's Changed

New Contributors

Full Changelog: https://github.com/actions/checkout/compare/v4.1.7...v4.2.0

Changelog

Sourced from actions/checkout's changelog.

Changelog

v4.2.0

v4.1.7

v4.1.6

v4.1.5

v4.1.4

v4.1.3

v4.1.2

v4.1.1

v4.1.0

v4.0.0

v3.6.0

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/checkout&package-manager=github_actions&previous-version=4.1.7&new-version=4.2.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore major version` will close this group update PR and stop Dependabot creating any more for the specific dependency's major version (unless you unignore this specific dependency's major version or upgrade to it yourself) - `@dependabot ignore minor version` will close this group update PR and stop Dependabot creating any more for the specific dependency's minor version (unless you unignore this specific dependency's minor version or upgrade to it yourself) - `@dependabot ignore ` will close this group update PR and stop Dependabot creating any more for the specific dependency (unless you unignore this specific dependency or upgrade to it yourself) - `@dependabot unignore ` will remove all of the ignore conditions of the specified dependency - `@dependabot unignore ` will remove the ignore condition of the specified dependency and ignore conditions
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 30b09ad7d5..3fe3185e05 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 + - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938 - uses: dart-lang/setup-dart@0a8a0fc875eb934c15d08629302413c671d3f672 with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [3.4, dev] steps: - - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 + - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938 - uses: dart-lang/setup-dart@0a8a0fc875eb934c15d08629302413c671d3f672 with: sdk: ${{ matrix.sdk }} From f49575eebe523185e9bd48e233e2b5652abab15a Mon Sep 17 00:00:00 2001 From: Kevin Moore Date: Mon, 28 Oct 2024 19:06:05 -0700 Subject: [PATCH 111/115] blast_repo fixes (dart-lang/pub_semver#108) drop-lint --- pkgs/pub_semver/analysis_options.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml index 01270cd054..76380a006a 100644 --- a/pkgs/pub_semver/analysis_options.yaml +++ b/pkgs/pub_semver/analysis_options.yaml @@ -23,7 +23,6 @@ linter: - missing_whitespace_between_adjacent_strings - no_adjacent_strings_in_list - no_runtimeType_toString - - package_api_docs - prefer_const_declarations - prefer_expression_function_bodies - unnecessary_await_in_return From 170c76f35233589668b7efd2501bfc7ff56409c9 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 1 Nov 2024 16:05:24 +0000 Subject: [PATCH 112/115] Bump actions/checkout from 4.2.0 to 4.2.2 in the github-actions group (dart-lang/pub_semver#109) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps the github-actions group with 1 update: [actions/checkout](https://github.com/actions/checkout). Updates `actions/checkout` from 4.2.0 to 4.2.2
Release notes

Sourced from actions/checkout's releases.

v4.2.2

What's Changed

Full Changelog: https://github.com/actions/checkout/compare/v4.2.1...v4.2.2

v4.2.1

What's Changed

New Contributors

Full Changelog: https://github.com/actions/checkout/compare/v4.2.0...v4.2.1

Changelog

Sourced from actions/checkout's changelog.

Changelog

v4.2.2

v4.2.1

v4.2.0

v4.1.7

v4.1.6

v4.1.5

v4.1.4

v4.1.3

v4.1.2

v4.1.1

v4.1.0

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/checkout&package-manager=github_actions&previous-version=4.2.0&new-version=4.2.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore major version` will close this group update PR and stop Dependabot creating any more for the specific dependency's major version (unless you unignore this specific dependency's major version or upgrade to it yourself) - `@dependabot ignore minor version` will close this group update PR and stop Dependabot creating any more for the specific dependency's minor version (unless you unignore this specific dependency's minor version or upgrade to it yourself) - `@dependabot ignore ` will close this group update PR and stop Dependabot creating any more for the specific dependency (unless you unignore this specific dependency or upgrade to it yourself) - `@dependabot unignore ` will remove all of the ignore conditions of the specified dependency - `@dependabot unignore ` will remove the ignore condition of the specified dependency and ignore conditions
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 3fe3185e05..057009dbec 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -22,7 +22,7 @@ jobs: matrix: sdk: [dev] steps: - - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938 + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 - uses: dart-lang/setup-dart@0a8a0fc875eb934c15d08629302413c671d3f672 with: sdk: ${{ matrix.sdk }} @@ -49,7 +49,7 @@ jobs: os: [ubuntu-latest] sdk: [3.4, dev] steps: - - uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938 + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 - uses: dart-lang/setup-dart@0a8a0fc875eb934c15d08629302413c671d3f672 with: sdk: ${{ matrix.sdk }} From 7cb7ee070e4c423cd502c144759fe65a45a56013 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sun, 1 Dec 2024 16:59:18 +0000 Subject: [PATCH 113/115] Bump dart-lang/setup-dart in the github-actions group (dart-lang/pub_semver#110) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps the github-actions group with 1 update: [dart-lang/setup-dart](https://github.com/dart-lang/setup-dart). Updates `dart-lang/setup-dart` from 1.6.5 to 1.7.0
Release notes

Sourced from dart-lang/setup-dart's releases.

v1.7.0

What's Changed

  • Install a Flutter SDK in the publish workflow allowing for publication of flutter packages.
Changelog

Sourced from dart-lang/setup-dart's changelog.

v1.7.0

v1.6.5

dart-lang/pub_semver#118: dart-lang/setup-dartdart-lang/pub_semver#118

v1.6.4

  • Rebuild JS code.

v1.6.3

v1.6.2

v1.6.1

  • Updated the google storage url for main channel releases.

v1.6.0

  • Enable provisioning of the latest Dart SDK patch release by specifying just the major and minor version (e.g. 3.2).

v1.5.1

  • No longer test the setup-dart action on pre-2.12 SDKs.
  • Upgrade JS interop code to use extension types (the new name for inline classes).
  • The upcoming rename of the be channel to main is now supported with forward compatibility that switches when the rename happens.

v1.5.0

... (truncated)

Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=dart-lang/setup-dart&package-manager=github_actions&previous-version=1.6.5&new-version=1.7.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore major version` will close this group update PR and stop Dependabot creating any more for the specific dependency's major version (unless you unignore this specific dependency's major version or upgrade to it yourself) - `@dependabot ignore minor version` will close this group update PR and stop Dependabot creating any more for the specific dependency's minor version (unless you unignore this specific dependency's minor version or upgrade to it yourself) - `@dependabot ignore ` will close this group update PR and stop Dependabot creating any more for the specific dependency (unless you unignore this specific dependency or upgrade to it yourself) - `@dependabot unignore ` will remove all of the ignore conditions of the specified dependency - `@dependabot unignore ` will remove the ignore condition of the specified dependency and ignore conditions
--- pkgs/pub_semver/.github/workflows/test-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/pkgs/pub_semver/.github/workflows/test-package.yml index 057009dbec..5bf727c297 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/pkgs/pub_semver/.github/workflows/test-package.yml @@ -23,7 +23,7 @@ jobs: sdk: [dev] steps: - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 - - uses: dart-lang/setup-dart@0a8a0fc875eb934c15d08629302413c671d3f672 + - uses: dart-lang/setup-dart@e630b99d28a3b71860378cafdc2a067c71107f94 with: sdk: ${{ matrix.sdk }} - id: install @@ -50,7 +50,7 @@ jobs: sdk: [3.4, dev] steps: - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 - - uses: dart-lang/setup-dart@0a8a0fc875eb934c15d08629302413c671d3f672 + - uses: dart-lang/setup-dart@e630b99d28a3b71860378cafdc2a067c71107f94 with: sdk: ${{ matrix.sdk }} - id: install From 6536814f80a0f128ba31019cd9d09fbda01193c9 Mon Sep 17 00:00:00 2001 From: Moritz Date: Tue, 10 Dec 2024 14:40:48 +0100 Subject: [PATCH 114/115] Add issue template and other fixes --- .github/ISSUE_TEMPLATE/pub_semver.md | 5 +++++ pkgs/pub_semver/pubspec.yaml | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) create mode 100644 .github/ISSUE_TEMPLATE/pub_semver.md diff --git a/.github/ISSUE_TEMPLATE/pub_semver.md b/.github/ISSUE_TEMPLATE/pub_semver.md new file mode 100644 index 0000000000..c7db9b5c15 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/pub_semver.md @@ -0,0 +1,5 @@ +--- +name: "package:pub_semver" +about: "Create a bug or file a feature request against package:pub_semver." +labels: "package:pub_semver" +--- \ No newline at end of file diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 5a061bec71..192de00efa 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -3,7 +3,7 @@ version: 2.1.5-wip description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. -repository: https://github.com/dart-lang/pub_semver +repository: https://github.com/dart-lang/tools/tree/main/pkgs/pub_semver topics: - dart-pub - semver From 5a6d593b64bbc3435682fd929e00a59195536bae Mon Sep 17 00:00:00 2001 From: Moritz Date: Tue, 10 Dec 2024 14:46:57 +0100 Subject: [PATCH 115/115] merge fixes --- .github/labeler.yml | 4 ++++ .../workflows/pub_semver.yaml | 17 ++++++++++++++--- README.md | 1 + pkgs/pub_semver/.github/dependabot.yaml | 14 -------------- pkgs/pub_semver/CHANGELOG.md | 3 ++- pkgs/pub_semver/README.md | 4 ++-- pkgs/pub_semver/pubspec.yaml | 2 +- 7 files changed, 24 insertions(+), 21 deletions(-) rename pkgs/pub_semver/.github/workflows/test-package.yml => .github/workflows/pub_semver.yaml (86%) delete mode 100644 pkgs/pub_semver/.github/dependabot.yaml diff --git a/.github/labeler.yml b/.github/labeler.yml index eca80bbc21..6e7b9f95ed 100644 --- a/.github/labeler.yml +++ b/.github/labeler.yml @@ -80,6 +80,10 @@ - changed-files: - any-glob-to-any-file: 'pkgs/oauth2/**' +'package:pub_semver': + - changed-files: + - any-glob-to-any-file: 'pkgs/pub_semver/**' + 'package:source_map_stack_trace': - changed-files: - any-glob-to-any-file: 'pkgs/source_map_stack_trace/**' diff --git a/pkgs/pub_semver/.github/workflows/test-package.yml b/.github/workflows/pub_semver.yaml similarity index 86% rename from pkgs/pub_semver/.github/workflows/test-package.yml rename to .github/workflows/pub_semver.yaml index 5bf727c297..ba0db18a3a 100644 --- a/pkgs/pub_semver/.github/workflows/test-package.yml +++ b/.github/workflows/pub_semver.yaml @@ -1,17 +1,28 @@ -name: Dart CI +name: package:pub_semver on: # Run on PRs and pushes to the default branch. push: - branches: [ master ] + branches: [ main ] + paths: + - '.github/workflows/pub_semver.yaml' + - 'pkgs/pub_semver/**' pull_request: - branches: [ master ] + branches: [ main ] + paths: + - '.github/workflows/pub_semver.yaml' + - 'pkgs/pub_semver/**' schedule: - cron: "0 0 * * 0" env: PUB_ENVIRONMENT: bot.github + +defaults: + run: + working-directory: pkgs/pub_semver/ + jobs: # Check code formatting and static analysis on a single OS (linux) # against Dart dev. diff --git a/README.md b/README.md index 50517c36eb..697a16cc7c 100644 --- a/README.md +++ b/README.md @@ -33,6 +33,7 @@ don't naturally belong to other topic monorepos (like | [json_rpc_2](pkgs/json_rpc_2/) | Utilities to write a client or server using the JSON-RPC 2.0 spec. | [![package issues](https://img.shields.io/badge/package:json_rpc_2-4774bc)](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Ajson_rpc_2) | [![pub package](https://img.shields.io/pub/v/json_rpc_2.svg)](https://pub.dev/packages/json_rpc_2) | | [mime](pkgs/mime/) | Utilities for handling media (MIME) types, including determining a type from a file extension and file contents. | [![package issues](https://img.shields.io/badge/package:mime-4774bc)](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Amime) | [![pub package](https://img.shields.io/pub/v/mime.svg)](https://pub.dev/packages/mime) | | [oauth2](pkgs/oauth2/) | A client library for authenticating with a remote service via OAuth2 on behalf of a user, and making authorized HTTP requests with the user's OAuth2 credentials. | [![package issues](https://img.shields.io/badge/package:oauth2-4774bc)](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Aoauth2) | [![pub package](https://img.shields.io/pub/v/oauth2.svg)](https://pub.dev/packages/oauth2) | +| [pub_semver](pkgs/pub_semver/) | Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases. | [![package issues](https://img.shields.io/badge/package:pub_semver-4774bc)](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Apub_semver) | [![pub package](https://img.shields.io/pub/v/pub_semver.svg)](https://pub.dev/packages/pub_semver) | | [source_map_stack_trace](pkgs/source_map_stack_trace/) | A package for applying source maps to stack traces. | [![package issues](https://img.shields.io/badge/package:source_map_stack_trace-4774bc)](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Asource_map_stack_trace) | [![pub package](https://img.shields.io/pub/v/source_map_stack_trace.svg)](https://pub.dev/packages/source_map_stack_trace) | | [unified_analytics](pkgs/unified_analytics/) | A package for logging analytics for all Dart and Flutter related tooling to Google Analytics. | [![package issues](https://img.shields.io/badge/package:unified_analytics-4774bc)](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Aunified_analytics) | [![pub package](https://img.shields.io/pub/v/unified_analytics.svg)](https://pub.dev/packages/unified_analytics) | diff --git a/pkgs/pub_semver/.github/dependabot.yaml b/pkgs/pub_semver/.github/dependabot.yaml deleted file mode 100644 index bf6b38a4d8..0000000000 --- a/pkgs/pub_semver/.github/dependabot.yaml +++ /dev/null @@ -1,14 +0,0 @@ -# Dependabot configuration file. -version: 2 - -updates: - - package-ecosystem: github-actions - directory: / - schedule: - interval: monthly - labels: - - autosubmit - groups: - github-actions: - patterns: - - "*" diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md index 83474d265b..a31fbb2437 100644 --- a/pkgs/pub_semver/CHANGELOG.md +++ b/pkgs/pub_semver/CHANGELOG.md @@ -1,6 +1,7 @@ -## 2.1.5-wip +## 2.1.5 - Require Dart `3.4.0`. +- Move to `dart-lang/tools` monorepo. ## 2.1.4 diff --git a/pkgs/pub_semver/README.md b/pkgs/pub_semver/README.md index ad0740ce0e..03c92a3c5f 100644 --- a/pkgs/pub_semver/README.md +++ b/pkgs/pub_semver/README.md @@ -1,5 +1,5 @@ -[![Dart CI](https://github.com/dart-lang/pub_semver/actions/workflows/test-package.yml/badge.svg)](https://github.com/dart-lang/pub_semver/actions/workflows/test-package.yml) -[![Pub](https://img.shields.io/pub/v/pub_semver.svg)](https://pub.dev/packages/pub_semver) +[![Build Status](https://github.com/dart-lang/tools/actions/workflows/pub_semver.yaml/badge.svg)](https://github.com/dart-lang/tools/actions/workflows/pub_semver.yaml) +[![pub package](https://img.shields.io/pub/v/pub_semver.svg)](https://pub.dev/packages/pub_semver) [![package publisher](https://img.shields.io/pub/publisher/pub_semver.svg)](https://pub.dev/packages/pub_semver/publisher) Handles version numbers and version constraints in the same way that [pub][] diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml index 192de00efa..290fb9254e 100644 --- a/pkgs/pub_semver/pubspec.yaml +++ b/pkgs/pub_semver/pubspec.yaml @@ -1,5 +1,5 @@ name: pub_semver -version: 2.1.5-wip +version: 2.1.5 description: >- Versions and version constraints implementing pub's versioning policy. This is very similar to vanilla semver, with a few corner cases.