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)
{
}
