/// <summary>
/// Мигратор.
/// </summary>
/// <param name="configuration">Конфигурация проекта.</param>
/// <param name="unitOfWorkFactory">Фабрика единиц работы.</param>
/// <param name="loggerFactory">Фабрика логеров.</param>
/// <param name="versionNumberComparer">Компаратор версий БД.</param>
public Migrator(IConfiguration configuration, IUnitOfWorkFactory unitOfWorkFactory, ILoggerFactory loggerFactory, IVersionComparer versionNumberComparer)
{
this.unitOfWorkFactory = unitOfWorkFactory;
this.configuration = configuration;
this.logger = loggerFactory.CreateLogger(string.Empty);
this.versionNumberComparer = versionNumberComparer;
}
public override async Task <Stream> GetStream(PackageIdentity identity, CancellationToken token)
{
Stream result = null;
IPackage package = null;
SemanticVersion version = SemanticVersion.Parse(identity.Version.ToString());
// attempt a normal lookup first
if (!V2Client.TryFindPackage(identity.Id, version, out package))
{
// skip further look ups for online repos
DataServicePackageRepository v2Online = V2Client as DataServicePackageRepository;
if (v2Online == null)
{
IVersionComparer versionComparer = VersionComparer.VersionRelease;
// otherwise search further to find the package - this is needed for v2 non-normalized versions
V2Client.FindPackagesById(identity.Id).Any(p => versionComparer.Equals(identity.Version, NuGetVersion.Parse(p.ToString())));
}
}
if (package != null)
{
result = package.GetStream();
}
return(result);
}
/// <summary>
/// Compare versions with a specific IVersionComparer
/// </summary>
public VersionRangeComparer(IVersionComparer versionComparer)
{
if (versionComparer == null)
{
throw new ArgumentNullException("versionComparer");
}
_versionComparer = versionComparer;
}
/// <summary>
/// Compare versions with a specific IVersionComparer
/// </summary>
public PackageIdentityComparer(IVersionComparer versionComparer)
{
if (versionComparer == null)
{
throw new ArgumentNullException("versionComparer");
}
_versionComparer = versionComparer;
}
/// <summary>
/// Compare versions with a specific IVersionComparer
/// </summary>
public PackageIdentityComparer(IVersionComparer versionComparer)
{
if (versionComparer == null)
{
throw new ArgumentNullException("versionComparer");
}
_versionComparer = versionComparer;
}
/// <summary>
/// Compare versions with a specific IVersionComparer
/// </summary>
public VersionRangeComparer(IVersionComparer versionComparer)
{
if (versionComparer == null)
{
throw new ArgumentNullException("versionComparer");
}
_versionComparer = versionComparer;
}
public TargetCompatibilityReferenceAnalyzer(
IPackageLoader packageLoader,
IVersionComparer comparer,
ILogger <TargetCompatibilityReferenceAnalyzer> logger)
{
_packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader));
_comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public WindowsCompatReferenceAnalyzer(
IPackageLoader loader,
IVersionComparer comparer,
ILogger <WindowsCompatReferenceAnalyzer> logger)
{
_logger = logger;
_loader = loader;
_comparer = comparer;
}
/// <summary>
/// Returns the greatest common range that satisfies all given ranges.
/// </summary>
public static VersionRange CommonSubSet(IEnumerable <VersionRange> ranges, IVersionComparer comparer)
{
if (ranges == null)
{
throw new ArgumentNullException(nameof(ranges));
}
if (comparer == null)
{
throw new ArgumentNullException(nameof(comparer));
}
// return None in case of any invalid range like (1.0.0, 1.0.0)
// This also includes VersionRange.None and any other ranges that satisfy zero versions
var versionRanges = ranges as VersionRange[] ?? ranges.ToArray();
if (!versionRanges.Any() || versionRanges.Any(range => !HasValidRange(range)))
{
return(None);
}
// find out maximum lowest bound and minimum highest bound to form common subset
var lowest = versionRanges.Where(range => range.HasLowerBound).Max(range => range.MinVersion);
var highest = versionRanges.Where(range => range.HasUpperBound).Min((range => range.MaxVersion));
// exclude this lowest if any range has this lowest as excluded, else include
var excludeLowest = versionRanges.Any(range => range.HasLowerBound &&
comparer.Compare(range.MinVersion, lowest) == 0 &&
!range.IsMinInclusive);
// exclude this highest if any range has this highest excluded, else include
var excludeHighest = versionRanges.Any(range => range.HasUpperBound &&
comparer.Compare(range.MaxVersion, highest) == 0 &&
!range.IsMaxInclusive);
// finally check the final lowest n highest versions
if (lowest != null && highest != null)
{
var compare = comparer.Compare(lowest, highest);
if (compare > 0)
{
return(None);
}
if (compare == 0)
{
excludeHighest = excludeLowest |= excludeHighest;
}
}
// Create the new range using the minimums found
var result = new VersionRange(lowest, !excludeLowest, highest, !excludeHighest);
return(HasValidRange(result) ? result : None);
}
public static PackageIdentity[] GetLatest(this PackageCollection packages, IVersionComparer versionComparer)
{
return(packages
.GroupBy(p => p.Id, p => p.Version, StringComparer.OrdinalIgnoreCase)
//max or default
.Select(g => new PackageIdentity(
g.Key,
g.OrderByDescending(v => v, versionComparer)
.FirstOrDefault()))
.ToArray());
}
public DependencyInfoResourceV2(IPackageRepository repo)
{
V2Client = repo;
_rangeSearched = new ConcurrentDictionary <string, VersionRange>(StringComparer.OrdinalIgnoreCase);
_found = new ConcurrentDictionary <string, HashSet <PackageDependencyInfo> >(StringComparer.OrdinalIgnoreCase);
_lockObjsById = new ConcurrentDictionary <string, object>(StringComparer.OrdinalIgnoreCase);
_frameworkReducer = new FrameworkReducer();
_packageDepComparer = new PackageDependencyComparer();
_versionComparer = VersionComparer.VersionRelease;
_versionRangeComparer = VersionRangeComparer.VersionRelease;
}
public PackageMapReferenceAnalyzer(
PackageMapProvider packageMapProvider,
IPackageLoader packageLoader,
IVersionComparer comparer,
ILogger <PackageMapReferenceAnalyzer> logger)
{
_packageMapProvider = packageMapProvider ?? throw new ArgumentNullException(nameof(packageMapProvider));
_packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader));
_comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
private static int Compare(IVersionComparer comparer, string version1, string version2)
{
// Act
var x = CompareOneWay(comparer, version1, version2);
var y = CompareOneWay(comparer, version2, version1) * -1;
// Assert
Assert.Equal(x, y);
return(x);
}
public WindowsCompatReferenceAnalyzer(
ITransitiveDependencyIdentifier transitiveIdentifier,
IPackageLoader loader,
IVersionComparer comparer,
ILogger <WindowsCompatReferenceAnalyzer> logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_transitiveIdentifier = transitiveIdentifier ?? throw new ArgumentNullException(nameof(transitiveIdentifier));
_loader = loader ?? throw new ArgumentNullException(nameof(loader));
_comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
}
private static int Compare(IVersionComparer comparer, string version1, string version2)
{
// Act
var x = CompareOneWay(comparer, version1, version2);
var y = CompareOneWay(comparer, version2, version1) * -1;
// Assert
Assert.Equal(x, y);
return x;
}
/// <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);
}
public DependencyInfoResourceV2(IPackageRepository repo)
{
V2Client = repo;
_rangeSearched = new ConcurrentDictionary<string, VersionRange>(StringComparer.OrdinalIgnoreCase);
_found = new ConcurrentDictionary<string, HashSet<PackageDependencyInfo>>(StringComparer.OrdinalIgnoreCase);
_lockObjsById = new ConcurrentDictionary<string, object>(StringComparer.OrdinalIgnoreCase);
_frameworkReducer = new FrameworkReducer();
_packageDepComparer = new PackageDependencyComparer();
_versionComparer = VersionComparer.VersionRelease;
_versionRangeComparer = VersionRangeComparer.VersionRelease;
_useFindById = !(repo is DataServicePackageRepository);
}
/// <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);
}
private static bool EqualsOneWayWithNuGetVersion(IVersionComparer comparer, string version1, string version2)
{
// Arrange
var a = NuGetVersion.Parse(version1);
var b = NuGetVersion.Parse(version2);
// Act
var match = comparer.Compare(a, b) == 0;
match &= comparer.Equals(a, b);
match &= comparer.GetHashCode(a) == comparer.GetHashCode(b);
return(match);
}
public void GetHashCode_WhenArgumentIsValid_ReturnsHashCode()
{
var range = new VersionRange(Version100, includeMinVersion: true, Version200, includeMaxVersion: true);
var combiner = new HashCodeCombiner();
IVersionComparer comparer = VersionComparer.Default;
combiner.AddObject(range.IsMinInclusive);
combiner.AddObject(range.IsMaxInclusive);
combiner.AddObject(comparer.GetHashCode(range.MinVersion));
combiner.AddObject(comparer.GetHashCode(range.MaxVersion));
int expectedResult = combiner.CombinedHash;
int actualResult = VersionRangeComparer.Default.GetHashCode(range);
Assert.Equal(expectedResult, actualResult);
}
public PackageMapReferenceAnalyzer(
IOptions <ICollection <NuGetPackageMap[]> > packageMaps,
IPackageLoader packageLoader,
IVersionComparer comparer,
ILogger <PackageMapReferenceAnalyzer> logger)
{
if (packageMaps is null)
{
throw new ArgumentNullException(nameof(packageMaps));
}
_packageMaps = packageMaps.Value.SelectMany(p => p);
_packageLoader = packageLoader ?? throw new ArgumentNullException(nameof(packageLoader));
_comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
private static bool DoesHaveMinimumXamarinVersion(IProject project, IVersionComparer comparer)
{
var packageReferences = project.NuGetReferences.PackageReferences;
foreach (var package in packageReferences)
{
if (package.Name == "Xamarin.Forms")
{
if (comparer.Compare(package.Version, MINIMUM_XAMARIN_VERSION) > 0)
{
return(true);
}
}
}
return(false);
}
public static int Compare(IVersionComparer comparer, string version1, string version2)
{
// Arrange
NuGetVersion a = NuGetVersion.Parse(version1);
NuGetVersion b = NuGetVersion.Parse(version2);
SemanticVersion c = SemanticVersion.Parse(version1);
SemanticVersion d = SemanticVersion.Parse(version2);
// Act
List <int> results = new List <int>();
results.Add(comparer.Compare(a, b));
results.Add(comparer.Compare(a, d));
results.Add(comparer.Compare(c, b));
results.Add(comparer.Compare(c, d));
return(results[3]);
}
private static bool EqualsOneWay(IVersionComparer comparer, string version1, string version2)
{
// Arrange
var a = NuGetVersion.Parse(version1);
var b = NuGetVersion.Parse(version2);
SemanticVersion c = NuGetVersion.Parse(version1);
SemanticVersion d = NuGetVersion.Parse(version2);
// Act
var match = Compare(comparer, version1, version2) == 0;
match &= comparer.Equals(a, b);
match &= comparer.Equals(a, d);
match &= comparer.Equals(c, d);
match &= comparer.Equals(c, b);
return(match);
}
private static int CompareOneWay(IVersionComparer comparer, string version1, string version2)
{
// Arrange
var a = NuGetVersion.Parse(version1);
var b = NuGetVersion.Parse(version2);
var c = SemanticVersion.Parse(version1);
var d = SemanticVersion.Parse(version2);
// Act
var results = new List<int>();
results.Add(comparer.Compare(a, b));
results.Add(comparer.Compare(a, d));
results.Add(comparer.Compare(c, b));
results.Add(comparer.Compare(c, d));
// Assert
Assert.True(results.FindAll(x => x == results[0]).Count == results.Count);
return results[0];
}
/// <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(NuGetVersion 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);
}
private static int CompareOneWay(IVersionComparer comparer, string version1, string version2)
{
// Arrange
var a = NuGetVersion.Parse(version1);
var b = NuGetVersion.Parse(version2);
var c = SemanticVersion.Parse(version1);
var d = SemanticVersion.Parse(version2);
// Act
var results = new List <int>();
results.Add(comparer.Compare(a, b));
results.Add(comparer.Compare(a, d));
results.Add(comparer.Compare(c, b));
results.Add(comparer.Compare(c, d));
// Assert
Assert.True(results.FindAll(x => x == results[0]).Count == results.Count);
return(results[0]);
}
public ResolverComparer(DependencyBehavior dependencyBehavior,
HashSet <PackageIdentity> preferredVersions,
HashSet <string> targetIds)
{
_dependencyBehavior = dependencyBehavior;
_preferredVersions = preferredVersions;
_targetIds = targetIds;
_versionComparer = VersionComparer.Default;
_identityComparer = PackageIdentity.Comparer;
_installedVersions = new Dictionary <string, NuGetVersion>();
if (_installedVersions != null)
{
foreach (var package in _preferredVersions)
{
if (package.Version != null)
{
_installedVersions.Add(package.Id, package.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;
}
public TransitiveReferenceAnalyzer(ITransitiveDependencyIdentifier transitiveChecker, IVersionComparer comparer)
{
_transitiveChecker = transitiveChecker ?? throw new ArgumentNullException(nameof(transitiveChecker));
_comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
}
/// <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;
}
private static bool Equals(IVersionComparer comparer, string version1, string version2)
{
return EqualsOneWay(comparer, version1, version2) && EqualsOneWay(comparer, version2, version1);
}
/// <summary>
/// SubSet check
/// </summary>
public bool IsSubSetOrEqualTo(VersionRangeBase possibleSuperSet, IVersionComparer comparer)
{
VersionRangeComparer rangeComparer = new VersionRangeComparer(comparer);
VersionRangeBase possibleSubSet = this;
VersionRangeBase target = possibleSuperSet;
if (rangeComparer.Equals(possibleSubSet, VersionRange.None))
{
return(true);
}
if (rangeComparer.Equals(target, VersionRange.None))
{
return(false);
}
if (target == null)
{
target = VersionRange.All;
}
if (possibleSubSet == null)
{
possibleSubSet = VersionRange.All;
}
bool result = true;
if (possibleSubSet.IncludePrerelease && !target.IncludePrerelease)
{
result = false;
}
if (possibleSubSet.HasLowerBound)
{
// normal check
if (!target.Satisfies(possibleSubSet.MinVersion))
{
// it's possible we didn't need that version, do a special non inclusive check
if (!possibleSubSet.IsMinInclusive && !target.IsMinInclusive)
{
result &= comparer.Equals(target.MinVersion, possibleSubSet.MinVersion);
}
else
{
result = false;
}
}
}
else
{
result &= !target.HasLowerBound;
}
if (possibleSubSet.HasUpperBound)
{
// normal check
if (!target.Satisfies(possibleSubSet.MaxVersion))
{
// it's possible we didn't need that version, do a special non inclusive check
if (!possibleSubSet.IsMaxInclusive && !target.IsMaxInclusive)
{
result &= comparer.Equals(target.MaxVersion, possibleSubSet.MaxVersion);
}
else
{
result = false;
}
}
}
else
{
result &= !target.HasUpperBound;
}
return(result);
}
/// <summary>
/// Use a specific IVersionComparer for comparison
/// </summary>
public bool Equals(VersionRangeBase other, IVersionComparer versionComparer)
{
IVersionRangeComparer comparer = new VersionRangeComparer(versionComparer);
return(Equals(other, comparer));
}
private static bool EqualsOneWay(IVersionComparer comparer, string version1, string version2)
{
// Arrange
var a = NuGetVersion.Parse(version1);
var b = NuGetVersion.Parse(version2);
SemanticVersion c = NuGetVersion.Parse(version1);
SemanticVersion d = NuGetVersion.Parse(version2);
// Act
var match = Compare(comparer, version1, version2) == 0;
match &= comparer.Equals(a, b);
match &= comparer.Equals(a, d);
match &= comparer.Equals(c, d);
match &= comparer.Equals(c, b);
return match;
}
/// <summary>
/// Returns the smallest range that includes all given ranges.
/// </summary>
public static VersionRange Combine(IEnumerable<VersionRange> ranges, IVersionComparer comparer)
{
if (ranges == null)
{
throw new ArgumentNullException(nameof(ranges));
}
if (comparer == null)
{
throw new ArgumentNullException(nameof(comparer));
}
// Default to None for empty lists
var result = None;
// Remove zero width ranges. Ex: (1.0.0, 1.0.0)
// This includes VersionRange.None and any other ranges that satisfy zero versions
ranges = ranges.Where(range => HasValidRange(range));
if (ranges.Any())
{
var rangeComparer = new VersionRangeComparer(comparer);
// start with the first range in the list
var first = ranges.First();
var lowest = first.MinVersion;
var highest = first.MaxVersion;
var includePre = first.IncludePrerelease;
// To keep things consistent set min/max inclusive to false when there is no boundary
// It is possible to denote an inclusive range with no bounds, but it has no useful meaning for combine
var includeLowest = first.IsMinInclusive && first.HasLowerBound;
var includeHighest = first.IsMaxInclusive && first.HasUpperBound;
// expand the range to inclue all other ranges
foreach (var range in ranges.Skip(1))
{
// allow prerelease versions in the range if any range allows them
includePre |= range.IncludePrerelease;
// once we have an unbounded lower we can stop checking
if (lowest != null)
{
if (range.HasLowerBound)
{
var lowerCompare = comparer.Compare(range.MinVersion, lowest);
if (lowerCompare < 0)
{
// A new lowest was found
lowest = range.MinVersion;
includeLowest = range.IsMinInclusive;
}
else if (lowerCompare == 0)
{
// The lower ends are identical, update the inclusiveness
includeLowest |= range.IsMinInclusive;
}
// lowerCompare > 0 falls into the current range, this is a no-op
}
else
{
// No lower bound
lowest = null;
includeLowest = false;
}
}
// null is the highest we can get, stop checking once it is hit
if (highest != null)
{
if (range.HasUpperBound)
{
var higherCompare = comparer.Compare(range.MaxVersion, highest);
if (higherCompare > 0)
{
// A new highest was found
highest = range.MaxVersion;
includeHighest = range.IsMaxInclusive;
}
else if (higherCompare == 0)
{
// The higher ends are identical, update the inclusiveness
includeHighest |= range.IsMaxInclusive;
}
// higherCompare < 0 falls into the current range, this is a no-op
}
else
{
// No higher bound
highest = null;
includeHighest = false;
}
}
}
// Create the new range using the maximums found
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)
{
var result = None;
if (versions.Any())
{
IEnumerable<NuGetVersion> ordered = versions.OrderBy(v => v, comparer);
result = new VersionRange(ordered.FirstOrDefault(), true, ordered.LastOrDefault(), true);
}
return result;
}
private static bool EqualsWithNuGetVersion(IVersionComparer comparer, string version1, string version2)
{
return(EqualsOneWayWithNuGetVersion(comparer, version1, version2) && EqualsOneWayWithNuGetVersion(comparer, version2, version1));
}
public DuplicateReferenceAnalyzer(IVersionComparer comparer, ILogger <DuplicateReferenceAnalyzer> logger)
{
_comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
/// <summary>
/// Returns the smallest range that includes all given ranges.
/// </summary>
public static VersionRange Combine(IEnumerable <VersionRange> ranges, IVersionComparer comparer)
{
if (ranges == null)
{
throw new ArgumentNullException(nameof(ranges));
}
if (comparer == null)
{
throw new ArgumentNullException(nameof(comparer));
}
// Default to None for empty lists
var result = None;
// Remove zero width ranges. Ex: (1.0.0, 1.0.0)
// This includes VersionRange.None and any other ranges that satisfy zero versions
ranges = ranges.Where(range => HasValidRange(range));
if (ranges.Any())
{
var rangeComparer = new VersionRangeComparer(comparer);
// start with the first range in the list
var first = ranges.First();
var lowest = first.MinVersion;
var highest = first.MaxVersion;
// To keep things consistent set min/max inclusive to false when there is no boundary
// It is possible to denote an inclusive range with no bounds, but it has no useful meaning for combine
var includeLowest = first.IsMinInclusive && first.HasLowerBound;
var includeHighest = first.IsMaxInclusive && first.HasUpperBound;
// expand the range to inclue all other ranges
foreach (var range in ranges.Skip(1))
{
// once we have an unbounded lower we can stop checking
if (lowest != null)
{
if (range.HasLowerBound)
{
var lowerCompare = comparer.Compare(range.MinVersion, lowest);
if (lowerCompare < 0)
{
// A new lowest was found
lowest = range.MinVersion;
includeLowest = range.IsMinInclusive;
}
else if (lowerCompare == 0)
{
// The lower ends are identical, update the inclusiveness
includeLowest |= range.IsMinInclusive;
}
// lowerCompare > 0 falls into the current range, this is a no-op
}
else
{
// No lower bound
lowest = null;
includeLowest = false;
}
}
// null is the highest we can get, stop checking once it is hit
if (highest != null)
{
if (range.HasUpperBound)
{
var higherCompare = comparer.Compare(range.MaxVersion, highest);
if (higherCompare > 0)
{
// A new highest was found
highest = range.MaxVersion;
includeHighest = range.IsMaxInclusive;
}
else if (higherCompare == 0)
{
// The higher ends are identical, update the inclusiveness
includeHighest |= range.IsMaxInclusive;
}
// higherCompare < 0 falls into the current range, this is a no-op
}
else
{
// No higher bound
highest = null;
includeHighest = false;
}
}
}
// Create the new range using the maximums found
result = new VersionRange(lowest, includeLowest, highest, includeHighest);
}
return(result);
}
public PackageIdentityComparer()
{
_versionComparer = new VersionComparer(VersionComparison.Default);
}
