public static IPackageInfo Find(this IPackageRepository packages, PackageDependency dependency)
{
var allMatchingPackages = packages.FindAll(dependency);
// only remove nuked versions if it's not an exact match
var availVersion = allMatchingPackages.FirstOrDefault(x => x.Nuked == false);
return availVersion ?? allMatchingPackages.FirstOrDefault();
}
/// <summary>
/// Applies the override, if it's relevant to the dependency, to produce a modified dependency.
/// </summary>
public PackageDependency Apply(PackageDependency dependency)
{
if (dependency.Name.EqualsNoCase(OldPackage))
{
// TODO: Should we create a new PackageDependency instance instead?
// Might be a good idea to make these objects immutable...
return new PackageDependencyBuilder(dependency).Name(NewPackage);
}
return dependency;
}
public static IEnumerable<IPackageInfo> FindAll(this ILookup<string, IPackageInfo> packages, PackageDependency dependency)
{
if (!packages.Contains(dependency.Name))
return Enumerable.Empty<IPackageInfo>();
return (from package in packages[dependency.Name]
where package.Version != null && dependency.IsFulfilledBy(package.Version)
orderby package.Version descending
select package).ToList();
}
bool VisitDependencyNode(IPackageInfo from, PackageDependency dependency, IPackageInfo to, PackageVisitor visitor, Dictionary<string,int> visitsLeft)
{
if (!visitor(from, dependency, to)) return false;
if (DecreaseVisitCount(visitsLeft, to.Name) <= 0)
{
foreach (var dependencyNode in to.Dependencies)
if (!VisitDependencyNode(to, dependencyNode, _byName[dependencyNode.Name], visitor, visitsLeft))
return false;
}
return true;
}
KeyValuePair<PackageIdentifier, IPackageInfo>? NextAvailablePackageVersion(IEnumerable<PackageIdentifier> seen, PackageDependency dependency)
{
return (from packageById in from repo in _repositories
from package in repo.FindAll(dependency)
where _selectionContext.IsIgnored(package.Identifier) == false
group package by package.Identifier
where seen.Contains(packageById.Key) == false && packageById.Count() > 0
orderby packageById.Key.Version descending
select new KeyValuePair<PackageIdentifier, IPackageInfo>?(
new KeyValuePair<PackageIdentifier, IPackageInfo>(
packageById.Key,
packageById.First())))
.FirstOrDefault();
}
Package CreatePackageInfo(PackageDependency dependency, IEnumerable<IPackageInfo> resolvedPackages, IEnumerable<IPackageInfo> lockedPackages, bool includeChildren, Stack<string> recursionDefender)
{
var packageInfo = new Package(
resolvedPackages.FirstOrDefault(
pack => pack.Name.EqualsNoCase(dependency.Name)),
dependency.ToString(),
lockedPackages.Any(x => x.Name.EqualsNoCase(dependency.Name)));
if (!includeChildren) return packageInfo;
if (recursionDefender.ContainsNoCase(dependency.Name))
packageInfo.Children = Truncated;
else
{
recursionDefender.Push(dependency.Name);
packageInfo.Children = (
packageInfo.PackageInfo.Dependencies.Select(
dep => CreatePackageInfo(dep, resolvedPackages, lockedPackages, includeChildren, recursionDefender)))
.ToList();
recursionDefender.Pop();
}
return packageInfo;
}
IEnumerable<ICommandOutput> ValidateInputs()
{
_dependency = FindDependencyByName();
if (_dependency == null)
{
yield return new Error("Dependency not found: " + Name);
yield break;
}
var gotVersion = Version != null;
var gotMinVersion = MinVersion != null;
var gotMaxVersion = MaxVersion != null;
var numberOfVersionInputTypes = (new[] { gotVersion, (gotMinVersion || gotMaxVersion), AnyVersion }).Count(v => v);
if (numberOfVersionInputTypes > 1)
{
yield return new Error("Arguments for 'version', 'version boundaries' and 'anyVersion' cannot be combined.");
yield break;
}
if (gotVersion && Version.ToVersion() == null)
{
yield return new Error("Could not parse version: " + Version);
yield break;
}
if (gotMinVersion && MinVersion.ToVersion() == null)
{
yield return new Error("Could not parse minversion: " + MinVersion);
yield break;
}
if (gotMaxVersion && MaxVersion.ToVersion() == null)
{
yield return new Error("Could not parse maxversion: " + MaxVersion);
yield break;
}
}
public static IPackageInfo Find(this ILookup<string, IPackageInfo> packages, PackageDependency dependency)
{
if (!packages.Contains(dependency.Name))
return null;
var allMatchingPackages = from package in packages[dependency.Name]
where package.Version != null && dependency.IsFulfilledBy(package.Version)
orderby package.Version descending
select package;
// only remove nuked versions if it's not an exact match
var bestMatching = allMatchingPackages.FirstOrDefault();
if (bestMatching != null)
{
if (dependency.IsExactlyFulfilledBy(bestMatching.Version))
return bestMatching;
}
// remove any nuked versions before returning the best match
return (from package in allMatchingPackages
where !package.Nuked
select package).FirstOrDefault();
}
public IEnumerable<IPackageInfo> FindAll(PackageDependency dependency)
{
return PackagesByName.FindAll(dependency);
}
public PackageDependencyRemovedResult(PackageDependency dependency)
{
Dependency = dependency;
}
public PackageDependencyBuilder(PackageDependency dep)
{
_name = dep.Name;
_tags = new List<string>(dep.Tags);
_versions = new List<VersionVertex>(dep.VersionVertices);
}
public void given_dependency(string dependencyLine)
{
var target = new PackageDescriptor();
((IPackageDescriptor)target).Dependencies.Add(DependsParser.ParseDependsLine(dependencyLine));
Declaration = target.Dependencies.First();
}
public PackageDependencyAddedResult(PackageDependency dependency)
{
Dependency = dependency;
}
public DependencyNode(PackageDependency dependency)
{
Dependency = dependency;
}
IEnumerable<IPackageInfo> Match(PackageDependency dependency)
{
return _packages.FindAll(dependency);
}
bool VisitPackageVersions(PackageDependency dependency)
{
IPackageInfo packageVersion;
var seen = new List<PackageIdentifier>();
while ((packageVersion = NextAvailablePackageVersion(seen, dependency)) != null)
{
seen.Add(packageVersion.Identifier);
_selectionContext.Trying(packageVersion.Identifier);
PushStack(packageVersion.Identifier);
if (VisitDependencies(packageVersion.Dependencies))
{
_selectionContext.PackageSucceeds(packageVersion.Identifier, CurrentCallStack);
WriteDebug("dependency: version found");
PopStack();
return true;
}
_selectionContext.PackageHasChildrenConflicting(packageVersion.Identifier);
WriteDebug("dependency: version didn't match");
PopStack();
}
WriteDebug("dependency: no version matches");
if (seen.Empty())
{
_notFound.Add(new KeyValuePair<PackageDependency, CallStack>(dependency, CurrentCallStack));
}
return false;
}
bool VisitPackageVersions(PackageDependency dependency)
{
KeyValuePair<PackageIdentifier, IPackageInfo>? packageVersion;
var seen = new List<PackageIdentifier>();
while ((packageVersion = NextAvailablePackageVersion(seen, dependency)) != null)
{
seen.Add(packageVersion.Value.Key);
_selectionContext.Trying(packageVersion.Value.Key);
PushStack(packageVersion.Value.Key);
IPackageInfo package = packageVersion.Value.Value;
if (package != null && VisitDependencies(package.Dependencies))
{
_selectionContext.PackageSucceeds(packageVersion.Value.Key, CurrentCallStack);
PopStack();
WriteDebug("VisitPackage version Succeeded");
return true;
}
_selectionContext.PackageHasChildrenConflicting(packageVersion.Value.Key);
PopStack();
WriteDebug("VisitPackage version failed");
}
WriteDebug("VisitPackage failed");
if (seen.Empty())
{
_notFound.Add(new KeyValuePair<PackageDependency, CallStack>(dependency, CurrentCallStack));
}
return false;
}
public IPackageInfo Find(PackageDependency dependency)
{
return PackagesByName.Find(dependency);
}
public bool IsCompatibleWith(PackageDependency dependency)
{
return(Name.EqualsNoCase(dependency.Name) &&
dependency.IsFulfilledBy(Version));
}
PackageDependency ApplyPackageHintOverride(PackageDependency originalDependency)
{
// TODO: Investigate being smarter in how overrides are applied
return _hints.ContainsKey(originalDependency.Name) && _hints[originalDependency.Name].VersionVertices.OfType<AnyVersionVertex>().Any() == false
? _hints[originalDependency.Name] : originalDependency;
}
protected void when_reading_test_module_descriptor(string packageName)
{
Descriptor = Repository.PackagesByName[packageName].FirstOrDefault();
Dependency = Descriptor.Dependencies.FirstOrDefault();
}
IPackageInfo NextAvailablePackageVersion(IEnumerable<PackageIdentifier> seen, PackageDependency dependency)
{
var availablePackages = Match(dependency).Where(_=>!_selectionContext.IsIgnored(_.Identifier) && !seen.Contains(_.Identifier));
return Select(availablePackages);
}
protected bool VisitNodes(IPackageInfo from, PackageDependency dependency, IPackageInfo to)
{
visited.Add(to);
return true;
}
PackageDependency ApplyPackageHintOverride(PackageDependency originalDependency)
{
return _hints.ContainsKey(originalDependency.Name) ? _hints[originalDependency.Name] : originalDependency;
}
PackageDependency UpdatedDependency(PackageDependency dependency)
{
var builder = new PackageDependencyBuilder(dependency);
if (_content.HasValue)
{
builder = builder.Content(_content.Value);
}
if (_anchored.HasValue)
{
builder = builder.Anchored(_anchored.Value);
}
if (SomeVersionInputGiven)
{
builder = builder.SetVersionVertices(Enumerable.Empty<VersionVertex>());
}
if (AnyVersion)
{
builder = builder.VersionVertex(new AnyVersionVertex());
}
if (Version != null)
{
builder = builder.VersionVertex(new EqualVersionVertex(Version.ToSemVer()));
}
if (MinVersion != null)
{
builder = builder.VersionVertex(new GreaterThanOrEqualVersionVertex(MinVersion.ToSemVer()));
}
if (MaxVersion != null)
{
builder = builder.VersionVertex(new LessThanVersionVertex(MaxVersion.ToSemVer()));
}
return builder;
}
PackageDependency ApplyPackageNameOverride(PackageDependency originalDependency)
{
return _nameOverrides.Aggregate(originalDependency, (modifiedDependency, wrapOverride) => wrapOverride.Apply(modifiedDependency));
}
void PushStack(PackageDependency dependency)
{
_currentNode.Push(new DependencyNode(dependency));
WriteDebug("D:" + dependency);
}
PackageDependency ApplyPackageHintOverride(PackageDependency originalDependency)
{
// TODO: Investigate being smarter in how overrides are applied
return _hints.ContainsKey(originalDependency.Name) && _hints[originalDependency.Name] != new PackageDependency(originalDependency.Name)
? _hints[originalDependency.Name] : originalDependency;
}
public PackageDependencyBuilder(PackageDependency dep)
{
_name = dep.Name;
_tags = new List <string>(dep.Tags);
_versions = new List <VersionVertex>(dep.VersionVertices);
}
bool VisitDependency(PackageDependency dependency)
{
try
{
dependency = ApplyPackageHintOverride(ApplyPackageNameOverride(dependency));
PushStack(dependency);
var existing = _selectionContext.SelectedPackageByName(dependency.Name);
if (existing != null && existing.IsCompatibleWith(dependency))
{
WriteDebug("VisitDependencies existing version compatible");
PushStack(existing);
_selectionContext.ExistingPackageCompatible(existing, CurrentCallStack);
PopStack();
return true;
}
if (existing != null)
{
_selectionContext.Trying(existing);
_selectionContext.PackageConflicts(existing, CurrentCallStack);
WriteDebug("VisitDependencies existing version failed");
return false;
}
if (!VisitPackageVersions(dependency))
{
WriteDebug("VisitDependencies failed");
return false;
}
return true;
}
finally
{
PopStack();
}
}
