public void WillChoosePackageWithSmallestNumberOfAssembliesFromMultipleMatches()
{
var packages = new List <IPackage>
{
PackageUtility.CreatePackage(AssemblyCommon, "1.0", assemblyReferences: new List <string>()
{
AssemblyCommonDll
}),
PackageUtility.CreatePackage("Assembly.Other", "1.0", assemblyReferences: new List <string>()
{
AssemblyCommonDll, "Assembly.Other.dll"
})
};
var assemblies = new List <string>()
{
AssemblyCommonDll
};
var filesystem = new MockFileSystem();
var assemblyResolver = new RepositoryAssemblyResolver(assemblies, packages.AsQueryable(), filesystem, new Mock <IConsole>().Object);
var resolved = assemblyResolver.GetAssemblyToPackageMapping(false);
resolved.OutputPackageConfigFile();
Assert.AreEqual(1, filesystem.Paths.Count);
var file = new PackageReferenceFile(filesystem, string.Concat(filesystem.Root, "packages.config"));
Assert.AreEqual(1, file.GetPackageReferences().Count());
Assert.AreEqual(true, file.EntryExists(AssemblyCommon, SemanticVersion.Parse("1.0")));
}
public void CanOutputPackageConfigWithSingleEntry()
{
var fileList = new List <string>()
{
AssemblyCommonDll
};
var packages = new List <IPackage> {
PackageUtility.CreatePackage(AssemblyCommon, "1.0", assemblyReferences: fileList)
};
var assemblies = new List <string>()
{
AssemblyCommonDll
};
var filesystem = new MockFileSystem();
//filesystem.Root = @"c:\test";
var assemblyResolver = new RepositoryAssemblyResolver(assemblies, packages.AsQueryable(), filesystem, new Mock <IConsole>().Object);
var resolved = assemblyResolver.GetAssemblyToPackageMapping(false);
resolved.OutputPackageConfigFile();
Assert.AreEqual(1, filesystem.Paths.Count);
var file = new PackageReferenceFile(filesystem, string.Concat(filesystem.Root, "packages.config"));
Assert.AreEqual(1, file.GetPackageReferences().Count());
}
public IEnumerable <string> CreatePackageFile()
{
var packagesFile = Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFile);
var packageReferenceFile = new PackageReferenceFile(packagesFile);
var packagesFolder = Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFolder);
var repository = new LocalPackageRepository(packagesFolder);
var newestPackages = repository.GetPackages().GroupBy(p => p.Id)
.Select(g => g.OrderByDescending(p => p.Version).FirstOrDefault());
foreach (var package in newestPackages)
{
var newestFramework = GetNewestSupportedFramework(package);
packageReferenceFile.AddEntry(package.Id, package.Version, newestFramework);
if (newestFramework == null)
{
yield return(string.Format("{0}, Version {1}", package.Id, package.Version));
}
else
{
yield return(string.Format("{0}, Version {1}, .NET {2}", package.Id, package.Version, newestFramework.Version));
}
}
}
public AuditProject(IProject roslynProject, FrameworkName targetFramework, Options options)
{
// Shared
RoslynProject = roslynProject;
MsBuildProject = RoslynProject.GetMsBuildProject();
LocalRepository = RoslynProject.Solution.GetLocalPackageRepository();
ConfigReferences = PackageReferenceFile.CreateFromProject(RoslynProject.FilePath).GetPackageReferences(false).ToList();
CsprojReferences = MsBuildProject.GetDirectPackageAssemblies().Select(g => g.Key).Where(r => r != null).Distinct().ToList();
References = ConfigReferences.Union(CsprojReferences).ToList();
Packages = options.Unused || options.Snapshot || options.Missing || options.Project
? References.Select(r => r.GetPackage(LocalRepository)).Where(p => p != null).ToList()
: Enumerable.Empty <IPackage>();
// Unused Packages
UnusedPackages = options.Unused
? GetUnusedPackages(targetFramework, options.UnusedUsings)
: Enumerable.Empty <UnusedPackage>();
// Snapshot References
SnapshotPackages = options.Snapshot
? Packages.GetSnapshotPackages()
: Enumerable.Empty <SnapshotPackage>();
// Missing Packages
MissingPackages = options.Missing
? GetMissingPackages(targetFramework)
: Enumerable.Empty <MissingPackageDependency>();
// Project Packages
ProjectPackages = options.Project
? GetProjectPackages()
: Enumerable.Empty <ProjectPackage>();
// File Diff References
MissingPackageReferences = options.FileDiff
? GetMissingPackageReferences()
: Enumerable.Empty <InconsistentFiles>();
// Duplicate Package References
DuplicatePackageReferences = options.FileDiff
? GetDuplicatePackageReferences()
: Enumerable.Empty <DuplicatePackageReference>();
// Orphan Binding Redirects
BindingRedirectOnlyReferences = options.FileDiff
? GetBindingRedirectOnlyReferences()
: Enumerable.Empty <OrphanAssemblyBinding>();
// Mismatched Binding Redirects
BindingRedirectMismatchReferences = options.RedirectMismatch
? GetBindingRedirectMismatchReferences()
: Enumerable.Empty <MismatchAssemblyBinding>();
BadProjectRefGuids = options.FileDiff
? GetBadProjectRefGuids()
: Enumerable.Empty <MismatchedGuid>();
IllegalNugetTargets = options.NugetTargets
? GetIllegalNugetTargets()
: Enumerable.Empty <IllegalProjectFileElement>();
}
private static JArray ParseNugetDependencies(string packagesConfigPath)
{
var nugetDependencies = new JArray();
if (!File.Exists(packagesConfigPath))
{
Console.Error.WriteLine($"Unable to find nuget dependencies file during project file parsing: {packagesConfigPath}");
return(nugetDependencies);
}
var file = new PackageReferenceFile(packagesConfigPath);
foreach (PackageReference packageReference in file.GetPackageReferences())
{
var dependency = new JObject();
dependency["Id"] = packageReference.Id;
dependency["Version"] = packageReference.Version.ToString();
dependency["TargetFramework"] = packageReference.TargetFramework.ToString();
dependency["RequireReinstallation"] = packageReference.RequireReinstallation;
dependency["IsDevelopmentDependency"] = packageReference.IsDevelopmentDependency;
JObject versionConstraint = null;
if (packageReference.VersionConstraint != null)
{
versionConstraint = new JObject();
versionConstraint["MinVersion"] = packageReference.VersionConstraint.MinVersion.ToString();
versionConstraint["MaxVersion"] = packageReference.VersionConstraint.MaxVersion.ToString();
versionConstraint["IsMinInclusive"] = packageReference.VersionConstraint.IsMinInclusive;
versionConstraint["IsMaxInclusive"] = packageReference.VersionConstraint.IsMaxInclusive;
}
dependency["VersionConstraint"] = versionConstraint;
nugetDependencies.Add(dependency);
}
return(nugetDependencies);
}
public static ICollection <PackageReference> GetPackageReferences(PackageReferenceFile configFile, bool requireVersion)
{
if (configFile == null)
{
throw new ArgumentNullException("configFile");
}
var packageReferences = configFile.GetPackageReferences(requireVersion).ToList();
foreach (var package in packageReferences)
{
// GetPackageReferences returns all records without validating values. We'll throw if we encounter packages
// with malformed ids / Versions.
if (String.IsNullOrEmpty(package.Id))
{
throw new InvalidDataException(
String.Format(CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("InstallCommandInvalidPackageReference"),
configFile.FullPath));
}
if (requireVersion && (package.Version == null))
{
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("InstallCommandPackageReferenceInvalidVersion"), package.Id));
}
}
return(packageReferences);
}
public override void ExecuteCommand()
{
if (string.IsNullOrEmpty(Directory))
{
Directory = Environment.CurrentDirectory;
}
if (_repository == null)
{
_repository = AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source);
}
var packageFiles = _fileSystem.GetFiles(Directory, "packages.config", true).ToList();
Console.WriteLine("Processing : {0} files.",packageFiles.Count);
Parallel.ForEach(packageFiles, packageFile =>
{
Console.WriteLine("\t{0}", packageFile);
var newReferences = new List<PackageReference>();
var packageFileDetails = new PackageReferenceFile(_fileSystem, packageFile);
foreach (var packageReference in packageFileDetails.GetPackageReferences())
{
Console.WriteLine("\t\t{0}",packageReference.ToString());
var exists = _repository.FindPackage(packageReference.Id, packageReference.Version);
if (exists != null)
{
Console.WriteLine("\t\t\tExists, not changing.");
newReferences.Add(packageReference);
}
else
{
var package = _repository.FindPackagesById(packageReference.Id).FirstOrDefault();
if (package == null)
{
Console.WriteLine("\t\t\tNot found, no change.");
newReferences.Add(packageReference);
}
else
{
var newReference = new PackageReference(package.Id, package.Version, new VersionSpec(), new FrameworkName(".NET Framework, Version=4.0"), false);
Console.WriteLine("\t\t\tUpdated to {0}", newReference.ToString());
newReferences.Add(newReference);
}
}
}
//TODO Clear the file (must be an easier way).
Console.WriteLine("Clearing existing file...");
foreach (var packageReference in packageFileDetails.GetPackageReferences())
{
packageFileDetails.DeleteEntry(packageReference.Id, packageReference.Version);
}
//Add the new references.
Console.WriteLine("Adding new references...");
foreach (var packageReference in newReferences)
{
packageFileDetails.AddEntry(packageReference.Id, packageReference.Version);
}
});
}
public override void ExecuteCommand()
{
CalculateEffectivePackageSaveMode();
string installPath = ResolveInstallPath();
IFileSystem fileSystem = CreateFileSystem(installPath);
string configFilePath = Path.GetFullPath(Arguments.Count == 0 ? Constants.PackageReferenceFile : Arguments[0]);
string configFileName = Path.GetFileName(configFilePath);
// If the first argument is a packages.xxx.config file, install everything it lists
// Otherwise, treat the first argument as a package Id
if (PackageReferenceFile.IsValidConfigFileName(configFileName))
{
Prerelease = true;
// By default the PackageReferenceFile does not throw if the file does not exist at the specified path.
// We'll try reading from the file so that the file system throws a file not found
EnsureFileExists(fileSystem, configFilePath);
InstallPackagesFromConfigFile(fileSystem, GetPackageReferenceFile(configFilePath));
}
else
{
string packageId = Arguments[0];
SemanticVersion version = Version != null ? new SemanticVersion(Version) : null;
InstallPackage(fileSystem, packageId, version);
}
}
/*<summary>
* Using Nuget.Core API, we gather all nuget`s packages that specific project depend on them.
* </summary>
* <returns></returns>
*/
private static void addDependencies(string projectName, Module module, string localSource, string[] packageConfigPath, string Configuration)
{
if (packageConfigPath.Length != 0)
{
var sharedPackages = new LocalPackageRepository(localSource);
var packageReferenceFile = new PackageReferenceFile(packageConfigPath[0]);
IEnumerable <PackageReference> projectPackages = packageReferenceFile.GetPackageReferences();
foreach (PackageReference package in projectPackages)
{
var pack = sharedPackages.FindPackage(package.Id, package.Version);
using (Stream packageStream = ((NuGet.OptimizedZipPackage)(pack)).GetStream())
{
byte[] buf = new byte[packageStream.Length];
int byteread = packageStream.Read(buf, 0, buf.Length);
module.Dependencies.Add(new Dependency
{
type = "nupkg",
md5 = MD5CheckSum.GenerateMD5(buf),
sha1 = Sha1Reference.GenerateSHA1(buf),
scopes = new List <string> {
Configuration
},
id = pack.Id + ":" + pack.Version
});
}
}
}
}
//writes new version of the package to packages.config file
public void writeToConfig(string fileName, string packageId, SemanticVersion newversion)
{
var file = new PackageReferenceFile(fileName);
file.DeleteEntry(packageId, null);
file.AddEntry(packageId, newversion);
}
private static void TestSourceGenerator()
{
string packageFile = Path.Combine(basePath, "TestApp", "packages.config");
var file = new PackageReferenceFile(packageFile);
// Default the version in case the package is removed or unavailable
string version = "2.5.0.6";
foreach (var package in file.GetPackageReferences())
{
if (package.Id == "nHapi")
{
version = package.Version.ToString();
break;
}
}
var nHapiPath = Path.Combine($"packages\\nHapi.{version}\\lib");
var dllFiles = Directory.GetFiles(Path.Combine(basePath, nHapiPath), "*.dll");
Console.WriteLine("\n==============================================\nTesting source generation.");
foreach (var dllFile in dllFiles)
{
if (dllFile.Contains("NHapi.Model.V"))
{
Console.WriteLine($"Generating source for {dllFile}.");
Generator gen2 = new Generator(dllFile, basePath);
SpinnerWhileWaiting(gen2.Generate);
Generator gen = new Generator(dllFile, Path.Combine(basePath + "\\Output"));
SpinnerWhileWaiting(gen.Generate);
}
}
}
private void InstallPackagesFromConfigFile(IFileSystem fileSystem, PackageReferenceFile file)
{
var packageReferences = file.GetPackageReferences().ToList();
foreach (var package in packageReferences)
{
if (String.IsNullOrEmpty(package.Id))
{
// GetPackageReferences returns all records without validating values. We'll throw if we encounter packages
// with malformed ids / Versions.
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, NuGetResources.InstallCommandInvalidPackageReference, Arguments[0]));
}
else if (package.Version == null)
{
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, NuGetResources.InstallCommandPackageReferenceInvalidVersion, package.Id));
}
}
bool installedAny = ExecuteInParallel(fileSystem, packageReferences);
if (!installedAny && packageReferences.Any())
{
Console.WriteLine(NuGetResources.InstallCommandNothingToInstall, Constants.PackageReferenceFile);
}
}
public override async Task ExecuteCommandAsync()
{
// update with self as parameter
if (Self)
{
var selfUpdater = new SelfUpdater(RepositoryFactory)
{
Console = Console
};
selfUpdater.UpdateSelf(Prerelease);
return;
}
string inputFile = GetInputFile();
if (string.IsNullOrEmpty(inputFile))
{
throw new CommandLineException(NuGetResources.InvalidFile);
}
_msbuildDirectory = new Lazy <string>(() => MsBuildUtility.GetMsbuildDirectory(MSBuildVersion, Console));
var context = new UpdateConsoleProjectContext(Console, FileConflictAction);
string inputFileName = Path.GetFileName(inputFile);
// update with packages.config as parameter
if (PackageReferenceFile.IsValidConfigFileName(inputFileName))
{
await UpdatePackagesAsync(inputFile, context);
return;
}
// update with project file as parameter
if (ProjectHelper.SupportedProjectExtensions.Contains(Path.GetExtension(inputFile) ?? string.Empty))
{
if (!File.Exists(inputFile))
{
throw new CommandLineException(NuGetResources.UnableToFindProject, inputFile);
}
var projectSystem = new MSBuildProjectSystem(
_msbuildDirectory.Value,
inputFile,
context);
await UpdatePackagesAsync(projectSystem, GetRepositoryPath(projectSystem.ProjectFullPath));
return;
}
if (!File.Exists(inputFile))
{
throw new CommandLineException(NuGetResources.UnableToFindSolution, inputFile);
}
// update with solution as parameter
string solutionDir = Path.GetDirectoryName(inputFile);
await UpdateAllPackages(solutionDir, context);
}
public void GetPackageReferencesReadFromConfigFileIfProjectConfigFileDoesNotExist()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""luan"" version=""1.0"" />
</packages>";
var projectConfig = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""an"" version=""1.0"" />
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
fileSystem.AddFile("packages.project.config", projectConfig);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config", "chocolate");
// Act
var values = packageReferenceFile.GetPackageReferences().ToArray();
// Assert
Assert.Equal(1, values.Length);
Assert.Equal("luan", values[0].Id);
}
private static List <PackageReferenceFile> GetPackageReferenceFileList()
{
var x1 = @"<?xml version='1.0' encoding='utf-8'?>
<packages>
<package id='Package1' version='1.0' allowedVersions='[1.0, 2.0)' />
<package id='Package2' version='2.0' />
</packages>";
var x2 = @"<?xml version='1.0' encoding='utf-8'?>
<packages>
<package id='Package1' version='2.0' allowedVersions='[1.0, 3.0)' />
<package id='Package2' version='2.0' />
</packages>";
var mfs = new Mock <MockFileSystem>();
mfs.Setup(m => m.OpenFile("x1")).Returns(x1.AsStream());
mfs.Setup(m => m.OpenFile("x2")).Returns(x2.AsStream());
mfs.Setup(m => m.FileExists(It.IsAny <string>())).Returns(true);
var mpr1 = new PackageReferenceFile(mfs.Object, "x1");
var mpr2 = new PackageReferenceFile(mfs.Object, "x2");
var packageFiles = new List <PackageReferenceFile>();
packageFiles.Add(mpr1);
packageFiles.Add(mpr2);
return(packageFiles);
}
/// <summary>
/// Outputs a package.config file reflecting the set of packages that provides the requested set of assemblies.
/// </summary>
public void OutputPackageConfigFile()
{
var packagesConfig = Constants.PackageReferenceFile;
if (_fileSystem.FileExists(packagesConfig))
_fileSystem.DeleteFile(packagesConfig);
if (!_fileSystem.FileExists(packagesConfig))
{
var prf = new PackageReferenceFile(_fileSystem, string.Format(".\\{0}", packagesConfig));
foreach (var assemblyToPackageMapping in ResolvedMappings)
{
IPackage smallestPackage;
if (assemblyToPackageMapping.Value.Count > 1)
{
smallestPackage = assemblyToPackageMapping.Value.OrderBy(l => l.GetFiles().Count()).FirstOrDefault();
_console.WriteLine(String.Format("{0} : Choosing {1} from {2} choices.", assemblyToPackageMapping.Key, smallestPackage.Id, assemblyToPackageMapping.Value.Count()));
}
else
{
smallestPackage = assemblyToPackageMapping.Value.First();
}
//Only add if we do not have another instance of the ID, not the id/version combo....
if (!prf.GetPackageReferences().Any(p => p.Id == smallestPackage.Id))
prf.AddEntry(smallestPackage.Id, smallestPackage.Version);
}
}
else
{
_console.WriteError("Please move the existing packages.config file....");
}
}
public override bool Execute()
{
var packageReferenceFile = PackageReferenceFile.CreateFromProject(ProjectPath);
PackageReferences = packageReferenceFile.GetPackageReferences().Select(ConvertPackageElement).ToArray();
return(true);
}
public static void MarkPackagesForReinstallationMarksPackagesProperly()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""1.0"" targetFramework=""net30""/>
<package id=""B"" version=""1.0""/>
<package id=""C"" version=""1.0"" targetFramework=""net40""/>
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config");
IList <IPackage> packagesToBeReinstalled = new List <IPackage>()
{
PackageUtility.CreatePackage("A", "1.0"), PackageUtility.CreatePackage("C", "1.0")
};
// Act
ProjectRetargetingUtility.MarkPackagesForReinstallation(packageReferenceFile, packagesToBeReinstalled);
var packageReferences = packageReferenceFile.GetPackageReferences().ToList();
// Assert
Assert.Equal(3, packageReferences.Count);
Assert.Equal("A", packageReferences[0].Id);
Assert.Equal("B", packageReferences[1].Id);
Assert.Equal("C", packageReferences[2].Id);
Assert.True(packageReferences[0].RequireReinstallation);
Assert.False(packageReferences[1].RequireReinstallation);
Assert.True(packageReferences[2].RequireReinstallation);
}
/// <summary>
/// Outputs a package.config file reflecting the set of packages that provides the requested set of assemblies.
/// </summary>
public void OutputPackageConfigFile()
{
if (fileSystem.FileExists("packages.config"))
fileSystem.DeleteFile("packages.config");
if (!fileSystem.FileExists("packages.config"))
{
var prf = new PackageReferenceFile(fileSystem,".\\packages.config");
foreach (var assemblyToPackageMapping in resolvedAssemblies)
{
if (assemblyToPackageMapping.Value.Count() > 0)
{
IPackage smallestPackage;
if (assemblyToPackageMapping.Value.Count > 1)
{
smallestPackage = assemblyToPackageMapping.Value.OrderBy(l => l.GetFiles().Count()).FirstOrDefault();
Console.WriteLine(String.Format("{0} : Choosing : {1} - {2} to choose from.", assemblyToPackageMapping.Key, smallestPackage.Id, assemblyToPackageMapping.Value.Count()));
}
else
{
smallestPackage = assemblyToPackageMapping.Value.First();
}
//Only add if we do not have another instance of the ID, not the id/version combo....
if (!prf.GetPackageReferences().Any(p => p.Id == smallestPackage.Id))
prf.AddEntry(smallestPackage.Id, smallestPackage.Version);
}
}
}
else
{
Console.WriteError("Please move the existing packages.config file....");
}
}
private DeployMessage.Item[] DeployPackagesFromConfigFile(PackageReferenceFile file)
{
var source = file.GetPackageReferences().ToList();
if (!source.Any())
{
return(null);
}
var list = new List <DeployMessage.Item>();
foreach (PackageReference reference in source)
{
if (string.IsNullOrEmpty(reference.Id))
{
throw new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Local.DeployCommandInvalidPackageReference, new[] { Arguments[1] }));
}
if (reference.Version == null)
{
throw new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Local.DeployCommandPackageReferenceInvalidVersion, new[] { reference.Id }));
}
list.Add(new DeployMessage.Item
{
PackageId = reference.Id,
Version = reference.Version.ToString(),
});
}
return(list.ToArray());
}
public void RegisterRepositoryDoesNotAddRelativePathToRepositoriesConfigIfExists()
{
// Arrange
var fileSystem = new Mock <MockFileSystem>()
{
CallBase = true
};
fileSystem.Object.AddFile("repositories.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""A\packages.config"" />
<repository path=""B\packages.config"" />
</repositories>");
fileSystem.Setup(m => m.Root).Returns(@"x:\foo\");
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, new MockFileSystem());
var packageReferenceFile = new PackageReferenceFile(new MockFileSystem(), @"x:\foo\A\packages.config");
// Act
repository.RegisterRepository(packageReferenceFile);
// Assert
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""A\packages.config"" />
<repository path=""B\packages.config"" />
</repositories>", fileSystem.Object.ReadAllText("repositories.config"));
}
private void AddDependencies(Dictionary <String, Tuple <IPackage, PackageDependency> > packagesAndDependencies)
{
string packagesConfig = GetPackagesConfig();
if (String.IsNullOrEmpty(packagesConfig))
{
return;
}
Logger.Log(MessageLevel.Info, NuGetResources.UsingPackagesConfigForDependencies);
var file = new PackageReferenceFile(packagesConfig);
// Get the solution repository
IPackageRepository repository = GetPackagesRepository();
// Collect all packages
IDictionary <PackageName, PackageReference> packageReferences =
file.GetPackageReferences().ToDictionary(r => new PackageName(r.Id, r.Version));
// add all packages and create an associated dependency to the dictionary
foreach (PackageReference reference in packageReferences.Values)
{
if (repository != null)
{
IPackage package = repository.FindPackage(reference.Id, reference.Version);
if (package != null && !packagesAndDependencies.ContainsKey(package.Id))
{
IVersionSpec spec = GetVersionConstraint(packageReferences, package);
var dependency = new PackageDependency(package.Id, spec);
packagesAndDependencies.Add(package.Id, new Tuple <IPackage, PackageDependency>(package, dependency));
}
}
}
}
public override Task ExecuteCommandAsync()
{
CalculateEffectivePackageSaveMode();
CalculateEffectiveSettings();
string installPath = ResolveInstallPath();
string configFilePath = Path.GetFullPath(Arguments.Count == 0 ? Constants.PackageReferenceFile : Arguments[0]);
string configFileName = Path.GetFileName(configFilePath);
// If the first argument is a packages.xxx.config file, install everything it lists
// Otherwise, treat the first argument as a package Id
if (PackageReferenceFile.IsValidConfigFileName(configFileName))
{
Prerelease = true;
// display opt-out message if needed
if (Console != null && RequireConsent &&
new PackageRestoreConsent(new SettingsToLegacySettings(Settings)).IsGranted)
{
string message = String.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("RestoreCommandPackageRestoreOptOutMessage"),
NuGet.Resources.NuGetResources.PackageRestoreConsentCheckBoxText.Replace("&", ""));
Console.WriteLine(message);
}
return(PerformV2Restore(configFilePath, installPath));
}
else
{
var packageId = Arguments[0];
var version = Version != null ? new NuGetVersion(Version) : null;
return(InstallPackage(packageId, version, installPath));
}
}
private void AddDependencies(Dictionary <String, Tuple <IPackage, PackageDependency> > packagesAndDependencies)
{
var file = PackageReferenceFile.CreateFromProject(_project.FullPath);
if (!File.Exists(file.FullPath))
{
return;
}
Logger.Log(MessageLevel.Info, LocalizedResourceManager.GetString("UsingPackagesConfigForDependencies"));
// Get the solution repository
IPackageRepository repository = GetPackagesRepository();
// Collect all packages
IDictionary <PackageName, PackageReference> packageReferences =
file.GetPackageReferences()
.Where(r => !r.IsDevelopmentDependency)
.ToDictionary(r => new PackageName(r.Id, r.Version));
// add all packages and create an associated dependency to the dictionary
foreach (PackageReference reference in packageReferences.Values)
{
if (repository != null)
{
IPackage package = repository.FindPackage(reference.Id, reference.Version);
if (package != null && !packagesAndDependencies.ContainsKey(package.Id))
{
IVersionSpec spec = GetVersionConstraint(packageReferences, package);
var dependency = new PackageDependency(package.Id, spec);
packagesAndDependencies.Add(package.Id, new Tuple <IPackage, PackageDependency>(package, dependency));
}
}
}
}
public void Execute(IDataContext context, DelegateExecute nextExecute)
{
ISolution solution = context.GetData <ISolution>(JetBrains.ProjectModel.DataContext.DataConstants.SOLUTION);
if (solution == null)
{
return;
}
string extensionFilters = "NuGet packages.config|packages.config|All files (*.*)|*.*";
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.CheckFileExists = true;
openFileDialog.AddExtension = false;
openFileDialog.ValidateNames = true;
openFileDialog.Multiselect = false;
openFileDialog.Filter = extensionFilters;
bool?openFileDialogResult = openFileDialog.ShowDialog();
if ((!openFileDialogResult.GetValueOrDefault() ? 1 : (!openFileDialogResult.HasValue ? 1 : 0)) != 0)
{
return;
}
foreach (var packagesConfigFile in openFileDialog.FileNames)
{
var packagesConfig = new PackageReferenceFile(packagesConfigFile);
var packagesToOpen = GetPackagesToOpen(packagesConfig);
OpenPackageFilesInCurrentSolution(context, packagesToOpen);
}
}
public void GetPackageReferencesParseTargetFrameworkCorrectly()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""1.0"" targetFramework=""sl4"" />
<package id=""B"" version=""1.0"" targetFramework=""net35-client"" />
<package id=""C"" version=""1.0"" targetFramework=""winrt45"" />
<package id=""D"" version=""1.0"" />
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config");
// Act
var values = packageReferenceFile.GetPackageReferences().ToList();
// Assert
Assert.Equal(4, values.Count);
Assert.Equal(new FrameworkName("Silverlight, Version=4.0"), values[0].TargetFramework);
Assert.Equal(new FrameworkName(".NETFramework, Version=3.5, Profile=Client"), values[1].TargetFramework);
Assert.Equal(new FrameworkName(".NETCore, Version=4.5"), values[2].TargetFramework);
Assert.Null(values[3].TargetFramework);
}
public void CanDetectMissingVersionAndUpdateToValid()
{
var fileSystem = new MockFileSystem(@"d:\");
fileSystem.AddFile(@"d:\test\packages.config",
"<packages>" +
"<package id=\"Test\" version=\"1.0.0.0\" />" +
"<package id=\"Other\" version=\"1.0.0.0\" />" +
"</packages>");
var repository = new MockPackageRepository("http://test.com");
repository.AddPackage(PackageUtility.CreatePackage("Test", "2.0.0.0"));
repository.AddPackage(PackageUtility.CreatePackage("Other", "1.0.0.0"));
var command = new FixReferences(fileSystem, repository, new Console())
{
Directory = @"d:\test"
};
command.Execute();
var packageReferences = new PackageReferenceFile(fileSystem, @"d:\test\packages.config").GetPackageReferences().ToList();
Assert.AreEqual("2.0.0.0", packageReferences.First(p => p.Id == "Test").Version.Version.ToString());
Assert.AreEqual("1.0.0.0", packageReferences.First(p => p.Id == "Other").Version.Version.ToString());
}
private void AddFiles(PackageBuilder builder, string itemType, string targetFolder)
{
// Skip files that are added by dependency packages
string packagesConfig = GetPackagesConfig();
IPackageRepository repository = GetPackagesRepository();
var contentFilesInDependencies = new List <IPackageFile>();
if (packagesConfig != null && repository != null)
{
var references = new PackageReferenceFile(packagesConfig).GetPackageReferences();
contentFilesInDependencies = references.Select(reference => repository.FindPackage(reference.Id, reference.Version))
.SelectMany(a => a.GetContentFiles())
.ToList();
}
// Get the content files from the project
foreach (var item in _project.GetItems(itemType))
{
string fullPath = item.GetMetadataValue("FullPath");
if (_excludeFiles.Contains(Path.GetFileName(fullPath)))
{
continue;
}
string targetFilePath = GetTargetPath(item);
if (!File.Exists(fullPath))
{
Logger.Log(MessageLevel.Warning, NuGetResources.Warning_FileDoesNotExist, targetFilePath);
continue;
}
// Check that file is added by dependency
string targetPath = Path.Combine(targetFolder, targetFilePath);
IPackageFile targetFile = contentFilesInDependencies.Find(a => a.Path.Equals(targetPath, StringComparison.OrdinalIgnoreCase));
if (targetFile != null)
{
// Compare contents as well
using (var dependencyFileStream = targetFile.GetStream())
using (var fileContentsStream = File.Open(fullPath, FileMode.Open))
{
var isEqual = FileHelper.AreFilesEqual(dependencyFileStream, fileContentsStream);
if (isEqual)
{
Logger.Log(MessageLevel.Info, NuGetResources.PackageCommandFileFromDependencyIsNotChanged, targetFilePath);
continue;
}
Logger.Log(MessageLevel.Info, NuGetResources.PackageCommandFileFromDependencyIsChanged, targetFilePath);
}
}
builder.Files.Add(new PhysicalPackageFile
{
SourcePath = fullPath,
TargetPath = targetPath
});
}
}
//https://stackoverflow.com/questions/36143663/create-a-visual-studio-project-template-that-pulls-nuget-references-from-online
public static void InstallPackages(Project project)
{
ProjectItem config = project.ProjectItems.Item("packages.init");
DTE dte = project.DTE;
if (config == null && config.FileCount == 0)
{
return;
}
var path = config.FileNames[0];
WriteToOutput(dte, "Installing packages for " + project.Name);
var componentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel));
IVsPackageInstallerServices installerServices =
componentModel.GetService <IVsPackageInstallerServices>();
var file = new PackageReferenceFile(path);
foreach (PackageReference pRef in file.GetPackageReferences())
{
if (!installerServices.IsPackageInstalled(project, pRef.Id))
{
WriteToOutput(dte, String.Format("Installing {0}, version {1}", pRef.Id, pRef.Version.Version.ToString()));
var installer = componentModel.GetService <IVsPackageInstaller>();
installer.InstallPackage(
"All",
project,
pRef.Id,
pRef.Version.Version,
false);
}
}
config.Delete();
}
IEnumerable<PackageReference> GetPackageReferences ()
{
if (project.HasPackages ()) {
var packageReferenceFile = new PackageReferenceFile (project.GetPackagesConfigFilePath ());
return packageReferenceFile.GetPackageReferences ();
}
return new PackageReference [0];
}
public static bool IsPackagesConfigFileName(this FilePath filePath)
{
if (filePath == null)
{
return(false);
}
return(PackageReferenceFile.IsValidConfigFileName(filePath.FileName));
}
protected virtual IEnumerable <PackageReference> GetPackageReferences()
{
if (project.HasPackages())
{
var packageReferenceFile = new PackageReferenceFile(project.GetPackagesConfigFilePath());
return(packageReferenceFile.GetPackageReferences());
}
return(new PackageReference [0]);
}
private static ICollection <PackageReference> GetPackageReferences(string fullConfigFilePath, string projectName)
{
var projectFileSystem = new PhysicalFileSystem(Path.GetDirectoryName(fullConfigFilePath));
string configFileName = Path.GetFileName(fullConfigFilePath);
PackageReferenceFile file = new PackageReferenceFile(projectFileSystem, configFileName, projectName);
return(CommandLineUtility.GetPackageReferences(file, requireVersion: true));
}
public override bool Execute()
{
var packageReferences = from project in Projects
let packageReferenceFile = PackageReferenceFile.CreateFromProject(project.GetMetadata("FullPath"))
from packageReference in packageReferenceFile.GetPackageReferences()
select ConvertPackageElement(project, packageReference);
PackageReferences = packageReferences.ToArray();
return(true);
}
private void CreatePackagesConfig(ICollection<IPackage> packagesToAdd, FrameworkName targetFramework = null)
{
_console.WriteLine("Creating {0}", PackageReferenceFilename);
var packagesConfig = new PackageReferenceFile(_projectFileSystem, PackageReferenceFilename);
foreach (var package in packagesToAdd)
{
if (!packagesConfig.EntryExists(package.Id, package.Version)) //Note we don't re-add entries that have the wrong targetFramework set
{
packagesConfig.AddEntry(package.Id, package.Version, false, targetFramework);
}
}
}
private static void CreatePackageConfigs(IFileSystem fs, out PackageReferenceFile f1, out PackageReferenceFile f2)
{
f1 = (new PackageReferenceFile(fs, @"c:\test1\packages.config"));
f1.AddEntry("Test", SemanticVersion.Parse("1.0.0.0"));
f1.AddEntry("Test", SemanticVersion.Parse("1.1.0.0"));
f1.AddEntry("Test", SemanticVersion.Parse("1.2.0.0"));
f2 = (new PackageReferenceFile(fs, @"c:\test2\packages.config"));
f2.AddEntry("Test", SemanticVersion.Parse("1.0.0.0"));
f2.AddEntry("Test", SemanticVersion.Parse("1.1.0.0"));
f2.AddEntry("Test", SemanticVersion.Parse("1.2.0.0"));
}
public void ConstructorNormalizeProjectName()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\");
fileSystem.AddFile("packages.project_with_space.config", "");
// Act
var packageReferenceFile = new PackageReferenceFile(
fileSystem, "packages.config", "project with space");
// Assert
Assert.Equal("x:\\packages.project_with_space.config", packageReferenceFile.FullPath);
}
public void ReferenceToPackageIdNotOnFeedStays()
{
var fileSystem = new MockFileSystem(@"d:\");
fileSystem.AddFile(@"d:\test\packages.config",
"<packages>" +
"<package id=\"Missing\" version=\"1.0.0.0\" />" +
"</packages>");
var repository = new MockPackageRepository("http://test.com");
var command = new FixReferences(fileSystem, repository, new Console()) { Directory = @"d:\test" };
command.Execute();
var packageReferences = new PackageReferenceFile(fileSystem, @"d:\test\packages.config").GetPackageReferences().ToList();
Assert.AreEqual("1.0.0.0", packageReferences.First(p => p.Id == "Missing").Version.Version.ToString());
}
public TestablePackageCompatibilityRunner (
IDotNetProject project,
IPackageManagementSolution solution,
IRegisteredPackageRepositories registeredRepositories,
IPackageManagementProgressMonitorFactory progressMonitorFactory,
IPackageManagementEvents packageManagementEvents,
IProgressProvider progressProvider)
: base (
project,
solution,
registeredRepositories,
progressMonitorFactory,
packageManagementEvents,
progressProvider)
{
PackageReferenceFile = new PackageReferenceFile (FileSystem, "packages.config");
}
public void RestorePackages(Project project)
{
string packageReferenceFileFullPath;
Tuple<string, string> packageReferenceFiles = VsUtility.GetPackageReferenceFileFullPaths(project);
if (File.Exists(packageReferenceFiles.Item1))
{
packageReferenceFileFullPath = packageReferenceFiles.Item1;
}
else if (File.Exists(packageReferenceFiles.Item2))
{
packageReferenceFileFullPath = packageReferenceFiles.Item2;
}
else
{
return;
}
var packageReferenceFile = new PackageReferenceFile(packageReferenceFileFullPath);
var packages = packageReferenceFile.GetPackageReferences().ToList();
if (packages.Count == 0)
{
return;
}
var repoSettings = ServiceLocator.GetInstance<IRepositorySettings>();
var fileSystem = new PhysicalFileSystem(repoSettings.RepositoryPath);
var activePackageSourceRepository = ServiceLocator.GetInstance<IPackageRepository>();
var repository = new PriorityPackageRepository(NuGet.MachineCache.Default, activePackageSourceRepository);
IVsPackageManagerFactory packageManagerFactory = ServiceLocator.GetInstance<IVsPackageManagerFactory>();
var packageManager = packageManagerFactory.CreatePackageManager(repository, useFallbackForDependencies: false);
foreach (var package in packages)
{
if (IsPackageInstalled(fileSystem, package.Id, package.Version))
{
continue;
}
using (packageManager.SourceRepository.StartOperation(RepositoryOperationNames.Restore, package.Id, package.Version.ToString()))
{
var resolvedPackage = PackageHelper.ResolvePackage(
packageManager.SourceRepository, package.Id, package.Version);
NuGet.Common.PackageExtractor.InstallPackage(packageManager, resolvedPackage);
}
}
}
public void GetPackageReferencesThrowsIfVersionIsNotPresent()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version="""" />
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config");
// Act
var values = packageReferenceFile.GetPackageReferences();
// Assert
Assert.Empty(values);
}
public void GetPackageReferencesThrowsIfVersionSpecIsInvalid()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""1.3.4"" allowedVersions=""1.23.4$-2.0"" />
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config");
// Act
var values = packageReferenceFile.GetPackageReferences();
// Assert
ExceptionAssert.Throws<InvalidDataException>(() => values.ToList(), "Unable to parse version value '1.23.4$-2.0' from 'packages.config'.");
}
public void GetPackageReferencesThrowsIfVersionIsInvalid(string version)
{
// Arrange
var config = String.Format(CultureInfo.InvariantCulture, @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""{0}"" />
</packages>", version);
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config");
// Act
var values = packageReferenceFile.GetPackageReferences();
// Assert
ExceptionAssert.Throws<InvalidDataException>(() => values.ToList(), "Unable to parse version value '" + version + "' from 'packages.config'.");
}
/// <summary>
/// Executes the command.
/// </summary>
public override void ExecuteCommand()
{
string inputPackagesConfigPath = GetLatestPackagesConfigPath();
string outputPackagesConfigPath = GetPackagesConfigPath();
if (String.IsNullOrEmpty(inputPackagesConfigPath) || String.IsNullOrEmpty(outputPackagesConfigPath))
{
throw new CommandLineException();
}
if (!File.Exists(inputPackagesConfigPath))
{
throw new CommandLineException();
}
TryCreateAllDirectories(Path.GetDirectoryName(outputPackagesConfigPath));
if(!File.Exists(outputPackagesConfigPath))
{
File.WriteAllText(outputPackagesConfigPath, @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
</packages>");
}
PhysicalFileSystem outputFileSystem = new PhysicalFileSystem(Path.GetDirectoryName(outputPackagesConfigPath));
PackageReferenceFile outputFile = new PackageReferenceFile(outputFileSystem, Path.GetFileName(outputPackagesConfigPath));
// Remove all existing references from output file
Dictionary<string, SemanticVersion> existingReferences = new Dictionary<string,SemanticVersion>();
foreach (PackageReference packageReference in outputFile.GetPackageReferences())
{
existingReferences.Add(packageReference.Id, packageReference.Version);
}
foreach (KeyValuePair<string, SemanticVersion> pair in existingReferences)
{
outputFile.DeleteEntry(pair.Key, pair.Value);
}
PhysicalFileSystem inputFileSystem = new PhysicalFileSystem(Path.GetDirectoryName(inputPackagesConfigPath));
PackageReferenceFile inputFile = new PackageReferenceFile(inputFileSystem, Path.GetFileName(inputPackagesConfigPath));
foreach (PackageReference packageReference in inputFile.GetPackageReferences())
{
IPackage package = GetLatestPackage(packageReference.Id);
outputFile.AddEntry(packageReference.Id, package.Version, false, packageReference.TargetFramework);
}
}
public void CheckProjectPackages (IDotNetProject project)
{
IPackageManagementProject packageManagementProject = solution.GetProject (registeredRepositories.ActiveRepository, project);
packageReferenceFile = CreatePackageReferenceFile (project.GetPackagesConfigFilePath ());
packageReferences = packageReferenceFile.GetPackageReferences ().ToList ();
compatibilityReport = new ProjectPackagesCompatibilityReport (packageManagementProject.TargetFramework);
foreach (PackageReference packageReference in packageReferences) {
IPackage package = packageManagementProject.FindPackage (packageReference.Id);
if (package != null) {
if (PackageNeedsReinstall (project, package, packageReference.TargetFramework)) {
packagesRequiringReinstallation.Add (package);
}
}
}
}
public void GetPackageReturnsReferencesWithEmptyVersionsWhenRequiredVersionIsFalse()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version="""" />
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config");
// Act
var values = packageReferenceFile.GetPackageReferences(requireVersion: false);
// Assert
Assert.Equal(1, values.Count());
Assert.Equal("A", values.First().Id);
Assert.Null(values.First().Version);
}
public void GetPackageReferencesNormalizeProjectName()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""luan"" version=""1.0"" />
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
fileSystem.AddFile("packages.project_with_space.config", config);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config", "project with space");
// Act
var values = packageReferenceFile.GetPackageReferences().ToArray();
// Assert
Assert.Equal(1, values.Length);
Assert.Equal("luan", values[0].Id);
}
public void CanDetectMissingVersionAndUpdateToValid()
{
var fileSystem = new MockFileSystem(@"d:\");
fileSystem.AddFile(@"d:\test\packages.config",
"<packages>" +
"<package id=\"Test\" version=\"1.0.0.0\" />" +
"<package id=\"Other\" version=\"1.0.0.0\" />" +
"</packages>");
var repository = new MockPackageRepository("http://test.com");
repository.AddPackage(PackageUtility.CreatePackage("Test", "2.0.0.0"));
repository.AddPackage(PackageUtility.CreatePackage("Other", "1.0.0.0"));
var command = new FixReferences(fileSystem, repository, new Console()) {Directory = @"d:\test"};
command.Execute();
var packageReferences = new PackageReferenceFile(fileSystem, @"d:\test\packages.config").GetPackageReferences().ToList();
Assert.AreEqual("2.0.0.0", packageReferences.First(p => p.Id == "Test").Version.Version.ToString());
Assert.AreEqual("1.0.0.0", packageReferences.First(p => p.Id == "Other").Version.Version.ToString());
}
public void GetPackageReferencesReadFromProjectConfigFileIfPresent()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""luan"" version=""1.0"" />
</packages>";
var projectConfig = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""an"" version=""1.0"" />
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
fileSystem.AddFile("packages.project.config", projectConfig);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config", "project");
// Act
var values = packageReferenceFile.GetPackageReferences().ToArray();
// Assert
Assert.Equal(1, values.Length);
Assert.Equal("an", values[0].Id);
}
public void GetPackageReferencesParseTargetFrameworkCorrectly()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""1.0"" targetFramework=""sl4"" />
<package id=""B"" version=""1.0"" targetFramework=""net35-client"" />
<package id=""C"" version=""1.0"" targetFramework=""winrt45"" />
<package id=""D"" version=""1.0"" />
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config");
// Act
var values = packageReferenceFile.GetPackageReferences().ToList();
// Assert
Assert.Equal(4, values.Count);
Assert.Equal(new FrameworkName("Silverlight, Version=4.0"), values[0].TargetFramework);
Assert.Equal(new FrameworkName(".NETFramework, Version=3.5, Profile=Client"), values[1].TargetFramework);
Assert.Equal(new FrameworkName(".NETCore, Version=4.5"), values[2].TargetFramework);
Assert.Null(values[3].TargetFramework);
}
private void AddFiles(PackageBuilder builder, string itemType, string targetFolder)
{
// Skip files that are added by dependency packages
string packagesConfig = GetPackagesConfig();
IPackageRepository repository = GetPackagesRepository();
var contentFilesInDependencies = new List<IPackageFile>();
if (packagesConfig != null && repository != null)
{
var references = new PackageReferenceFile(packagesConfig).GetPackageReferences();
contentFilesInDependencies = references.Select(reference => repository.FindPackage(reference.Id, reference.Version))
.Where(a => a != null)
.SelectMany(a => a.GetContentFiles())
.ToList();
}
// Get the content files from the project
foreach (var item in _project.GetItems(itemType))
{
string fullPath = item.GetMetadataValue("FullPath");
if (_excludeFiles.Contains(Path.GetFileName(fullPath)))
{
continue;
}
string targetFilePath = GetTargetPath(item);
if (!File.Exists(fullPath))
{
Logger.Log(MessageLevel.Warning, NuGetResources.Warning_FileDoesNotExist, targetFilePath);
continue;
}
// Check that file is added by dependency
string targetPath = Path.Combine(targetFolder, targetFilePath);
IPackageFile targetFile = contentFilesInDependencies.Find(a => a.Path.Equals(targetPath, StringComparison.OrdinalIgnoreCase));
if (targetFile != null)
{
// Compare contents as well
var isEqual = ContentEquals(targetFile, fullPath);
if (isEqual)
{
Logger.Log(MessageLevel.Info, NuGetResources.PackageCommandFileFromDependencyIsNotChanged, targetFilePath);
continue;
}
Logger.Log(MessageLevel.Info, NuGetResources.PackageCommandFileFromDependencyIsChanged, targetFilePath);
}
builder.Files.Add(new PhysicalPackageFile
{
SourcePath = fullPath,
TargetPath = targetPath
});
}
}
private void ProcessDependencies(PackageBuilder builder)
{
string packagesConfig = GetPackagesConfig();
// No packages config then bail out
if (String.IsNullOrEmpty(packagesConfig))
{
return;
}
Logger.Log(MessageLevel.Info, NuGetResources.UsingPackagesConfigForDependencies);
var file = new PackageReferenceFile(packagesConfig);
// Get the solution repository
IPackageRepository repository = GetPackagesRepository();
// Collect all packages
var packages = new List<IPackage>();
IDictionary<Tuple<string, SemanticVersion>, PackageReference> packageReferences = file.GetPackageReferences()
.ToDictionary(r => Tuple.Create(r.Id, r.Version));
foreach (PackageReference reference in packageReferences.Values)
{
if (repository != null)
{
IPackage package = repository.FindPackage(reference.Id, reference.Version);
if (package != null)
{
packages.Add(package);
}
}
}
// Add the transform file to the package builder
ProcessTransformFiles(builder, packages.SelectMany(GetTransformFiles));
var dependencies = builder.GetCompatiblePackageDependencies(targetFramework: null)
.ToDictionary(d => d.Id, StringComparer.OrdinalIgnoreCase);
// Reduce the set of packages we want to include as dependencies to the minimal set.
// Normally, packages.config has the full closure included, we only add top level
// packages, i.e. packages with in-degree 0
foreach (var package in GetMinimumSet(packages))
{
// Don't add duplicate dependencies
if (dependencies.ContainsKey(package.Id))
{
continue;
}
IVersionSpec spec = GetVersionConstraint(packageReferences, package);
var dependency = new PackageDependency(package.Id, spec);
dependencies[dependency.Id] = dependency;
}
// TO FIX: when we persist the target framework into packages.config file,
// we need to pull that info into building the PackageDependencySet object
builder.DependencySets.Clear();
builder.DependencySets.Add(new PackageDependencySet(null, dependencies.Values));
}
private void InstallPackagesFromConfigFile(IFileSystem fileSystem, PackageReferenceFile configFile)
{
// display opt-out message if needed
if (Console != null && RequireConsent && new PackageRestoreConsent(Settings).IsGranted)
{
string message = String.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("RestoreCommandPackageRestoreOptOutMessage"),
NuGet.Resources.NuGetResources.PackageRestoreConsentCheckBoxText.Replace("&", ""));
Console.WriteLine(message);
}
var packageReferences = CommandLineUtility.GetPackageReferences(configFile, requireVersion: true);
bool installedAny = ExecuteInParallel(fileSystem, packageReferences);
if (!installedAny && packageReferences.Any())
{
Console.WriteLine(LocalizedResourceManager.GetString("InstallCommandNothingToInstall"), Constants.PackageReferenceFile);
}
}
public void GetPackageReferencesFindTheOnlyVersionAsLatestVersion()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""1.3.4"" />
<package id=""A"" version=""2.5-beta"" />
<package id=""B"" version=""1.0"" />
<package id=""C"" version=""2.1.4"" />
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config");
// Act
PackageName packageName = packageReferenceFile.FindEntryWithLatestVersionById("B");
// Assert
Assert.NotNull(packageName);
Assert.Equal("B", packageName.Id);
Assert.Equal(new SemanticVersion("1.0"), packageName.Version);
}
public void GetPackageReferencesReturnsNullForNonExistentId()
{
// Arrange
var config = @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""1.3.4"" />
<package id=""A"" version=""2.5-beta"" />
<package id=""B"" version=""1.0"" />
<package id=""C"" version=""2.1.4"" />
</packages>";
var fileSystem = new MockFileSystem();
fileSystem.AddFile("packages.config", config);
var packageReferenceFile = new PackageReferenceFile(fileSystem, "packages.config");
// Act
PackageName packageName = packageReferenceFile.FindEntryWithLatestVersionById("nonexistentId");
// Assert
Assert.Null(packageName);
}
private static List<PackageReferenceFile> GetPackageReferenceFileList()
{
var x1 = @"<?xml version='1.0' encoding='utf-8'?>
<packages>
<package id='Package1' version='1.0' allowedVersions='[1.0, 2.0)' />
<package id='Package2' version='2.0' />
</packages>";
var x2 = @"<?xml version='1.0' encoding='utf-8'?>
<packages>
<package id='Package1' version='2.0' allowedVersions='[1.0, 3.0)' />
<package id='Package2' version='2.0' />
</packages>";
var mfs = new Mock<MockFileSystem>();
mfs.Setup(m => m.OpenFile("x1")).Returns(x1.AsStream());
mfs.Setup(m => m.OpenFile("x2")).Returns(x2.AsStream());
mfs.Setup(m => m.FileExists(It.IsAny<string>())).Returns(true);
var mpr1 = new PackageReferenceFile(mfs.Object, "x1");
var mpr2 = new PackageReferenceFile(mfs.Object, "x2");
var packageFiles = new List<PackageReferenceFile>();
packageFiles.Add(mpr1);
packageFiles.Add(mpr2);
return packageFiles;
}
/// <summary>
/// Restores packages listed in the <paramref name="packageReferenceFileName"/> into the packages folder
/// represented by <paramref name="fileSystem"/>.
/// </summary>
/// <param name="packageReferenceFileName">The package reference file name.</param>
/// <param name="fileSystem">The file system that represents the packages folder.</param>
private void RestorePackages(string packageReferenceFileName, IFileSystem fileSystem)
{
var packageReferenceFile = new PackageReferenceFile(packageReferenceFileName);
var packageReferences = packageReferenceFile.GetPackageReferences().ToList();
foreach (var package in packageReferences)
{
RestorePackage(package, fileSystem);
}
}
//TODO HACK HACK #WTF #EVIL Check the access to a private property. This requires a change to the PackageReferenceFile otherwise, which would take a long time.....
/// <summary>
/// Logs the satisfaction failure.
/// </summary>
/// <param name="p">The p.</param>
/// <param name="prf">The PRF.</param>
private void LogSatisfactionFailure(PackageReference p, PackageReferenceFile prf)
{
Console.WriteError("{0} {1}{2} in {3} could not be satisfied.", p.Id, p.Version, p.VersionConstraint != null ? " using constraint " + p.VersionConstraint : string.Empty, GetPackageConfigLocationUsingUltimateEvil(prf));
}
/// <summary>
/// Installs the packages from config file.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="file">The file.</param>
/// <param name="target"> </param>
private void InstallPackagesFromConfigFile(string packagesDirectory, PackageReferenceFile file, string target)
{
var packageReferences = file.GetPackageReferences().ToList();
//We need to create a damn filesystem at the packages directory, so that the ROOT is correct. Ahuh...
var fileSystem = CreateFileSystem(packagesDirectory);
if (!NoCache)
Console.WriteLine("Using cache....");
PackageManager packageManager = CreatePackageManager(fileSystem, useMachineCache: !NoCache);
if (Clean)
packageManager.CleanPackageFolders();
bool installedAny = false;
foreach (var packageReference in packageReferences)
{
if (String.IsNullOrEmpty(packageReference.Id))
{
// GetPackageReferences returns all records without validating values. We'll throw if we encounter packages
// with malformed ids / Versions.
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, GetResources.GetCommandInvalidPackageReference, target));
}
else if (packageReference.Version == null)
{
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, GetResources.GetCommandPackageReferenceInvalidVersion, packageReference.Id));
}
IPackage package = _packageResolutionManager.ResolveLatestInstallablePackage(_repository, packageReference);
if (package == null)
{
SemanticVersion version = _packageResolutionManager.ResolveInstallableVersion(_repository, packageReference);
installedAny |= InstallPackage(packageManager, fileSystem, packageReference.Id, version ?? packageReference.Version);
}
else
{
//We got it straight from the server, check whether we get a cache hit, else just install
var resolvedPackage = _packageResolutionManager.FindPackageInAllLocalSources(packageManager.LocalRepository, packageManager.SourceRepository, package);
packageManager.InstallPackage(resolvedPackage ?? package, !IncludeDependencies, false);
}
// Note that we ignore dependencies here because packages.config already contains the full closure
}
if (!installedAny && packageReferences.Any())
{
Console.WriteLine(GetResources.GetCommandNothingToInstall, Constants.PackageReferenceFile);
}
}
private static string GetPackageConfigLocationUsingUltimateEvil(PackageReferenceFile prf)
{
var blah = prf.GetPrivateProperty<IFileSystem>("FileSystem");
return blah.GetFullPath(prf.GetPrivateField<string>("_path"));
}
