private string Format(char c, VersionRange range) { string s = null; switch (c) { case 'P': s = PrettyPrint(range); break; case 'L': s = range.HasLowerBound ? String.Format(new VersionFormatter(), ZeroN, range.MinVersion) : string.Empty; break; case 'U': s = range.HasUpperBound ? String.Format(new VersionFormatter(), ZeroN, range.MaxVersion) : string.Empty; break; case 'S': s = GetToString(range); break; case 'N': s = GetNormalizedString(range); break; case 'D': s = GetLegacyString(range); break; } return s; }
//public SemanticVersionedRouteAttribute(int version) // : this(string.Empty, version) //{ //} public SemanticVersionedAttribute ( string version , string allowedVersionRange ) { Version = NuGetVersion.Parse(version); AllowedVersionRange = VersionRange.Parse(allowedVersionRange); }
public SemanticVersionConstraint(VersionRange allowedVersionRange) { //AllowedVersion = allowedVersion; AllowedVersionRange = allowedVersionRange; }
/// <summary> /// A pretty print representation of the VersionRange. /// </summary> private string PrettyPrint(VersionRange range) { StringBuilder sb = new StringBuilder("("); // no upper if (range.HasLowerBound && !range.HasUpperBound) { sb.Append(GreaterThanOrEqualTo); sb.AppendFormat(_versionFormatter, " {0:N}", range.MinVersion); } // single version else if (range.HasLowerAndUpperBounds && range.MaxVersion.Equals(range.MinVersion) && range.IsMinInclusive && range.IsMaxInclusive) { sb.AppendFormat(_versionFormatter, "= {0:N}", range.MinVersion); } else // normal range { if (range.HasLowerBound) { if (range.IsMinInclusive) { sb.AppendFormat(CultureInfo.InvariantCulture, "{0} ", GreaterThanOrEqualTo); } else { sb.Append("> "); } sb.AppendFormat(_versionFormatter, ZeroN, range.MinVersion); } if (range.HasLowerAndUpperBounds) { sb.Append(" && "); } if(range.HasUpperBound) { if (range.IsMaxInclusive) { sb.AppendFormat(CultureInfo.InvariantCulture, "{0} ", LessThanOrEqualTo); } else { sb.Append("< "); } sb.AppendFormat(_versionFormatter, ZeroN, range.MaxVersion); } } sb.Append(")"); // avoid () if (sb.Length == 2) { sb.Clear(); } return sb.ToString(); }
/// <summary> /// Builds a string to represent the VersionRange. This string can include short hand notations. /// </summary> private string GetToString(VersionRange range) { string s = null; if (range.HasLowerBound && range.IsMinInclusive && !range.HasUpperBound) { s = String.Format(_versionFormatter, ZeroN, range.MinVersion); } else if(range.HasLowerAndUpperBounds && range.IsMinInclusive && range.IsMaxInclusive && range.MinVersion.Equals(range.MaxVersion)) { // TODO: Does this need a specific version comparision? Does metadata matter? s = String.Format(_versionFormatter, "[{0:N}]", range.MinVersion); } else { s = GetNormalizedString(range); } return s; }
/// <summary> /// Builds a normalized string with no short hand /// </summary> private string GetNormalizedString(VersionRange range) { // TODO: write out the float version StringBuilder sb = new StringBuilder(); sb.Append(range.HasLowerBound && range.IsMinInclusive ? '[' : '('); if (range.HasLowerBound) { if (range.IsFloating) { sb.Append(range.Float.ToString()); } else { sb.AppendFormat(_versionFormatter, ZeroN, range.MinVersion); } } sb.Append(", "); if (range.HasUpperBound) { sb.AppendFormat(_versionFormatter, ZeroN, range.MaxVersion); } sb.Append(range.HasUpperBound && range.IsMaxInclusive ? ']' : ')'); return sb.ToString(); }
/// <summary> /// Parses a VersionRange from its string representation. /// </summary> public static bool TryParse(string value, bool allowFloating, out VersionRange versionRange) { if (value == null) { throw new ArgumentNullException("value"); } versionRange = null; value = value.Trim(); char[] charArray = value.ToCharArray(); // * is the only range below 3 chars if (allowFloating && charArray.Length == 1 && charArray[0] == '*') { versionRange = AllStableFloating; return true; } // Fail early if the string is too short to be valid if (charArray.Length < 3) { return false; } string minVersionString = null; string maxVersionString = null; bool isMinInclusive = false; bool isMaxInclusive = false; NuGetVersion minVersion = null; NuGetVersion maxVersion = null; FloatRange floatRange = null; if (charArray[0] == '(' || charArray[0] == '[') { // The first character must be [ to ( switch (charArray[0]) { case '[': isMinInclusive = true; break; case '(': isMinInclusive = false; break; default: return false; } // The last character must be ] ot ) switch (charArray[charArray.Length - 1]) { case ']': isMaxInclusive = true; break; case ')': isMaxInclusive = false; break; default: return false; } // Get rid of the two brackets value = value.Substring(1, value.Length - 2); // Split by comma, and make sure we don't get more than two pieces string[] parts = value.Split(','); if (parts.Length > 2) { return false; } else if (parts.All(String.IsNullOrEmpty)) { // If all parts are empty, then neither of upper or lower bounds were specified. Version spec is of the format (,] return false; } // If there is only one piece, we use it for both min and max minVersionString = parts[0]; maxVersionString = (parts.Length == 2) ? parts[1] : parts[0]; } else { // default to min inclusive when there are no braces isMinInclusive = true; // use the entire value as the version minVersionString = value; } if (!String.IsNullOrWhiteSpace(minVersionString)) { // parse the min version string if (allowFloating && minVersionString.Contains("*")) { // single floating version if (FloatRange.TryParse(minVersionString, out floatRange) && floatRange.HasMinVersion) { minVersion = floatRange.MinVersion; } else { // invalid float return false; } } else { // single non-floating version if (!NuGetVersion.TryParse(minVersionString, out minVersion)) { // invalid version return false; } } } // parse the max version string, the max cannot float if (!String.IsNullOrWhiteSpace(maxVersionString)) { if (!NuGetVersion.TryParse(maxVersionString, out maxVersion)) { // invalid version return false; } } // Successful parse! versionRange = new VersionRange( minVersion: minVersion, includeMinVersion: isMinInclusive, maxVersion: maxVersion, includeMaxVersion: isMaxInclusive, includePrerelease: null, floatRange: floatRange); return true; }
/// <summary> /// Parses a VersionRange from its string representation. /// </summary> public static bool TryParse(string value, out VersionRange versionRange) { return TryParse(value, true, out versionRange); }
/// <summary> /// Returns the smallest range that includes all given ranges. /// </summary> public static VersionRange Combine(IEnumerable<VersionRange> ranges, IVersionComparer comparer) { VersionRange result = VersionRange.None; if (ranges.Any()) { VersionRangeComparer rangeComparer = new VersionRangeComparer(comparer); // remove zero ranges ranges = ranges.Where(r => !rangeComparer.Equals(r, VersionRange.None)); var first = ranges.First(); NuGetVersion lowest = first.MinVersion; bool includeLowest = first.IsMinInclusive; NuGetVersion highest = first.MaxVersion; bool includeHighest = first.IsMaxInclusive; bool includePre = first.IncludePrerelease; foreach (var range in ranges.Skip(1)) { includePre |= range.IncludePrerelease; if (!range.HasLowerBound) { lowest = null; includeLowest |= range.IsMinInclusive; } else if (comparer.Compare(range.MinVersion, lowest) < 0) { lowest = range.MinVersion; includeLowest = range.IsMinInclusive; } if (!range.HasUpperBound) { highest = null; includeHighest |= range.IsMinInclusive; } else if (comparer.Compare(range.MinVersion, highest) > 0) { highest = range.MinVersion; includeHighest = range.IsMinInclusive; } } result = new VersionRange(lowest, includeLowest, highest, includeHighest, includePre); } return result; }
/// <summary> /// Returns the smallest range that includes all given versions. /// </summary> public static VersionRange Combine(IEnumerable<NuGetVersion> versions, IVersionComparer comparer) { VersionRange result = VersionRange.None; if (versions.Any()) { IEnumerable<NuGetVersion> ordered = versions.OrderBy(v => v, comparer); result = new VersionRange(ordered.FirstOrDefault(), true, ordered.LastOrDefault(), true); } return result; }
/// <summary> /// A pretty print representation of the VersionRange. /// </summary> private string PrettyPrint(VersionRange range) { StringBuilder sb = new StringBuilder("("); // no upper if (range.HasLowerBound && !range.HasUpperBound) { sb.Append(GreaterThanOrEqualTo); sb.AppendFormat(_versionFormatter, " {0:N}", range.MinVersion); } // single version else if (range.HasLowerAndUpperBounds && range.MaxVersion.Equals(range.MinVersion) && range.IsMinInclusive && range.IsMaxInclusive) { sb.AppendFormat(_versionFormatter, "= {0:N}", range.MinVersion); } else // normal range { if (range.HasLowerBound) { if (range.IsMinInclusive) { sb.AppendFormat(CultureInfo.InvariantCulture, "{0} ", GreaterThanOrEqualTo); } else { sb.Append("> "); } sb.AppendFormat(_versionFormatter, ZeroN, range.MinVersion); } if (range.HasLowerAndUpperBounds) { sb.Append(" && "); } if (range.HasUpperBound) { if (range.IsMaxInclusive) { sb.AppendFormat(CultureInfo.InvariantCulture, "{0} ", LessThanOrEqualTo); } else { sb.Append("< "); } sb.AppendFormat(_versionFormatter, ZeroN, range.MaxVersion); } } sb.Append(")"); // avoid () if (sb.Length == 2) { sb.Clear(); } return(sb.ToString()); }
/// <summary> /// Clones a version range and applies a new float range. /// </summary> public VersionRange(VersionRange range, FloatRange floatRange) : this(range.MinVersion, range.IsMinInclusive, range.MaxVersion, range.IsMaxInclusive, range.IncludePrerelease, floatRange) { }