public IEnumerable<PackageIssue> Validate(IPackage package)
{
if (package.ProjectUrl != null && package.ProjectUrl.OriginalString.Equals(SpecCommand.SampleProjectUrl, StringComparison.Ordinal))
{
yield return CreateIssueFor("ProjectUrl", package.ProjectUrl.OriginalString);
}
if (package.LicenseUrl != null && package.LicenseUrl.OriginalString.Equals(SpecCommand.SampleLicenseUrl, StringComparison.Ordinal))
{
yield return CreateIssueFor("LicenseUrl", package.LicenseUrl.OriginalString);
}
if (package.IconUrl != null && package.IconUrl.OriginalString.Equals(SpecCommand.SampleIconUrl, StringComparison.Ordinal))
{
yield return CreateIssueFor("IconUrl", package.IconUrl.OriginalString);
}
if (!String.IsNullOrEmpty(package.Tags) && package.Tags.Trim().Equals(SpecCommand.SampleTags, StringComparison.Ordinal))
{
yield return CreateIssueFor("Tags", SpecCommand.SampleTags);
}
if (SpecCommand.SampleReleaseNotes.Equals(package.ReleaseNotes, StringComparison.Ordinal))
{
yield return CreateIssueFor("ReleaseNotes", SpecCommand.SampleReleaseNotes);
}
if (SpecCommand.SampleDescription.Equals(package.Description, StringComparison.Ordinal))
{
yield return CreateIssueFor("Description", SpecCommand.SampleDescription);
}
var dependency = package.GetCompatiblePackageDependencies(targetFramework: null).FirstOrDefault();
if (dependency != null && dependency.Id.Equals(SpecCommand.SampleManifestDependency.Id, StringComparison.Ordinal)
&& dependency.VersionSpec.ToString().Equals("[" + SpecCommand.SampleManifestDependency.Version + "]", StringComparison.Ordinal))
{
yield return CreateIssueFor("Dependency", dependency.ToString());
}
}
public IEnumerable <PackageIssue> Validate(IPackage package)
{
if (package.ProjectUrl != null && package.ProjectUrl.OriginalString.Equals(SpecCommand.SampleProjectUrl, StringComparison.Ordinal))
{
yield return(CreateIssueFor("ProjectUrl", package.ProjectUrl.OriginalString));
}
if (package.LicenseUrl != null && package.LicenseUrl.OriginalString.Equals(SpecCommand.SampleLicenseUrl, StringComparison.Ordinal))
{
yield return(CreateIssueFor("LicenseUrl", package.LicenseUrl.OriginalString));
}
if (package.IconUrl != null && package.IconUrl.OriginalString.Equals(SpecCommand.SampleIconUrl, StringComparison.Ordinal))
{
yield return(CreateIssueFor("IconUrl", package.IconUrl.OriginalString));
}
if (!String.IsNullOrEmpty(package.Tags) && package.Tags.Trim().Equals(SpecCommand.SampleTags, StringComparison.Ordinal))
{
yield return(CreateIssueFor("Tags", SpecCommand.SampleTags));
}
if (SpecCommand.SampleReleaseNotes.Equals(package.ReleaseNotes, StringComparison.Ordinal))
{
yield return(CreateIssueFor("ReleaseNotes", SpecCommand.SampleReleaseNotes));
}
if (SpecCommand.SampleDescription.Equals(package.Description, StringComparison.Ordinal))
{
yield return(CreateIssueFor("Description", SpecCommand.SampleDescription));
}
var dependency = package.GetCompatiblePackageDependencies(targetFramework: null).FirstOrDefault();
if (dependency != null && dependency.Id.Equals(SpecCommand.SampleManifestDependency.Id, StringComparison.Ordinal) &&
dependency.VersionSpec.ToString().Equals("[" + SpecCommand.SampleManifestDependency.Version + "]", StringComparison.Ordinal))
{
yield return(CreateIssueFor("Dependency", dependency.ToString()));
}
}
private void GetAllDependencies(IPackage current, List <IPackage> collectedDependencies)
{
Debug.Assert(current != null);
logger.LogDebug(UIResources.NG_ResolvingPackageDependencies, current.Id, current.Version);
foreach (PackageDependency dependency in current.GetCompatiblePackageDependencies(null))
{
IPackage dependencyPackage = packageManager.LocalRepository.ResolveDependency(dependency, true, true);
if (dependencyPackage == null)
{
logger.LogWarning(UIResources.NG_FailedToResolveDependency, dependency.Id, dependency.VersionSpec.ToString());
}
else
{
if (collectedDependencies.Contains(dependencyPackage))
{
logger.LogDebug(UIResources.NG_DuplicateDependency, dependencyPackage.Id, dependencyPackage.Version);
}
else
{
logger.LogDebug(UIResources.NG_AddingNewDependency, dependencyPackage.Id, dependencyPackage.Version);
collectedDependencies.Add(dependencyPackage);
GetAllDependencies(dependencyPackage, collectedDependencies);
}
}
}
}
static IEnumerable <T> GetReferencesTree <T>(IPackageRepository repo,
IPackage package, FrameworkName targetFrameworkName, IndentingLineWriter writer,
Func <IPackageAssemblyReference, IPackage, T> selector)
{
writer?.WriteLine(package.GetFullName());
IEnumerable <IPackageAssemblyReference> refs;
if (VersionUtility.TryGetCompatibleItems(targetFrameworkName, package.AssemblyReferences, out refs))
{
foreach (var r in refs)
{
yield return(selector(r, package));
}
}
else
{
yield return(selector(null, package));
}
var subrefs =
from d in package.GetCompatiblePackageDependencies(targetFrameworkName)
select repo.FindPackage(d.Id) into dp
where dp != null
from r in GetReferencesTree(repo, dp, targetFrameworkName,
writer?.Indent(), selector)
select r;
foreach (var r in subrefs)
{
yield return(r);
}
}
private static void GetValue(IPackageRepository repository, FrameworkName frameworkName, IPackage package, bool prerelease, int level)
{
Console.WriteLine("{0}{1}", new string(' ', level * 3), package);
foreach (PackageDependency dependency in package.GetCompatiblePackageDependencies(frameworkName))
{
IPackage subPackage = repository.ResolveDependency(dependency, prerelease, true);
GetValue(repository, frameworkName, subPackage, prerelease, level + 1);
}
}
private static IEnumerable <PackageDependency> getCompatiblePackageDependencies(IPackage package)
{
FrameworkName frameworkName = null;
IEnumerable <PackageDependency> dependenciesPkgsList = new List <PackageDependency>();
foreach (var curFrameWorkName in package.GetSupportedFrameworks())
{
dependenciesPkgsList = package.GetCompatiblePackageDependencies(frameworkName);
if (dependenciesPkgsList != null && dependenciesPkgsList.Count() > 0)
{
break;
} // If found a matching dependecy, no need to check more frameowrks
}
// Incase no supported frameworks - use: frameworkName = null
if (dependenciesPkgsList == null || dependenciesPkgsList.Count() == 0)
{
dependenciesPkgsList = package.GetCompatiblePackageDependencies(frameworkName);
}
return(dependenciesPkgsList);
}
public IEnumerable <PackageIssue> Validate(IPackage package)
{
if (package.ProjectUrl != null && package.ProjectUrl.OriginalString.Equals(SpecCommand.SampleProjectUrl, StringComparison.Ordinal))
{
yield return(CreateIssueFor("ProjectUrl", package.ProjectUrl.OriginalString));
}
if (package.LicenseUrl != null && package.LicenseUrl.OriginalString.Equals(SpecCommand.SampleLicenseUrl, StringComparison.Ordinal))
{
yield return(CreateIssueFor("LicenseUrl", package.LicenseUrl.OriginalString));
}
if (package.IconUrl != null && package.IconUrl.OriginalString.Equals(SpecCommand.SampleIconUrl, StringComparison.Ordinal))
{
yield return(CreateIssueFor("IconUrl", package.IconUrl.OriginalString));
}
if (!String.IsNullOrEmpty(package.Tags) && package.Tags.Trim().Equals(SpecCommand.SampleTags, StringComparison.Ordinal))
{
yield return(CreateIssueFor("Tags", SpecCommand.SampleTags));
}
if (SpecCommand.SampleReleaseNotes.Equals(package.ReleaseNotes, StringComparison.Ordinal))
{
yield return(CreateIssueFor("ReleaseNotes", SpecCommand.SampleReleaseNotes));
}
if (SpecCommand.SampleDescription.Equals(package.Description, StringComparison.Ordinal))
{
yield return(CreateIssueFor("Description", SpecCommand.SampleDescription));
}
var dependency = package.GetCompatiblePackageDependencies(targetFramework: null).FirstOrDefault();
if (dependency != null &&
dependency.Id.Equals(SpecCommand.SampleManifestDependency.Id, StringComparison.Ordinal) &&
dependency.VersionSpec != null &&
dependency.VersionSpec.ToString().Equals("[" + SpecCommand.SampleManifestDependency.Version + "]", StringComparison.Ordinal))
{
yield return(CreateIssueFor("Dependency", dependency.ToString()));
}
if (dependency != null && dependency.VersionSpec == null)
{
var message = String.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("Warning_UnspecifiedDependencyVersion"),
dependency.Id);
var issue = new PackageIssue(
LocalizedResourceManager.GetString("Warning_UnspecifiedDependencyVersionTitle"),
message,
LocalizedResourceManager.GetString("Warning_UnspecifiedDependencyVersionSolution"));
yield return(issue);
}
}
public PackageObject(IPackage package, FrameworkName frameworkName)
{
_package = package;
FrameworkName = frameworkName;
Id = package.Id;
Version = package.Version.Version;
TextVersion = package.Version.ToString();
var dependencies = _package.GetCompatiblePackageDependencies(frameworkName);
if (dependencies != null)
{
Dependencies = dependencies.Select(i => new PackageObject(i.Id) { FrameworkName = frameworkName });
}
}
public IEnumerable<PackageIssue> Validate(IPackage package)
{
if (package.ProjectUrl != null && package.ProjectUrl.OriginalString.Equals(SpecCommand.SampleProjectUrl, StringComparison.Ordinal))
{
yield return CreateIssueFor("ProjectUrl", package.ProjectUrl.OriginalString);
}
if (package.LicenseUrl != null && package.LicenseUrl.OriginalString.Equals(SpecCommand.SampleLicenseUrl, StringComparison.Ordinal))
{
yield return CreateIssueFor("LicenseUrl", package.LicenseUrl.OriginalString);
}
if (package.IconUrl != null && package.IconUrl.OriginalString.Equals(SpecCommand.SampleIconUrl, StringComparison.Ordinal))
{
yield return CreateIssueFor("IconUrl", package.IconUrl.OriginalString);
}
if (!String.IsNullOrEmpty(package.Tags) && package.Tags.Trim().Equals(SpecCommand.SampleTags, StringComparison.Ordinal))
{
yield return CreateIssueFor("Tags", SpecCommand.SampleTags);
}
if (SpecCommand.SampleReleaseNotes.Equals(package.ReleaseNotes, StringComparison.Ordinal))
{
yield return CreateIssueFor("ReleaseNotes", SpecCommand.SampleReleaseNotes);
}
if (SpecCommand.SampleDescription.Equals(package.Description, StringComparison.Ordinal))
{
yield return CreateIssueFor("Description", SpecCommand.SampleDescription);
}
var dependency = package.GetCompatiblePackageDependencies(targetFramework: null).FirstOrDefault();
if (dependency != null &&
dependency.Id.Equals(SpecCommand.SampleManifestDependency.Id, StringComparison.Ordinal) &&
dependency.VersionSpec != null &&
dependency.VersionSpec.ToString().Equals("[" + SpecCommand.SampleManifestDependency.Version + "]", StringComparison.Ordinal))
{
yield return CreateIssueFor("Dependency", dependency.ToString());
}
if (dependency != null && dependency.VersionSpec == null)
{
var message = String.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("Warning_UnspecifiedDependencyVersion"),
dependency.Id);
var issue = new PackageIssue(
LocalizedResourceManager.GetString("Warning_UnspecifiedDependencyVersionTitle"),
message,
LocalizedResourceManager.GetString("Warning_UnspecifiedDependencyVersionSolution"));
yield return issue;
}
}
private IEnumerable<PackageUpgrade> IdentifyUpgrades(IPackage package)
{
IList<PackageUpgrade> upgrades = new List<PackageUpgrade>();
foreach (var dependency in package.GetCompatiblePackageDependencies(_targetFramework))
{
var recentDependencyPackage = _packageRepository.FindPackage(dependency.Id);
var upgradeType = DetectUpgradeAction(dependency, recentDependencyPackage);
upgrades.Add(new PackageUpgrade(dependency, upgradeType, recentDependencyPackage));
}
return upgrades;
}
public PackageObject(IPackage package, FrameworkName frameworkName)
{
_package = package;
FrameworkName = frameworkName;
Id = package.Id;
Version = package.Version.Version;
TextVersion = package.Version.ToString();
FrameworkAssemblies = package.FrameworkAssemblies
.Where(x => x.SupportedFrameworks.Any(y => y == frameworkName))
.Select(x => x.AssemblyName);
var dependencies = _package.GetCompatiblePackageDependencies(frameworkName);
if (dependencies != null)
{
Dependencies = dependencies.Select(i => new PackageObject(i.Id) { FrameworkName = frameworkName });
}
}
public PackageObject(IPackage package, FrameworkName frameworkName)
{
_package = package;
FrameworkName = frameworkName;
Id = package.Id;
Version = package.Version.Version;
TextVersion = package.Version.ToString();
var dependencies = _package.GetCompatiblePackageDependencies(frameworkName);
if (dependencies != null)
{
Dependencies = dependencies.Select(i => new PackageObject(i.Id)
{
FrameworkName = frameworkName
});
}
}
static IEnumerable <string> FindAssemblyReferences(IPackageRepository repository, IPackage package)
{
foreach (var assembly in package.AssemblyReferences)
{
yield return(assembly.Name);
}
var dependencies = package.GetCompatiblePackageDependencies(null);
foreach (var dependency in dependencies)
{
var dependencyPackage = repository.ResolveDependency(dependency, true, true);
if (dependencyPackage != null)
{
foreach (var reference in FindAssemblyReferences(repository, dependencyPackage))
{
yield return(reference);
}
}
}
}
public PackageObject(IPackage package, FrameworkName frameworkName)
{
_package = package;
FrameworkName = frameworkName;
Id = package.Id;
Version = package.Version.Version;
TextVersion = package.Version.ToString();
FrameworkAssemblies = package.FrameworkAssemblies
.Where(x => x.SupportedFrameworks.Any(y => y == frameworkName))
.Select(x => x.AssemblyName);
var dependencies = _package.GetCompatiblePackageDependencies(frameworkName);
if (dependencies != null)
{
Dependencies = dependencies.Select(i => new PackageObject(i.Id)
{
FrameworkName = frameworkName
});
}
}
public void Walk(IPackage package)
{
CheckPackageMinClientVersion(package);
// Do nothing if we saw this package already
if (Marker.IsVisited(package))
{
ProcessPackageTarget(package);
return;
}
OnBeforePackageWalk(package);
// Mark the package as processing
Marker.MarkProcessing(package);
if (!IgnoreDependencies)
{
foreach (var dependency in package.GetCompatiblePackageDependencies(TargetFramework))
{
// Try to resolve the dependency from the visited packages first
IPackage resolvedDependency = DependencyResolveUtility.ResolveDependency(
Marker,
dependency, constraintProvider: null,
allowPrereleaseVersions: AllowPrereleaseVersions,
preferListedPackages: false,
dependencyVersion: DependencyVersion);
if (resolvedDependency == null)
{
resolvedDependency = ResolveDependency(dependency);
}
if (resolvedDependency == null)
{
OnDependencyResolveError(dependency);
// If we're skipping dependency resolve errors then move on to the next
// dependency
if (SkipDependencyResolveError)
{
continue;
}
return;
}
if (!IgnoreWalkInfo)
{
// Set the parent
PackageWalkInfo dependencyInfo = GetPackageInfo(resolvedDependency);
dependencyInfo.Parent = package;
}
Marker.AddDependent(package, resolvedDependency);
if (!OnAfterResolveDependency(package, resolvedDependency))
{
continue;
}
if (Marker.IsCycle(resolvedDependency) ||
Marker.IsVersionCycle(resolvedDependency.Id))
{
if (RaiseErrorOnCycle)
{
List <IPackage> packages = Marker.Packages.ToList();
packages.Add(resolvedDependency);
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.CircularDependencyDetected, String.Join(" => ",
packages.Select(p => p.GetFullName()))));
}
continue;
}
Walk(resolvedDependency);
}
}
// Mark the package as visited
Marker.MarkVisited(package);
ProcessPackageTarget(package);
OnAfterPackageWalk(package);
}
void InstallPackageDependencies(System.Runtime.Versioning.FrameworkName TargetFramework, IPackage Package)
{
if (Package == null)
{
throw new ArgumentNullException("Package", "Package cannot be null");
}
if (Package.Id.ToLower() == "netstandard.library")
{
return;
}
// if (Package.Id.ToLower() == "system.net.websockets.client.managed") return;
if (Package.Id.ToLower() == "system.buffers")
{
return;
}
if (Package.Id.ToLower() == "system.reflection.emit")
{
return;
}
//if (Package.Id.ToLower() == "system.net.websockets.client.managed")
//{
// var b = true;
//}
try
{
IPackage exists = null;
System.Runtime.Versioning.FrameworkName framework = TargetFramework;
if (Package == null)
{
return;
}
var deps = Package.GetCompatiblePackageDependencies(framework);
if (deps.Count() == 0)
{
var dsets = Package.DependencySets.Where(x => x.TargetFramework.Version.Major == 4).OrderByDescending(x => x.TargetFramework.Version.Minor).ToList();
if (dsets.Count() == 0 && Package.DependencySets.Count() == 1)
{
dsets = Package.DependencySets.ToList();
}
if (dsets.Count() > 0)
{
if (dsets.First().Dependencies.Count() > 0)
{
framework = dsets.First().TargetFramework;
System.Diagnostics.Debug.WriteLine("******** " + Package.Id + " " + framework.ToString());
deps = dsets.First().Dependencies;
}
}
//// .NETFramework4.5
//framework = new System.Runtime.Versioning.FrameworkName(".NETStandard", new Version("2.0"));
//deps = Package.GetCompatiblePackageDependencies(framework);
//if(deps.Count() > 0)
//{
// System.Diagnostics.Debug.WriteLine("******** " + Package.Id + " " + framework.ToString());
//}
}
else
{
System.Diagnostics.Debug.WriteLine("******** " + Package.Id + " " + TargetFramework.ToString());
foreach (var d in deps)
{
System.Diagnostics.Debug.WriteLine(d.Id);
}
}
foreach (var d in deps)
{
_InstallPackage(d.Id, d.VersionSpec.MinVersion);
// Whats wrong with FastMember.1.5.0 ??
exists = packageManager.LocalRepository.FindPackage(d.Id);
// exists = packageManager.LocalRepository.FindPackage(d.Id, d.VersionSpec.MinVersion);
if (exists != null)
{
PackageInstalled(null, new PackageOperationEventArgs(exists, FileSystem, RepositoryPath + @"\" + exists.Id + "." + exists.Version.ToString()));
InstallPackageDependencies(framework, exists);
}
}
}
catch (Exception ex)
{
logger.Log(MessageLevel.Error, ex.ToString());
System.Diagnostics.Debug.WriteLine(ex.ToString());
throw;
}
}
public void Walk(IPackage package)
{
CheckPackageMinClientVersion(package);
// Do nothing if we saw this package already
if (Marker.IsVisited(package))
{
ProcessPackageTarget(package);
return;
}
OnBeforePackageWalk(package);
// Mark the package as processing
Marker.MarkProcessing(package);
if (!IgnoreDependencies)
{
foreach (var dependency in package.GetCompatiblePackageDependencies(TargetFramework))
{
// Try to resolve the dependency from the visited packages first
IPackage resolvedDependency = DependencyResolveUtility.ResolveDependency(
Marker,
dependency, constraintProvider: null,
allowPrereleaseVersions: AllowPrereleaseVersions,
preferListedPackages: false,
dependencyVersion: DependencyVersion);
if (resolvedDependency == null)
{
resolvedDependency = ResolveDependency(dependency);
}
if (resolvedDependency == null)
{
OnDependencyResolveError(dependency);
// If we're skipping dependency resolve errors then move on to the next
// dependency
if (SkipDependencyResolveError)
{
continue;
}
return;
}
if (!IgnoreWalkInfo)
{
// Set the parent
PackageWalkInfo dependencyInfo = GetPackageInfo(resolvedDependency);
dependencyInfo.Parent = package;
}
Marker.AddDependent(package, resolvedDependency);
if (!OnAfterResolveDependency(package, resolvedDependency))
{
continue;
}
if (Marker.IsCycle(resolvedDependency) ||
Marker.IsVersionCycle(resolvedDependency.Id))
{
if (RaiseErrorOnCycle)
{
List<IPackage> packages = Marker.Packages.ToList();
packages.Add(resolvedDependency);
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.CircularDependencyDetected, String.Join(" => ",
packages.Select(p => p.GetFullName()))));
}
continue;
}
Walk(resolvedDependency);
}
}
// Mark the package as visited
Marker.MarkVisited(package);
ProcessPackageTarget(package);
OnAfterPackageWalk(package);
}
private void GetAllDependencies(IPackage current, List<IPackage> collectedDependencies)
{
this.logger.LogDebug(UIResources.NG_ResolvingPackageDependencies, current.Id, current.Version);
Debug.Assert(current != null);
foreach (PackageDependency dependency in current.GetCompatiblePackageDependencies(null))
{
IPackage dependencyPackage = this.packageManager.LocalRepository.ResolveDependency(dependency, true, true);
if (dependencyPackage == null)
{
this.logger.LogWarning(UIResources.NG_FailedToResolveDependency, dependency.Id, dependency.VersionSpec.ToString());
}
else
{
if (collectedDependencies.Contains(dependencyPackage))
{
this.logger.LogDebug(UIResources.NG_DuplicateDependency, dependencyPackage.Id, dependencyPackage.Version);
}
else
{
this.logger.LogDebug(UIResources.NG_AddingNewDependency, dependencyPackage.Id, dependencyPackage.Version);
collectedDependencies.Add(dependencyPackage);
GetAllDependencies(dependencyPackage, collectedDependencies);
}
}
}
}
public IEnumerable<IPackage> FindDependenciesToBeInstalled(IPackage package)
{
var dependencies = package.GetCompatiblePackageDependencies(null);
return dependencies.SelectMany(dependency => this.RemotePackages.Where(remote => remote.Id == dependency.Id && dependency.VersionSpec.Satisfies(remote.Version)));
}
public IEnumerable <IPackage> FindDependenciesToBeInstalled(IPackage package)
{
var dependencies = package.GetCompatiblePackageDependencies(null);
return(dependencies.SelectMany(dependency => this.RemotePackages.Where(remote => remote.Id == dependency.Id && dependency.VersionSpec.Satisfies(remote.Version))));
}
