public int GetHashCode(SimpleVersion obj) { NuGetVersion version = obj as NuGetVersion; return(String.Format(CultureInfo.InvariantCulture, "{0}.{1}.{2}-{3}GIT{4}", version.Major, version.Minor, version.Patch, version.Release, GetCommitFromMetadata(version.Metadata)).GetHashCode()); }
public int GetHashCode(SimpleVersion obj) { NuGetVersion version = obj as NuGetVersion; return String.Format(CultureInfo.InvariantCulture, "{0}.{1}.{2}-{3}GIT{4}", version.Major, version.Minor, version.Patch, version.Release, GetCommitFromMetadata(version.Metadata)).GetHashCode(); }
/// <summary> /// Gives a hash code based on the normalized version string. /// </summary> public int GetHashCode(SimpleVersion obj) { if (Object.ReferenceEquals(obj, null)) { return 0; } string verString = string.Empty; VersionFormatter formatter = new VersionFormatter(); if (_mode == VersionComparison.Default || _mode == VersionComparison.VersionRelease) { verString = obj.ToString("V-R", formatter).ToUpperInvariant(); } else if (_mode == VersionComparison.Version) { verString = obj.ToString("V", formatter); } else if (_mode == VersionComparison.VersionReleaseMetadata) { verString = String.Format(CultureInfo.InvariantCulture, "{0}+{1}", obj.ToString("V-R", formatter).ToUpperInvariant(), obj.ToString("M", formatter)); } if (String.IsNullOrEmpty(verString)) { verString = obj.ToNormalizedString().ToUpperInvariant(); } return verString.GetHashCode(); }
public static NuGet.SemanticVersion SafeToSemanticVersion(SimpleVersion simpleVersion) { if (simpleVersion == null) { return null; } return new NuGet.SemanticVersion(simpleVersion.ToNormalizedString()); }
public static NuGet.SemanticVersion SafeToSemanticVersion(SimpleVersion simpleVersion) { if (simpleVersion == null) { return(null); } return(new NuGet.SemanticVersion(simpleVersion.ToNormalizedString())); }
public OctoVersionInfo Create(SimpleVersion version) { var preReleaseTag = DerivePreReleaseTag(); var major = version.Major; if (_overriddenMajorVersion.HasValue) { _logger.Debug("Overriding derived major version {DerivedMajorVersion} with {OverriddenMajorVersion}", version.Major, _overriddenMajorVersion.Value); major = _overriddenMajorVersion.Value; } var minor = version.Minor; if (_overriddenMinorVersion.HasValue) { _logger.Debug("Overriding derived minor version {DerivedMinorVersion} with {OverriddenMinorVersion}", version.Minor, _overriddenMinorVersion.Value); minor = _overriddenMinorVersion.Value; } var patch = version.Patch; if (_overriddenPatchVersion.HasValue) { _logger.Debug("Overriding derived patch version {DerivedPatchVersion} with {OverriddenPatchVersion}", version.Patch, _overriddenPatchVersion.Value); patch = _overriddenPatchVersion.Value; } var buildMetadata = DeriveBuildMetadata(); if (!string.IsNullOrEmpty(_overriddenBuildMetadata)) { var sanitizedBuildMetadata = _sanitizer.Sanitize(_overriddenBuildMetadata); _logger.Debug("Overriding derived build metadata {DerivedBuildMetadata} with {OverriddenBuildMetadata}", buildMetadata, sanitizedBuildMetadata); buildMetadata = sanitizedBuildMetadata; } var result = new OctoVersionInfo(major, minor, patch, preReleaseTag, buildMetadata); return(result); }
public int Compare(SimpleVersion x, SimpleVersion y) { NuGetVersion versionX = x as NuGetVersion; NuGetVersion versionY = y as NuGetVersion; // compare without metadata int result = VersionComparer.VersionRelease.Compare(x, y); if (result != 0) return result; // compare git commits, form: buildmachine-gitcommit return GitCommitOrder(GetCommitFromMetadata(versionX.Metadata)).CompareTo(GitCommitOrder(GetCommitFromMetadata(versionY.Metadata))); }
public int Compare(SimpleVersion x, SimpleVersion y) { NuGetVersion versionX = x as NuGetVersion; NuGetVersion versionY = y as NuGetVersion; // compare without metadata int result = VersionComparer.VersionRelease.Compare(x, y); if (result != 0) { return(result); } // compare git commits, form: buildmachine-gitcommit return(GitCommitOrder(GetCommitFromMetadata(versionX.Metadata)).CompareTo(GitCommitOrder(GetCommitFromMetadata(versionY.Metadata)))); }
/// <summary> /// Creates a VersionRange with the given min and max. /// </summary> /// <param name="minVersion">Lower bound of the version range.</param> /// <param name="includeMinVersion">True if minVersion satisfies the condition.</param> /// <param name="maxVersion">Upper bound of the version range.</param> /// <param name="includeMaxVersion">True if maxVersion satisfies the condition.</param> /// <param name="includePrerelease">True if prerelease versions should satisfy the condition.</param> public VersionRange(SimpleVersion minVersion=null, bool includeMinVersion=true, SimpleVersion maxVersion=null, bool includeMaxVersion=false, bool? includePrerelease=null) { _minVersion = minVersion; _maxVersion = maxVersion; _includeMinVersion = includeMinVersion; _includeMaxVersion = includeMaxVersion; if (includePrerelease == null) { _includePrerelease = (_maxVersion != null && IsPrerelease(_maxVersion) == true) || (_minVersion != null && IsPrerelease(_minVersion) == true); } else { _includePrerelease = includePrerelease == true; } }
public SampleData WithVersion(SimpleVersion version) { Version = version; return(this); }
public virtual string GetManifestFileName(string packageId, SimpleVersion version) { return(packageId + ".nuspec"); }
public virtual string GetPackageFileName(string packageId, SimpleVersion version) { return(string.Format("{0}.{1}.nupkg", packageId, version)); }
public virtual string GetPackageDirectory(string packageId, SimpleVersion version) { return(Path.Combine(packageId, version.ToString())); }
private static bool? IsPrerelease(SimpleVersion version) { bool? b = null; SemanticVersion semVer = version as SemanticVersion; if (semVer != null) { b = semVer.IsPrerelease; } return b; }
/// <summary> /// Compare versions. /// </summary> public int Compare(SimpleVersion x, SimpleVersion y) { // null checks if (Object.ReferenceEquals(x, null) && Object.ReferenceEquals(y, null)) { return 0; } if (Object.ReferenceEquals(y, null)) { return 1; } if (Object.ReferenceEquals(x, null)) { return -1; } SemanticVersion semX = x as SemanticVersion; SemanticVersion semY = y as SemanticVersion; if (semX != null && semY != null) { // compare version int result = semX.Major.CompareTo(semY.Major); if (result != 0) return result; result = semX.Minor.CompareTo(semY.Minor); if (result != 0) return result; result = semX.Patch.CompareTo(semY.Patch); if (result != 0) return result; NuGetVersion legacyX = x as NuGetVersion; NuGetVersion legacyY = y as NuGetVersion; result = CompareLegacyVersion(legacyX, legacyY); if (result != 0) return result; if (_mode != VersionComparison.Version) { // compare release labels if (semX.IsPrerelease && !semY.IsPrerelease) return -1; if (!semX.IsPrerelease && semY.IsPrerelease) return 1; if (semX.IsPrerelease && semY.IsPrerelease) { result = CompareReleaseLabels(semX.ReleaseLabels, semY.ReleaseLabels); if (result != 0) return result; } // compare the metadata if (_mode == VersionComparison.VersionReleaseMetadata) { result = StringComparer.OrdinalIgnoreCase.Compare(semX.Metadata ?? string.Empty, semY.Metadata ?? string.Empty); if (result != 0) return result; } } } return 0; }
internal static bool VersionLessThanOrEquals(string a, string b) { return(SimpleVersion.Parse(a) <= SimpleVersion.Parse(b)); }
public void TheResultingVersionShouldBeCorrect(string input, SimpleVersion expected) { SimpleVersion.TryParse(input).ShouldBe(expected); }
/// <summary> /// Compares the given versions using the VersionComparison mode. /// </summary> public static int Compare(SimpleVersion version1, SimpleVersion version2, VersionComparison versionComparison) { IVersionComparer comparer = new VersionComparer(versionComparison); return comparer.Compare(version1, version2); }
public static void Run(SimpleVersion currentVersion) { }
public bool Equals(SimpleVersion x, SimpleVersion y) { return(Compare(x, y) == 0); }
/// <summary> /// Determines if an NuGetVersion meets the requirements. /// </summary> /// <param name="version">SemVer to compare</param> /// <returns>True if the given version meets the version requirements.</returns> public bool Satisfies(SimpleVersion version) { // ignore metadata by default when finding a range. return Satisfies(version, VersionComparer.VersionRelease); }
/// <summary> /// Determines if an NuGetVersion meets the requirements using the given mode. /// </summary> /// <param name="version">SemVer to compare</param> /// <param name="versionComparison">VersionComparison mode used to determine the version range.</param> /// <returns>True if the given version meets the version requirements.</returns> public bool Satisfies(SimpleVersion version, VersionComparison versionComparison) { return Satisfies(version, new VersionComparer(versionComparison)); }
internal static bool VersionNotEquals(string a, string b) { return(SimpleVersion.Parse(a) != SimpleVersion.Parse(b)); }
internal static bool VersionGreaterThanOrEquals(string a, string b) { return(SimpleVersion.Parse(a) >= SimpleVersion.Parse(b)); }
public virtual string GetInstallPath(string packageId, SimpleVersion version) { return(Path.Combine(_path, GetPackageDirectory(packageId, version))); }
public bool Equals(SimpleVersion x, SimpleVersion y) { return Compare(x, y) == 0; }
public string GetManifestFilePath(string packageId, SimpleVersion version) { return(Path.Combine(GetInstallPath(packageId, version), GetManifestFileName(packageId, version))); }
public string GetHashPath(string packageId, SimpleVersion version) { return(Path.Combine(GetInstallPath(packageId, version), string.Format("{0}.{1}.nupkg.sha512", packageId, version))); }
/// <summary> /// Determines if an NuGetVersion meets the requirements using the version comparer. /// </summary> /// <param name="version">SemVer to compare.</param> /// <param name="comparer">Version comparer used to determine if the version criteria is met.</param> /// <returns>True if the given version meets the version requirements.</returns> public bool Satisfies(SimpleVersion version, IVersionComparer comparer) { if (version == null) { throw new ArgumentNullException("version"); } // Determine if version is in the given range using the comparer. bool condition = true; if (HasLowerBound) { if (IsMinInclusive) { condition &= comparer.Compare(MinVersion, version) <= 0; } else { condition &= comparer.Compare(MinVersion, version) < 0; } } if (HasUpperBound) { if (IsMaxInclusive) { condition &= comparer.Compare(MaxVersion, version) >= 0; } else { condition &= comparer.Compare(MaxVersion, version) > 0; } } if (!IncludePrerelease) { condition &= IsPrerelease(version) != true; } return condition; }