Convert /** comments to /// in pub.

utils/pub/version.dart

 // Copyright (c) 2012, 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.
 
-/**
- * Handles version numbers, following the [Semantic Versioning][semver] spec.
- *
- * [semver]: http://semver.org/
- */
+/// Handles version numbers, following the [Semantic Versioning][semver] spec.
+///
+/// [semver]: http://semver.org/
 library version;
 
 import 'dart:math';
 
 import 'utils.dart';
 
-/** A parsed semantic version number. */
+/// A parsed semantic version number.
 class Version implements Comparable, VersionConstraint {
-  /** No released version: i.e. "0.0.0". */
+  /// No released version: i.e. "0.0.0".
   static Version get none => new Version(0, 0, 0);
 
   static final _PARSE_REGEX = 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.
       r'$');                                     // Consume entire string.
 
-  /** The major version number: "1" in "1.2.3". */
+  /// The major version number: "1" in "1.2.3".
   final int major;
 
-  /** The minor version number: "2" in "1.2.3". */
+  /// The minor version number: "2" in "1.2.3".
   final int minor;
 
-  /** The patch version number: "3" in "1.2.3". */
+  /// The patch version number: "3" in "1.2.3".
   final int patch;
 
-  /** The pre-release identifier: "foo" in "1.2.3-foo". May be `null`. */
+  /// The pre-release identifier: "foo" in "1.2.3-foo". May be `null`.
   final String preRelease;
 
-  /** The build identifier: "foo" in "1.2.3+foo". May be `null`. */
+  /// The build identifier: "foo" in "1.2.3+foo". May be `null`.
   final String build;
 
-  /** Creates a new [Version] object. */
+  /// Creates a new [Version] object.
   Version(this.major, this.minor, this.patch, {String pre, this.build})
     : preRelease = pre {
     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] by parsing [text].
-   */
+  /// Creates a new [Version] by parsing [text].
   factory Version.parse(String text) {
     final match = _PARSE_REGEX.firstMatch(text);
     if (match == null) {
       throw new FormatException('Could not parse "$text".');
     }
 
     try {
       int major = parseInt(match[1]);
       int minor = parseInt(match[2]);
       int patch = parseInt(match[3]);
@@ skipping 12 matching lines @@
     return 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 operator >=(Version other) => compareTo(other) >= 0;
 
   bool get isEmpty => false;
 
-  /** Tests if [other] matches this version exactly. */
+  /// 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 : const _EmptyVersion();
@@ skipping 29 matching lines @@
   int get hashCode => toString().hashCode;
 
   String toString() {
     var buffer = new StringBuffer();
     buffer.add('$major.$minor.$patch');
     if (preRelease != null) buffer.add('-$preRelease');
     if (build != null) buffer.add('+$build');
     return buffer.toString();
   }
 
-  /**
-   * Compares the string part of two versions. This is used for the pre-release
-   * and build version parts. This follows Rule 12. of the Semantic Versioning
-   * spec.
-   */
+  /// Compares the string part of two versions. This is used for the pre-release
+  /// and build version parts. This follows Rule 12. of the Semantic Versioning
+  /// spec.
   int _compareStrings(String a, String b) {
     var aParts = _splitParts(a);
     var bParts = _splitParts(b);
 
     for (int i = 0; i < max(aParts.length, bParts.length); i++) {
       var aPart = (i < aParts.length) ? aParts[i] : null;
       var bPart = (i < bParts.length) ? bParts[i] : null;
 
       if (aPart != bPart) {
         // Missing parts come before present ones.
@@ skipping 14 matching lines @@
             return 1;
           } else {
             // Compare two strings.
             return aPart.compareTo(bPart);
           }
         }
       }
     }
   }
 
-  /**
-   * Splits a string of dot-delimited identifiers into their component parts.
-   * Identifiers that are numeric are converted to numbers.
-   */
+  /// Splits a string of dot-delimited identifiers into their component parts.
+  /// Identifiers that are numeric are converted to numbers.
   List _splitParts(String text) {
     return text.split('.').map((part) {
       try {
         return parseInt(part);
       } on FormatException catch (ex) {
         // Not a number.
         return part;
       }
     });
   }
 }
 
-/**
- * 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.
- */
+/// 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 no versions: i.e. the empty set.
-   */
+  /// A [VersionConstraint] that allows no versions: i.e. the empty set.
   factory VersionConstraint.empty() => const _EmptyVersion();
 
-  /**
-   * Parses a version constraint. This string is a space-separated 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. There cannot be a space between the operator and the version.
-   *
-   * Examples:
-   *
-   *     1.2.3-alpha
-   *     <=5.1.4
-   *     >2.0.4 <=2.4.6
-   */
+  /// Parses a version constraint. This string is a space-separated 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. There cannot be a space between the operator and the version.
+  ///
+  /// Examples:
+  ///
+  ///     1.2.3-alpha
+  ///     <=5.1.4
+  ///     >2.0.4 <=2.4.6
   factory VersionConstraint.parse(String text) {
     if (text.trim() == '') {
       throw new FormatException('Cannot parse an empty string.');
     }
 
     // Split it into space-separated parts.
     var constraints = <VersionConstraint>[];
     for (var part in text.split(' ')) {
       constraints.add(_parseSingleConstraint(part));
     }
 
     return new VersionConstraint.intersection(constraints);
   }
 
-  /**
-   * Creates a new version constraint that is the intersection of [constraints].
-   * It will only allow versions that all of those constraints allow. If
-   * constraints is empty, then it returns a VersionConstraint that allows all
-   * versions.
-   */
+  /// Creates a new version constraint that is the intersection of
+  /// [constraints]. It will only allow versions that all of those constraints
+  /// allow. If constraints is empty, then it returns a VersionConstraint that
+  /// allows all versions.
   factory VersionConstraint.intersection(
       Collection<VersionConstraint> constraints) {
     var constraint = new VersionRange();
     for (var other in constraints) {
       constraint = constraint.intersect(other);
     }
     return constraint;
   }
 
-  /**
-   * Returns `true` if this constraint allows no versions.
-   */
+  /// Returns `true` if this constraint allows no versions.
   bool get isEmpty;
 
-  /**
-   * Returns `true` if this constraint allows [version].
-   */
+  /// 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].
-   */
+  /// Creates a new [VersionConstraint] that only allows [Version]s allowed by
+  /// both this and [other].
   VersionConstraint intersect(VersionConstraint other);
 
   static VersionConstraint _parseSingleConstraint(String text) {
     if (text == 'any') {
       return new VersionRange();
     }
 
     // TODO(rnystrom): Consider other syntaxes for version constraints. This
     // one is whitespace sensitive (you can't do "< 1.2.3") and "<" is
     // unfortunately meaningful in YAML, requiring it to be quoted in a
     // pubspec.
     // See if it's a comparison operator followed by a version, like ">1.2.3".
     var match = new RegExp(r"^([<>]=?)?(.*)$").firstMatch(text);
     if (match != null) {
       var comparison = match[1];
       var version = new Version.parse(match[2]);
       switch (match[1]) {
         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);
       }
     }
 
     // Otherwise, it must be an explicit version.
     return new Version.parse(text);
   }
 }
 
-/**
- * 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`.
- */
+/// 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 {
   final Version min;
   final Version max;
   final bool includeMin;
   final bool includeMax;
 
   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;
 
-  /** Tests if [other] matches falls within this version range. */
+  /// Tests if [other] matches falls within this version range.
   bool allows(Version other) {
     if (min != null && other < min) return false;
     if (min != null && !includeMin && other == min) return false;
     if (max != null && other > max) return false;
     if (max != null && !includeMax && other == max) return false;
     return true;
   }
 
   VersionConstraint intersect(VersionConstraint other) {
     if (other.isEmpty) return other;
@@ skipping 77 matching lines @@
 }
 
 class _EmptyVersion implements VersionConstraint {
   const _EmptyVersion();
 
   bool get isEmpty => true;
   bool allows(Version other) => false;
   VersionConstraint intersect(VersionConstraint other) => this;
   String toString() => '<empty>';
 }