// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.Diagnostics;
|
using System.Text;
|
using System.Text.RegularExpressions;
|
using System.Threading;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// Version object for OpenTAP versions. Adheres to Semantic Version 2.0 formatting and behavior, see http://semver.org.
|
/// Supported formats:
|
/// Major.Minor.Patch
|
/// Major.Minor.Patch-PreRelease
|
/// Major.Minor.Patch+BuildMetadata.
|
/// Major.Minor.Patch-PreRelease+BuildMetadata.
|
/// </summary>
|
[Serializable]
|
[DebuggerDisplay("{Major}.{Minor}.{Patch}-{PreRelease}+{BuildMetadata}")]
|
public class SemanticVersion : IComparable
|
{
|
|
/// <summary>
|
/// Major version. Incrementing this number signifies a backward incompatible change in the API.
|
/// </summary>
|
public readonly int Major;
|
|
/// <summary>
|
/// Minor version. Incrementing this number usually signifies a backward compatible addition to the API.
|
/// </summary>
|
public readonly int Minor;
|
|
/// <summary>
|
/// Patch version. Incrementing this number signifies a change that is both backward and forward compatible.
|
/// </summary>
|
public readonly int Patch;
|
|
/// <summary>
|
/// Optional build related metadata. Usually a short git commit hash (8 chars). Ignored when determining version presedence. Only ASCII alphanumeric characters and hyphen is allowed [0-9A-Za-z-]
|
/// </summary>
|
public readonly string BuildMetadata;
|
|
/// <summary>
|
/// Optional pre-release version, denoted by a -. Only ASCII alphanumeric characters and hyphen is allowed [0-9A-Za-z-].
|
/// A pre-release version indicates that the version is unstable and might not satisfy the intended compatibility requirements as denoted by its associated normal version.
|
/// </summary>
|
public readonly string PreRelease;
|
|
private static Regex semVerRegex = new Regex(@"^(?<major>\d+)\.(?<minor>\d+)(?:\.(?<patch>\d+))?(?:-(?<prerelease>[a-zA-Z0-9-.]+))?(?:\+(?<metadata>[a-zA-Z0-9-.]+))?$", RegexOptions.Compiled | RegexOptions.ExplicitCapture);
|
|
private static Regex validChars = new Regex("^[a-zA-Z0-9-.]*$", RegexOptions.Compiled);
|
|
/// <summary>
|
/// Creates a new SemanticVersion instance
|
/// </summary>
|
/// <param name="major">Major version. Incrementing this number signifies a backward incompatible change in the API.</param>
|
/// <param name="minor">Minor version. Incrementing this number usually signifies a backward compatible addition to the API.</param>
|
/// <param name="patch">Patch version. Incrementing this number signifies a change that is both backward and forward compatible.</param>
|
/// <param name="preRelease">Optional pre-release version, denoted by a -. Only ASCII alphanumeric characters and hyphen is allowed [0-9A-Za-z-]. </param>
|
/// <param name="buildMetadata">Optional build related metadata. Usually a short git commit hash (8 chars). Ignored when determining version presedence. Only ASCII alphanumeric characters and hyphen is allowed [0-9A-Za-z-]</param>
|
public SemanticVersion(int major, int minor, int patch, string preRelease, string buildMetadata)
|
{
|
Major = major;
|
Minor = minor;
|
Patch = patch;
|
if (preRelease != null && !validChars.IsMatch(preRelease))
|
throw new ArgumentException("Only ASCII alphanumeric characters, hyphen and dot is allowed (0-9, A-Z, a-z, '-' and '.').", "preRelease");
|
PreRelease = preRelease;
|
if (buildMetadata != null && !validChars.IsMatch(buildMetadata))
|
throw new ArgumentException("Only ASCII alphanumeric characters, hyphen and dot is allowed (0-9, A-Z, a-z, '-' and '.').", "buildMetadata");
|
BuildMetadata = buildMetadata;
|
}
|
|
/// <summary>
|
/// Tries to parse a SemanticVersion from string. Input must strictly adhere to http://semver.org for this method to return true.
|
/// </summary>
|
/// <returns>True if the string was sucessfully parsed.</returns>
|
public static bool TryParse(string version, out SemanticVersion result)
|
{
|
if (version != null)
|
{
|
// Do real parsing of semantic versioning style versions.
|
var match = semVerRegex.Match(version);
|
if (match.Success)
|
{
|
result = new SemanticVersion(
|
int.Parse(match.Groups["major"].Value),
|
int.Parse(match.Groups["minor"].Value),
|
match.Groups["patch"].Success ? int.Parse(match.Groups["patch"].Value) : 0,
|
match.Groups["prerelease"].Success ? match.Groups["prerelease"].Value : null,
|
match.Groups["metadata"].Success ? match.Groups["metadata"].Value : null);
|
return true;
|
}
|
}
|
result = default(SemanticVersion);
|
return false;
|
}
|
|
/// <summary>
|
/// Parses a SemanticVersion from string. In addition to the http://semver.org format, this also supports a four value number (x.x.x.x) which will be interpreted as Major.Minor.BuildMetadata.Patch.
|
/// The non semver format is supported to be compatible with Microsofts definition of version numbers (e.g. for .NET assemblies), see https://docs.microsoft.com/en-us/dotnet/api/system.version
|
/// </summary>
|
/// <exception cref="FormatException"></exception>
|
/// <returns></returns>
|
public static SemanticVersion Parse(string version)
|
{
|
if(TryParse(version, out SemanticVersion semver))
|
{
|
return semver;
|
}
|
throw new FormatException("The version string is not in a Semantic Version compliant format.");
|
}
|
|
static ThreadLocal<StringBuilder> versionFormatter = new ThreadLocal<StringBuilder>(() => new StringBuilder(), false);
|
|
/// <summary>
|
/// Prints the string in version format. It should be parsable from the same string.
|
/// </summary>
|
/// <returns></returns>
|
public override string ToString()
|
{
|
return ToString(5);
|
}
|
|
/// <summary>
|
/// Prints the string in version format. It should be parsable from the same string.
|
/// </summary>
|
/// <param name="fieldCount">Number of values to return. Must be 1, 2, 4 or 5.</param>
|
/// <exception cref="ArgumentOutOfRangeException"></exception>
|
/// <returns></returns>
|
public string ToString(int fieldCount)
|
{
|
if (fieldCount < 1 || fieldCount > 5)
|
throw new ArgumentOutOfRangeException();
|
if (fieldCount == 1)
|
return Major.ToString();
|
|
var formatter = versionFormatter.Value;
|
|
formatter.Clear();
|
|
formatter.Append(Major);
|
formatter.Append('.');
|
formatter.Append(Minor);
|
|
if (fieldCount == 2)
|
return formatter.ToString();
|
|
if (Patch != int.MaxValue)
|
{
|
formatter.Append('.');
|
formatter.Append(Patch);
|
}
|
if (fieldCount == 3)
|
return formatter.ToString();
|
|
if (false == string.IsNullOrWhiteSpace(PreRelease))
|
{
|
formatter.Append('-');
|
formatter.Append(PreRelease);
|
}
|
if (fieldCount == 4)
|
return formatter.ToString();
|
|
if (false == string.IsNullOrWhiteSpace(BuildMetadata))
|
{
|
formatter.Append('+');
|
formatter.Append(BuildMetadata);
|
}
|
|
return formatter.ToString();
|
}
|
|
/// <summary>
|
/// Returns true if the given version is backwards compatible with this. Meaning that 'other' can replace 'this' in every respect.
|
/// </summary>
|
/// <param name="other"></param>
|
/// <returns></returns>
|
public bool IsCompatible(SemanticVersion other)
|
{
|
if (other == null)
|
throw new ArgumentNullException("other");
|
if (other.Major != Major) return false;
|
if (other.Minor < Minor) return false;
|
return true;
|
}
|
|
/// <summary>
|
/// Returns -1 if obj is greater than this version, 0 if they are the same, and 1 if this is greater than obj
|
/// </summary>
|
/// <param name="obj"></param>
|
/// <returns></returns>
|
public int CompareTo(object obj)
|
{
|
if (!(obj is SemanticVersion))
|
throw new ArgumentException("Object is not a TapVersion");
|
|
SemanticVersion other = (SemanticVersion)obj;
|
if (Major > other.Major) return 1;
|
if (Major < other.Major) return -1;
|
if (Minor > other.Minor) return 1;
|
if (Minor < other.Minor) return -1;
|
if (Patch > other.Patch) return 1;
|
if (Patch < other.Patch) return -1;
|
|
return ComparePreRelease(PreRelease, other.PreRelease);
|
}
|
|
private static int ComparePreRelease(string p1, string p2)
|
{
|
if (p1 == p2) return 0;
|
|
if (string.IsNullOrEmpty(p1) && string.IsNullOrEmpty(p2)) return 0;
|
if (string.IsNullOrEmpty(p1)) return 1;
|
if (string.IsNullOrEmpty(p2)) return -1;
|
|
var identifiers1 = p1.Split('.');
|
var identifiers2 = p2.Split('.');
|
|
for (int i = 0; i < Math.Min(identifiers1.Length, identifiers2.Length); i++)
|
{
|
var id1 = identifiers1[i];
|
var id2 = identifiers2[i];
|
|
int v1, v2;
|
|
if (int.TryParse(id1, out v1) && int.TryParse(id2, out v2))
|
{
|
if (v1 != v2)
|
return v1.CompareTo(v2);
|
}
|
else
|
{
|
var res = string.Compare(id1, id2);
|
|
if (res != 0)
|
return res;
|
}
|
}
|
|
if (identifiers1.Length > identifiers2.Length) return 1;
|
if (identifiers1.Length < identifiers2.Length) return -1;
|
|
return 0;
|
}
|
|
/// <summary>
|
/// Returns true if the two versions are equal.
|
/// </summary>
|
/// <param name="obj"></param>
|
/// <returns></returns>
|
public override bool Equals(object obj)
|
{
|
if (obj is SemanticVersion)
|
return this.ToString() == obj.ToString();
|
return false;
|
}
|
|
/// <summary>
|
/// Returns the hashcode for the version.
|
/// </summary>
|
/// <returns></returns>
|
public override int GetHashCode()
|
{
|
return this.ToString().GetHashCode();
|
}
|
|
/// <summary>
|
/// Overloaded == operator that provides value equality (instead of the default reference equality)
|
/// </summary>
|
public static bool operator ==(SemanticVersion a, SemanticVersion b)
|
{
|
return Object.Equals(a, b);
|
}
|
|
/// <summary>
|
/// Overloaded != operator that provides value equality (instead of the default reference equality)
|
/// </summary>
|
public static bool operator !=(SemanticVersion a, SemanticVersion b)
|
{
|
return !(a == b);
|
}
|
}
|
}
|
