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