public static IPackageInfo Find(this ILookup<string, IPackageInfo> packages, PackageDependency dependency) { if (!packages.Contains(dependency.Name)) return null; return (from package in packages[dependency.Name] where package.Version != null && dependency.IsFulfilledBy(package.Version) orderby package.Version descending select package).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 == OldPackage) { // TODO: Should we create a new PackageDependency instance instead? // Might be a good idea to make these objects immutable... 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(); }
/// <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; }
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(); }
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(); }
PackageDependency ApplyPackageNameOverride(PackageDependency originalDependency) { return _nameOverrides.Aggregate(originalDependency, (modifiedDependency, wrapOverride) => wrapOverride.Apply(modifiedDependency)); }
PackageDependency ApplyPackageHintOverride(PackageDependency originalDependency) { return _hints.ContainsKey(originalDependency.Name) ? _hints[originalDependency.Name] : originalDependency; }
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; }
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(); } }
public PackageDependencyBuilder(PackageDependency dep) { _name = dep.Name; _tags = new List<string>(dep.Tags); _versions = new List<VersionVertex>(dep.VersionVertices); }
public IEnumerable<IPackageInfo> FindAll(PackageDependency dependency) { return PackagesByName.FindAll(dependency); }
static PackageDependency CreateDependency(XmlNode xmlNode) { var dep = new PackageDependency { Name = (xmlNode.Attributes["id"] ?? xmlNode.Attributes["id", NuSpecSchema]).Value }; var version = xmlNode.Attributes["version"] ?? xmlNode.Attributes["version", NuSpecSchema]; var minversion = xmlNode.Attributes["minversion"] ?? xmlNode.Attributes["minversion", NuSpecSchema]; var maxversion = xmlNode.Attributes["maxversion"] ?? xmlNode.Attributes["maxversion", NuSpecSchema]; if (version != null) dep.VersionVertices.Add(new ExactVersionVertex(version.Value.ToVersion())); if (minversion != null) dep.VersionVertices.Add(new GreaterThenOrEqualVersionVertex(minversion.Value.ToVersion())); if (maxversion != null) dep.VersionVertices.Add(new LessThanVersionVertex(maxversion.Value.ToVersion())); return dep; }
public DependencyNotFoundInRepositories(PackageDependency dependency, IEnumerable<IPackageRepository> repositories) { Dependency = dependency; Repositories = repositories; }
public PackageDependency(PackageDependency copy) { VersionVertices = new List<VersionVertex>(copy.VersionVertices); Tags = new List<string>(copy.Tags); Name = copy.Name; }
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; } }
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 ExactVersionVertex(Version.ToVersion())); } if (MinVersion != null) { builder = builder.VersionVertex(new GreaterThenOrEqualVersionVertex(MinVersion.ToVersion())); } if (MaxVersion != null) { builder = builder.VersionVertex(new LessThanVersionVertex(MaxVersion.ToVersion())); } return builder; }
void UpdatedDependency(PackageDependency dependency) { if (_content.HasValue) { dependency.ContentOnly = _content.Value; } if (_anchored.HasValue) { dependency.Anchored = _anchored.Value; } if (SomeVersionInputGiven) { dependency.VersionVertices.Clear(); } if (AnyVersion) { dependency.VersionVertices.Add(new AnyVersionVertex()); } if (Version != null) { dependency.VersionVertices.Add(new ExactVersionVertex(Version.ToVersion())); } if (MinVersion != null) { dependency.VersionVertices.Add(new GreaterThenOrEqualVersionVertex(MinVersion.ToVersion())); } if (MaxVersion != null) { dependency.VersionVertices.Add(new LessThanVersionVertex(MaxVersion.ToVersion())); } }
public IPackageInfo Find(PackageDependency dependency) { return PackagesByName.Find(dependency); }
public ParentedDependency(PackageDependency dependency, ParentedDependency parent) { Dependency = dependency; Parent = parent; }
public void sonic_is_changed_to_super_sonic() { var sonic = new PackageDependency { Name = "sonic" }; PackageNameOverride.Apply(sonic); sonic.Name.ShouldBe("super-sonic"); }
void PushStack(PackageDependency dependency) { _currentNode.Push(new DependencyNode(dependency)); WriteDebug("D:" + dependency); }
public void tails_is_still_tails() { var tails = new PackageDependency { Name = "tails" }; PackageNameOverride.Apply(tails); tails.Name.ShouldBe("tails"); }
public DependencyNode(PackageDependency dependency) { Dependency = dependency; }