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(); } }