using System; using System.Text.RegularExpressions; using Newtonsoft.Json; namespace StardewModdingAPI.Common { /// A low-level implementation of a semantic version with an optional release tag. /// The implementation is defined by Semantic Version 2.0 (http://semver.org/). internal class SemanticVersionImpl { /********* ** Accessors *********/ /// The major version incremented for major API changes. public int Major { get; } /// The minor version incremented for backwards-compatible changes. public int Minor { get; } /// The patch version for backwards-compatible bug fixes. public int Patch { get; } /// An optional prerelease tag. public string Tag { get; } /// A regular expression matching a semantic version string. /// /// This pattern is derived from the BNF documentation in the semver repo, /// with three important deviations intended to support Stardew Valley mod conventions: /// - allows short-form "x.y" versions; /// - allows hyphens in prerelease tags as synonyms for dots (like "-unofficial-update.3"); /// - doesn't allow '+build' suffixes. /// internal static readonly Regex Regex = new Regex(@"^(?>(?0|[1-9]\d*))\.(?>(?0|[1-9]\d*))(?>(?:\.(?0|[1-9]\d*))?)(?:-(?(?>[a-z0-9]+[\-\.]?)+))?$", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.ExplicitCapture); /********* ** Public methods *********/ /// Construct an instance. /// The major version incremented for major API changes. /// The minor version incremented for backwards-compatible changes. /// The patch version for backwards-compatible bug fixes. /// An optional prerelease tag. [JsonConstructor] public SemanticVersionImpl(int major, int minor, int patch, string tag = null) { this.Major = major; this.Minor = minor; this.Patch = patch; this.Tag = this.GetNormalisedTag(tag); } /// Construct an instance. /// The semantic version string. /// The is null. /// The is not a valid semantic version. public SemanticVersionImpl(string version) { // parse if (version == null) throw new ArgumentNullException(nameof(version), "The input version string can't be null."); var match = SemanticVersionImpl.Regex.Match(version.Trim()); if (!match.Success) throw new FormatException($"The input '{version}' isn't a valid semantic version."); // initialise this.Major = int.Parse(match.Groups["major"].Value); this.Minor = match.Groups["minor"].Success ? int.Parse(match.Groups["minor"].Value) : 0; this.Patch = match.Groups["patch"].Success ? int.Parse(match.Groups["patch"].Value) : 0; this.Tag = match.Groups["prerelease"].Success ? this.GetNormalisedTag(match.Groups["prerelease"].Value) : null; } /// Get an integer indicating whether this version precedes (less than 0), supercedes (more than 0), or is equivalent to (0) the specified version. /// The version to compare with this instance. /// The value is null. public int CompareTo(SemanticVersionImpl other) { if (other == null) throw new ArgumentNullException(nameof(other)); return this.CompareTo(other.Major, other.Minor, other.Patch, other.Tag); } /// Get an integer indicating whether this version precedes (less than 0), supercedes (more than 0), or is equivalent to (0) the specified version. /// The major version to compare with this instance. /// The minor version to compare with this instance. /// The patch version to compare with this instance. /// The prerelease tag to compare with this instance. public int CompareTo(int otherMajor, int otherMinor, int otherPatch, string otherTag) { const int same = 0; const int curNewer = 1; const int curOlder = -1; // compare stable versions if (this.Major != otherMajor) return this.Major.CompareTo(otherMajor); if (this.Minor != otherMinor) return this.Minor.CompareTo(otherMinor); if (this.Patch != otherPatch) return this.Patch.CompareTo(otherPatch); if (this.Tag == otherTag) return same; // stable supercedes pre-release bool curIsStable = string.IsNullOrWhiteSpace(this.Tag); bool otherIsStable = string.IsNullOrWhiteSpace(otherTag); if (curIsStable) return curNewer; if (otherIsStable) return curOlder; // compare two pre-release tag values string[] curParts = this.Tag.Split('.', '-'); string[] otherParts = otherTag.Split('.', '-'); for (int i = 0; i < curParts.Length; i++) { // longer prerelease tag supercedes if otherwise equal if (otherParts.Length <= i) return curNewer; // compare if different if (curParts[i] != otherParts[i]) { // compare numerically if possible { if (int.TryParse(curParts[i], out int curNum) && int.TryParse(otherParts[i], out int otherNum)) return curNum.CompareTo(otherNum); } // else compare lexically return string.Compare(curParts[i], otherParts[i], StringComparison.OrdinalIgnoreCase); } } // fallback (this should never happen) return string.Compare(this.ToString(), new SemanticVersionImpl(otherMajor, otherMinor, otherPatch, otherTag).ToString(), StringComparison.InvariantCultureIgnoreCase); } /// Get a string representation of the version. public override string ToString() { // version string result = this.Patch != 0 ? $"{this.Major}.{this.Minor}.{this.Patch}" : $"{this.Major}.{this.Minor}"; // tag string tag = this.Tag; if (tag != null) result += $"-{tag}"; return result; } /// Parse a version string without throwing an exception if it fails. /// The version string. /// The parsed representation. /// Returns whether parsing the version succeeded. internal static bool TryParse(string version, out SemanticVersionImpl parsed) { try { parsed = new SemanticVersionImpl(version); return true; } catch { parsed = null; return false; } } /********* ** Private methods *********/ /// Get a normalised build tag. /// The tag to normalise. private string GetNormalisedTag(string tag) { tag = tag?.Trim(); if (string.IsNullOrWhiteSpace(tag) || tag == "0") // '0' from incorrect examples in old SMAPI documentation return null; return tag; } } }