public static async Task <PackageInfo> FindBestMatchPackage(
IEnumerable <IPackageFeed> packageFeeds,
string packageName,
SemanticVersionRange idealVersion)
{
var tasks = new List <Task <IEnumerable <PackageInfo> > >();
foreach (var feed in packageFeeds)
{
tasks.Add(feed.FindPackagesByIdAsync(packageName));
}
var results = (await Task.WhenAll(tasks)).SelectMany(x => x);
PackageInfo bestResult = null;
foreach (var result in results)
{
if (VersionUtility.ShouldUseConsidering(
current: bestResult?.Version,
considering: result.Version,
ideal: idealVersion))
{
bestResult = result;
}
}
return(bestResult);
}
public static bool EqualsFloating(this SemanticVersionRange versionRange, SemanticVersion version)
{
switch (versionRange.VersionFloatBehavior)
{
case SemanticVersionFloatBehavior.Prerelease:
return(versionRange.MinVersion.Version == version.Version &&
version.SpecialVersion.StartsWith(versionRange.MinVersion.SpecialVersion, StringComparison.OrdinalIgnoreCase));
case SemanticVersionFloatBehavior.Revision:
return(versionRange.MinVersion.Version.Major == version.Version.Major &&
versionRange.MinVersion.Version.Minor == version.Version.Minor &&
versionRange.MinVersion.Version.Build == version.Version.Build &&
versionRange.MinVersion.Version.Revision == version.Version.Revision);
case SemanticVersionFloatBehavior.Build:
return(versionRange.MinVersion.Version.Major == version.Version.Major &&
versionRange.MinVersion.Version.Minor == version.Version.Minor &&
versionRange.MinVersion.Version.Build == version.Version.Build);
case SemanticVersionFloatBehavior.Minor:
return(versionRange.MinVersion.Version.Major == version.Version.Major &&
versionRange.MinVersion.Version.Minor == version.Version.Minor);
case SemanticVersionFloatBehavior.Major:
return(versionRange.MinVersion.Version.Major == version.Version.Major);
case SemanticVersionFloatBehavior.None:
return(versionRange.MinVersion == version);
default:
return(false);
}
}
public static async Task<PackageInfo> FindBestMatchPackage(
IEnumerable<IPackageFeed> packageFeeds,
string packageName,
SemanticVersionRange idealVersion)
{
var tasks = new List<Task<IEnumerable<PackageInfo>>>();
foreach (var feed in packageFeeds)
{
tasks.Add(feed.FindPackagesByIdAsync(packageName));
}
var results = (await Task.WhenAll(tasks)).SelectMany(x => x);
PackageInfo bestResult = null;
foreach (var result in results)
{
if (VersionUtility.ShouldUseConsidering(
current: bestResult?.Version,
considering: result.Version,
ideal: idealVersion))
{
bestResult = result;
}
}
return bestResult;
}
public void VersionRangeToString()
{
var range = new SemanticVersionRange
{
MinVersion = new SemanticVersion("1.0.0-beta"),
MaxVersion = new SemanticVersion("1.0.0-beta")
};
Assert.Equal("1.0.0-beta", range.ToString());
}
public void Should_Return_False_For_Higher_Version_When_Range_Is_Inclusive_Single_Version()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("[1.0]", out range);
// Then
Assert.False(range.IsIncluded("1.1"));
}
public void Should_Give_Correct_Rule_When_Range_Is_Single_Version()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("1.0", out range);
// Then
Assert.IsType <GreaterThanOrEqualsRule>(range.Rules[0]);
}
public void Should_Return_False_For_Version_Same_As_Upper_When_Range_Is_Inclusive_Lower_Exclusive_Upper()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("[1.0,2.0)", out range);
// Then
Assert.False(range.IsIncluded("2.0"));
}
public void Should_Return_True_For_Version_Between_Lower_And_Upper_When_Range_Is_Exclusive_Lower_Inclusive_Upper()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("(1.0,2.0]", out range);
// Then
Assert.True(range.IsIncluded("1.5"));
}
public void Should_Return_False_For_Version_Lower_Than_Lower_When_Range_Is_Exclusive_Lower_Inclusive_Upper()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("(1.0,2.0]", out range);
// Then
Assert.False(range.IsIncluded("0.9"));
}
public void Should_Give_Correct_Rule_When_Range_Is_Exclusive_No_Lower_With_Exclusive_Upper()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("(,1.0)", out range);
// Then
Assert.IsType <LessThanRule>(range.Rules[0]);
}
public IWebLibrary Find(string name, SemanticVersionRange range)
{
if (items.TryGetValue(name, out IWebLibrary lib))
{
return(lib);
}
else
{
throw new Exception($"No library named '{name}' was not found");
}
}
public void Should_Return_False_For_Higher_Version_When_Range_Is_Exclusive_No_Lower_With_Exclusive_Upper()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("(,1.0)", out range);
// Then
Assert.False(range.IsIncluded("1.0"));
}
public void Should_Give_Correct_Rule_When_Range_Is_Inclusive_Single_Version()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("[1.0]", out range);
// Then
Assert.IsType <EqualsRule>(range.Rules[0]);
}
public void Should_Return_True_For_Lower_Version_When_Range_Is_Exclusive_No_Lower_With_Inclusive_Upper()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("(,1.0]", out range);
// Then
Assert.True(range.IsIncluded("0.9"));
}
public void Should_Return_True_For_Higher_Version_When_Range_Is_Exclusive_Lower_Exclusive_No_Upper()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("(1.0,)", out range);
// Then
Assert.True(range.IsIncluded("1.1"));
}
public void Should_Return_True_For_Same_Version_When_Range_Is_Single_Version()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("1.0", out range);
// Then
Assert.True(range.IsIncluded("1.0"));
}
public void Should_Give_No_Rule_When_Range_Is_Exclusive_Single_Version()
{
// Given
SemanticVersionRange range;
// When
var result = SemanticVersionRange.TryParse("(1.0)", out range);
// Then
Assert.False(result);
Assert.Null(range);
}
public void Should_Give_Correct_Rule_When_Range_Is_Exclusive_Lower_With_Inclusive_Upper()
{
// Given
SemanticVersionRange range;
// When
SemanticVersionRange.TryParse("(1.0,2.0]", out range);
// Then
Assert.IsType <GreaterThanRule>(range.Rules[0]);
Assert.IsType <LessThanOrEqualsRule>(range.Rules[1]);
}
public void Should_Return_False_If_Range_Upper_Is_Invalid()
{
// Given
SemanticVersionRange range;
// When
var result = SemanticVersionRange.TryParse("(1.0,invalid)", out range);
// Then
Assert.False(result);
Assert.Null(range);
}
public IEnumerable <Dependency> Parse(JToken value)
{
var dependencyList = value as JArray;
if (dependencyList == null)
{
throw new InvalidDataException("Value of 'dependencies' must be an array.");
}
if (dependencyList.Children().Any(c => c.Type != JTokenType.Object))
{
throw new InvalidDataException("Elements of the 'dependencies' array must be objects.");
}
var result = new List <Dependency>();
foreach (var item in dependencyList.Children <JObject>())
{
var props = item.Properties().OrderBy(p => p.Name).Select(p => p.Name).ToList();
if (!ValidDependencyProperties.SequenceEqual(props))
{
var unexpectedProperties = string.Join(",", props.Except(ValidDependencyProperties));
throw new UnexpectedPropertyException(unexpectedProperties);
}
var id = item["id"].Value <string>();
var version = item["version"].Value <string>();
SemanticVersionRange range;
if (!SemanticVersionRange.TryParse(version, out range))
{
throw new InvalidDataException("Invalid semantic version range: " + version);
}
result.Add(new Dependency
{
Name = id,
VersionRange = range
});
}
return(result);
}
public PackageDependency(string id, SemanticVersionRange versionRange)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException(nameof(id));
}
Id = id;
VersionSpec = versionRange != null ?
new VersionSpec
{
IsMinInclusive = true,
IsMaxInclusive = versionRange.IsMaxInclusive,
MinVersion = versionRange.MinVersion,
MaxVersion = versionRange.MaxVersion
} :
null;
}
public PackageDependency(string id, SemanticVersionRange versionRange)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException(nameof(id));
}
Id = id;
VersionSpec = versionRange != null ?
new VersionSpec
{
IsMinInclusive = true,
IsMaxInclusive = versionRange.IsMaxInclusive,
MinVersion = versionRange.MinVersion,
MaxVersion = versionRange.MaxVersion
} :
null;
}
public static bool ShouldUseConsidering(
SemanticVersion current,
SemanticVersion considering,
SemanticVersionRange ideal)
{
if (considering == null)
{
// skip nulls
return(false);
}
if (!ideal.EqualsFloating(considering) && considering < ideal.MinVersion)
{
// Don't use anything that can't be satisfied
return(false);
}
/*
* Come back to this later
* if (ideal.VersionFloatBehavior == SemanticVersionFloatBehavior.None &&
* considering != ideal.MinVersion)
* {
* return false;
* }
*/
if (current == null)
{
// always use version when it's the first valid
return(true);
}
if (ideal.EqualsFloating(current) &&
ideal.EqualsFloating(considering))
{
// favor higher version when they both match a floating pattern
return(current < considering);
}
// Favor lower versions
return(current > considering);
}
private PackageInfo FindCandidate(string name, SemanticVersionRange versionRange)
{
var packages = _repository.FindPackagesById(name);
if (versionRange == null)
{
// TODO: Disallow null versions for nuget packages
var packageInfo = packages.FirstOrDefault();
if (packageInfo != null)
{
return packageInfo;
}
return null;
}
PackageInfo bestMatch = null;
foreach (var packageInfo in packages)
{
if (VersionUtility.ShouldUseConsidering(
current: bestMatch?.Version,
considering: packageInfo.Version,
ideal: versionRange))
{
bestMatch = packageInfo;
}
}
if (bestMatch == null)
{
return null;
}
return bestMatch;
}
public void ToString_should_render_proper_NuGet_style_range_strings()
{
// Arrange
var formats = new[] {"1.0", "(,1.0]", "(,1.0)", "[1.0]", "(1.0,)", "(1.0,2.0)", "[1.0,2.0]"};
foreach (var format in formats)
{
// Act
var range = new SemanticVersionRange(format);
// Assert
var actual = range.ToString().Should().Be(format);
}
}
public void Parse_should_return_parsed_range()
{
// Arrange
var expected = new SemanticVersionRange("1.0");
// Act
var actual = SemanticVersionRange.Parse("1.0");
// Assert
actual.Should().Be(expected);
}
