public PackageDependencySetMetadata(PackageDependencyGroup dependencyGroup) { TargetFramework = dependencyGroup.TargetFramework; Dependencies = dependencyGroup.Packages .Select(d => new PackageDependencyMetadata(d)) .ToList() .AsReadOnly(); }
private static IList <LibraryDependency> GetDependencies(NuGetFramework targetFramework, PackageDependencyGroup dependencies, FrameworkSpecificGroup frameworkAssemblies) { var libraryDependencies = new List <LibraryDependency>(); if (dependencies != null) { foreach (var d in dependencies.Packages) { libraryDependencies.Add(new LibraryDependency { LibraryRange = new LibraryRange { Name = d.Id, VersionRange = d.VersionRange } }); } } if (frameworkAssemblies == null) { return(libraryDependencies); } if (!targetFramework.IsDesktop()) { // REVIEW: This isn't 100% correct since none *can* mean // any in theory, but in practice it means .NET full reference assembly // If there's no supported target frameworks and we're not targeting // the desktop framework then skip it. // To do this properly we'll need all reference assemblies supported // by each supported target framework which isn't always available. return(libraryDependencies); } foreach (var name in frameworkAssemblies.Items) { libraryDependencies.Add(new LibraryDependency { LibraryRange = new LibraryRange { Name = name, TypeConstraint = LibraryTypes.Reference } }); } return(libraryDependencies); }
private static IList<LibraryDependency> GetDependencies(NuGetFramework targetFramework, PackageDependencyGroup dependencies, FrameworkSpecificGroup frameworkAssemblies) { var libraryDependencies = new List<LibraryDependency>(); if (dependencies != null) { foreach (var d in dependencies.Packages) { libraryDependencies.Add(new LibraryDependency { LibraryRange = new LibraryRange { Name = d.Id, VersionRange = d.VersionRange } }); } } if (frameworkAssemblies == null) { return libraryDependencies; } if (!targetFramework.IsDesktop()) { // REVIEW: This isn't 100% correct since none *can* mean // any in theory, but in practice it means .NET full reference assembly // If there's no supported target frameworks and we're not targeting // the desktop framework then skip it. // To do this properly we'll need all reference assemblies supported // by each supported target framework which isn't always available. return libraryDependencies; } foreach (var name in frameworkAssemblies.Items) { libraryDependencies.Add(new LibraryDependency { LibraryRange = new LibraryRange { Name = name, TypeConstraint = LibraryTypes.Reference } }); } return libraryDependencies; }
/// <summary> /// Creates test package from assembly /// </summary> /// <param name="assembly">The source assembly</param> /// <param name="allAssemblies">The list of all defined assemblies</param> /// <returns>The test package</returns> private static TestPackage CreateTestPackage(Assembly assembly, Assembly[] allAssemblies) { var dependencies = assembly.GetReferencedAssemblies().Select( d => { var dependentAssembly = allAssemblies.FirstOrDefault(a => a.GetName().Name == d.Name); return(dependentAssembly != null && !dependentAssembly.IsDynamic #if APPDOMAIN && !dependentAssembly.GlobalAssemblyCache #endif ? dependentAssembly : null); }).Where(d => d != null).Select( d => new PackageDependency( d.GetName().Name, new VersionRange(NuGetVersion.Parse(d.GetName().Version.ToString())))).ToList(); var standardDependencies = new PackageDependencyGroup( NuGetFramework.ParseFrameworkName( ConfigurationCheckTestsBase.NetCore, DefaultFrameworkNameProvider.Instance), dependencies); var net46Dependencies = new PackageDependencyGroup( NuGetFramework.ParseFrameworkName( ConfigurationCheckTestsBase.Net46, DefaultFrameworkNameProvider.Instance), dependencies); Func <string, string, string, IEnumerable <string> > extaction = (framework, destination, temp) => { if (string.IsNullOrWhiteSpace(assembly.Location)) { throw new InvalidOperationException("Assembly has no location"); } var fileName = Path.GetFileName(assembly.Location); File.Copy(assembly.Location, Path.Combine(destination, fileName)); return(new[] { fileName }); }; return(new TestPackage(assembly.GetName().Name, assembly.GetName().Version.ToString()) { DependencySets = new[] { standardDependencies, net46Dependencies }, Extract = extaction }); }
private static void AssertDependencyGroup(PackageDependencyGroup expected, PackageDependencyGroup actual) { Assert.Equal(expected.TargetFramework, actual.TargetFramework); var actualDependencies = actual.Packages.ToList(); var expectedDependencies = expected.Packages.ToList(); Assert.Equal(expectedDependencies.Count, actualDependencies.Count); for (int i = 0; i < expectedDependencies.Count; i++) { AssertDependency(expectedDependencies[i], actualDependencies[i]); } }
private static IList <LibraryDependency> GetDependencies(NuGetFramework targetFramework, PackageDependencyGroup dependencies) { List <LibraryDependency> libraryDependencies = new List <LibraryDependency>(); if (dependencies != null) { libraryDependencies.AddRange( dependencies.Packages.Select(PackagingUtility.GetLibraryDependencyFromNuspec)); } return(libraryDependencies); }
public async Task DependencyCommandTests_ClearExclude() { using (var workingDir = new TestFolder()) { // Arrange var testPackageA = new TestNupkg() { Nuspec = new TestNuspec() { Id = "a", Version = "1.0.0" } }; var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] { new PackageDependency("b", VersionRange.Parse("1.0.0")) }); var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("any"), new[] { new PackageDependency("b", VersionRange.Parse("2.0.0"), new[] { "build" }, new[] { "content" }), new PackageDependency("x", VersionRange.Parse("1.0.0"), new[] { "build" }, new[] { "content" }), }); testPackageA.Nuspec.Dependencies.Add(depGroup1); testPackageA.Nuspec.Dependencies.Add(depGroup2); var zipFileA = testPackageA.Save(workingDir.Root); var log = new TestLogger(); // Act var exitCode = await Program.MainCore(new[] { "nuspec", "dependencies", "modify", workingDir.Root, "--dependency-id", "b", "--clear-exclude" }, log); exitCode.Should().Be(0, log.GetMessages()); var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0.nupkg")); var groups = nuspecA.GetDependencyGroups().ToDictionary(e => e.TargetFramework.GetShortFolderName().ToLowerInvariant()); // Assert groups.Count().Should().Be(2); groups["net45"].Packages.Single(e => e.Id == "b").VersionRange.Should().Be(VersionRange.Parse("1.0.0")); groups["net45"].Packages.Single(e => e.Id == "b").Exclude.Should().BeEmpty(); groups["net45"].Packages.Single(e => e.Id == "b").Include.Should().BeEmpty(); groups["any"].Packages.FirstOrDefault(e => e.Id == "b").VersionRange.Should().Be(VersionRange.Parse("2.0.0")); groups["any"].Packages.FirstOrDefault(e => e.Id == "b").Exclude.Should().BeEmpty(); groups["any"].Packages.FirstOrDefault(e => e.Id == "b").Include.ShouldBeEquivalentTo(new[] { "build" }); groups["any"].Packages.FirstOrDefault(e => e.Id == "x").VersionRange.Should().Be(VersionRange.Parse("1.0.0")); groups["any"].Packages.FirstOrDefault(e => e.Id == "x").Include.ShouldBeEquivalentTo(new[] { "build" }); groups["any"].Packages.FirstOrDefault(e => e.Id == "x").Exclude.ShouldBeEquivalentTo(new[] { "content" }); } }
public async Task Command_ReleaseCommand_VersionOutsideOfOriginalRange() { using (var workingDir = new TestFolder()) { // Arrange var testPackageA = new TestNupkg() { Nuspec = new TestNuspec() { Id = "a", Version = "6.0.0" } }; var depGroup = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] { new PackageDependency("b", VersionRange.Parse("[1.0.0, 2.0.0]")) }); testPackageA.Nuspec.Dependencies.Add(depGroup); var testPackageB = new TestNupkg() { Nuspec = new TestNuspec() { Id = "b", Version = "6.0.0" } }; var zipFileA = testPackageA.Save(workingDir.Root); var zipFileB = testPackageB.Save(workingDir.Root); var log = new TestLogger(); // Act var exitCode = await Program.MainCore(new[] { "release", workingDir.Root, "-n", "9.0.0" }, log); var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.9.0.0.nupkg")); var dependencyB = nuspecA.GetDependencyGroups().Single().Packages.Single(e => e.Id == "b"); var dependencyBString = dependencyB.VersionRange.ToLegacyShortString(); // Assert Assert.Equal(0, exitCode); Assert.Equal("[1.0.0, 2.0.0]", dependencyBString); Assert.Contains("dependency b does not allow the original version of b 6.0.0. Skipping.", string.Join("|", log.Messages)); } }
public async Task DependencyCommandTests_AddVerifyAddWithNewFramework() { using (var workingDir = new TestFolder()) { // Arrange var testPackageA = new TestNupkg() { Nuspec = new TestNuspec() { Id = "a", Version = "1.0.0" } }; var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] { new PackageDependency("b", VersionRange.Parse("1.0.0")) }); var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("net46"), new[] { new PackageDependency("b", VersionRange.Parse("2.0.0")) }); testPackageA.Nuspec.Dependencies.Add(depGroup1); testPackageA.Nuspec.Dependencies.Add(depGroup2); var zipFileA = testPackageA.Save(workingDir.Root); var log = new TestLogger(); // Act var exitCode = await Program.MainCore(new[] { "nuspec", "dependencies", "add", workingDir.Root, "--dependency-id", "c", "--dependency-version", "1.0.0", "--framework", "any" }, log); exitCode.Should().Be(0, log.GetMessages()); var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0.nupkg")); var groups = nuspecA.GetDependencyGroups(); var dependencyCAny = groups.Single(e => e.TargetFramework.IsAny).Packages.FirstOrDefault(e => e.Id == "c"); var dependencyCNet45 = groups.Single(e => e.TargetFramework == NuGetFramework.Parse("net45")).Packages.FirstOrDefault(e => e.Id == "c"); var dependencyCNet46 = groups.Single(e => e.TargetFramework == NuGetFramework.Parse("net46")).Packages.FirstOrDefault(e => e.Id == "c"); // Assert dependencyCNet45.Should().BeNull(); dependencyCNet46.Should().BeNull(); dependencyCAny.VersionRange.Should().Be(VersionRange.Parse("1.0.0")); nuspecA.GetDependencyGroups().Count().Should().Be(3); } }
public static PackageBuilder CreateExecutablePackage(string path, Manifest manifest, PackageConfiguration configuration, out bool updateDependencies) { if (string.IsNullOrEmpty(path) || !File.Exists(path)) { throw new ArgumentException("Invalid workflow file path.", "path"); } var packageBuilder = new PackageBuilder(); var basePath = Path.GetDirectoryName(path) + "\\"; packageBuilder.Populate(manifest.Metadata); packageBuilder.Tags.Add(NuGet.Constants.BonsaiDirectory); packageBuilder.Tags.Add(NuGet.Constants.GalleryDirectory); packageBuilder.PackageTypes = new[] { new PackageType(NuGet.Constants.GalleryPackageType, PackageType.EmptyVersion) }; var files = manifest.Files ?? GetContentFiles(basePath); packageBuilder.PopulateFiles(basePath, files); var manifestDependencies = new Dictionary <string, PackageDependency>(StringComparer.OrdinalIgnoreCase); foreach (var dependency in packageBuilder.DependencyGroups.Where(group => group.TargetFramework == NuGetFramework.AnyFramework) .SelectMany(group => group.Packages)) { manifestDependencies.Add(dependency.Id, dependency); } updateDependencies = false; var workflowFiles = packageBuilder.Files.Select(file => file as PhysicalPackageFile) .Where(file => file != null && Path.GetExtension(file.SourcePath) == NuGet.Constants.BonsaiExtension) .Select(file => file.SourcePath) .ToArray(); var workflowDependencies = DependencyInspector.GetWorkflowPackageDependencies(workflowFiles, configuration).ToArray().Wait(); foreach (var dependency in workflowDependencies) { if (!manifestDependencies.TryGetValue(dependency.Id, out PackageDependency manifestDependency) || !DependencyEqualityComparer.Default.Equals(dependency, manifestDependency)) { updateDependencies = true; manifestDependencies[dependency.Id] = dependency; } } var dependencyGroup = new PackageDependencyGroup(NuGetFramework.AnyFramework, manifestDependencies.Values); packageBuilder.DependencyGroups.Clear(); packageBuilder.DependencyGroups.Add(dependencyGroup); return(packageBuilder); }
private void AddFlattenedFrameworkDependency(PackageDependencyGroup dependencyGroup, StringBuilder builder) { if (!SpecialFrameworks.Contains(dependencyGroup.TargetFramework)) { try { builder.Append(":"); builder.Append(dependencyGroup.TargetFramework?.GetShortFolderName()); } catch (FrameworkException) { // ignoring FrameworkException on purpose - we don't want the job crashing // whenever someone uploads an unsupported framework } } }
public async Task Command_ReleaseCommand_NewVersionBelowMin() { using (var workingDir = new TestFolder()) { // Arrange var testPackageA = new TestNupkg() { Nuspec = new TestNuspec() { Id = "a", Version = "6.0.0" } }; var depGroup = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] { new PackageDependency("b", VersionRange.Parse("5.0.0")) }); testPackageA.Nuspec.Dependencies.Add(depGroup); var testPackageB = new TestNupkg() { Nuspec = new TestNuspec() { Id = "b", Version = "6.0.0" } }; var zipFileA = testPackageA.Save(workingDir.Root); var zipFileB = testPackageB.Save(workingDir.Root); var log = new TestLogger(); // Act var exitCode = await Program.MainCore(new[] { "release", workingDir.Root, "-n", "1.0.0" }, log); var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0.nupkg")); var dependencyB = nuspecA.GetDependencyGroups().Single().Packages.Single(e => e.Id == "b"); var dependencyBString = dependencyB.VersionRange.ToLegacyShortString(); // Assert Assert.Equal(0, exitCode); Assert.Equal("1.0.0", dependencyBString); } }
/// <summary> /// Converts a <see cref="ManifestMetadata"/> into a <see cref="NuGetManifestMetadata"/>. /// </summary> /// <param name="metadata">The metadata source of conversion.</param> /// <returns>A new instance of <see cref="NuGetManifestMetadata"/> corresponding to <paramref name="metadata"/>.</returns> public static NuGetManifestMetadata ToManifestMetadata(this ManifestMetadata metadata) { if (metadata == null) { throw new ArgumentNullException(nameof(metadata)); } var nugetMetadata = new NuGetManifestMetadata() { Id = metadata.Id, Authors = metadata.Authors, Description = metadata.Description, Copyright = metadata.Copyright, DevelopmentDependency = metadata.DevelopmentDependency, Version = new NuGetVersion(metadata.Version), Owners = metadata.Owners, Language = metadata.Language, MinClientVersionString = metadata.MinClientVersionString, ReleaseNotes = metadata.ReleaseNotes, RequireLicenseAcceptance = metadata.RequireLicenseAcceptance, Summary = metadata.Summary, Tags = metadata.Tags, Title = metadata.Title }; // Setting properties without a setter. nugetMetadata.SetIconUrl(metadata.IconUrl); nugetMetadata.SetLicenseUrl(metadata.LicenseUrl); nugetMetadata.SetProjectUrl(metadata.ProjectUrl); // Updating dependencies if (metadata.Dependencies.Count != 0) { var packages = new List <PackageDependency>(); foreach (var dependency in metadata.Dependencies) { packages.Add(new PackageDependency(dependency.Id, dependency.Version.ToVersionRange())); } // We are .NET agnostic var group = new PackageDependencyGroup(NuGetFramework.AgnosticFramework, packages); nugetMetadata.DependencyGroups = new [] { group }; } return(nugetMetadata); }
public async Task Command_DependenciesEmptyGroupCommand_AddNew() { using (var workingDir = new TestFolder()) { // Arrange var testPackage = new TestNupkg() { Nuspec = new TestNuspec() { Id = "a", Version = "1.0.0" } }; var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] { new PackageDependency("b", VersionRange.Parse("2.0.0-alpha")), new PackageDependency("c", VersionRange.Parse("[1.0.0-beta]")) }); var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("netstandard1.6"), new[] { new PackageDependency("b", VersionRange.Parse("2.0.0-alpha")), new PackageDependency("c", VersionRange.Parse("[1.0.0-beta]")) }); testPackage.Nuspec.Dependencies.Add(depGroup1); testPackage.Nuspec.Dependencies.Add(depGroup2); var zipFile = testPackage.Save(workingDir.Root); var log = new TestLogger(); // Act var exitCode = await Program.MainCore(new[] { "nuspec", "dependencies", "emptygroup", zipFile.FullName, "-f", "win8" }, log); var nuspec = GetNuspec(zipFile.FullName); // Assert Assert.Equal(0, exitCode); Assert.Equal(3, nuspec.GetDependencyGroups().Count()); Assert.Equal(2, nuspec.GetDependencyGroups().Where(e => e.TargetFramework.Equals(NuGetFramework.Parse("net45"))).Single().Packages.Count()); Assert.Equal(2, nuspec.GetDependencyGroups().Where(e => e.TargetFramework.Equals(NuGetFramework.Parse("netstandard1.6"))).Single().Packages.Count()); nuspec.GetDependencyGroups().Where(e => e.TargetFramework.Equals(NuGetFramework.Parse("win8"))).Single().Packages.Should().BeEmpty(); } }
private void AddFlattennedPackageDependency( PackageDependencyGroup dependencyGroup, Packaging.Core.PackageDependency packageDependency, StringBuilder builder) { if (builder.Length > 0) { builder.Append("|"); } builder.Append(packageDependency.Id); builder.Append(":"); if (!packageDependency.VersionRange.Equals(VersionRange.All)) { builder.Append(packageDependency.VersionRange?.ToString("S", new VersionRangeFormatter())); } AddFlattenedFrameworkDependency(dependencyGroup, builder); }
private void BuildNuSpecManifest_After(object sender, BuildNuSpecManifestEventArgs e) { if (e.ResourceName.Equals("RelationshipsExtended", StringComparison.InvariantCultureIgnoreCase)) { e.Manifest.Metadata.SetIconUrl("https://www.kentico.com/icons/icon-48x48.png"); e.Manifest.Metadata.SetProjectUrl("https://github.com/KenticoDevTrev/RelationshipsExtended"); e.Manifest.Metadata.ReleaseNotes = "Adjusted library nuget package to depend on RelationshipsExtended.Base for easier maintenance"; e.Manifest.Metadata.Copyright = "Heartland Business Systems"; // Add dependencies List <PackageDependency> NetStandardDependencies = new List <PackageDependency>() { new PackageDependency("Kentico.Xperience.Libraries", new VersionRange(new NuGetVersion("13.0.0")), new string[] { }, new string[] { "Build", "Analyzers" }), new PackageDependency("RelationshipsExtended.Base", new VersionRange(new NuGetVersion("13.0.1")), new string[] { }, new string[] { "Build", "Analyzers" }) }; PackageDependencyGroup PackageGroup = new PackageDependencyGroup(new NuGet.Frameworks.NuGetFramework(".NETStandard2.0"), NetStandardDependencies); e.Manifest.Metadata.DependencyGroups = new PackageDependencyGroup[] { PackageGroup }; } }
public async Task DependencyCommandTests_RemoveWithFrameworkThatDoesExist() { using (var workingDir = new TestFolder()) { // Arrange var testPackageA = new TestNupkg() { Nuspec = new TestNuspec() { Id = "a", Version = "1.0.0" } }; var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] { new PackageDependency("b", VersionRange.Parse("1.0.0")) }); var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("net46"), new[] { new PackageDependency("b", VersionRange.Parse("2.0.0")) }); testPackageA.Nuspec.Dependencies.Add(depGroup1); testPackageA.Nuspec.Dependencies.Add(depGroup2); var zipFileA = testPackageA.Save(workingDir.Root); var log = new TestLogger(); // Act var exitCode = await Program.MainCore(new[] { "nuspec", "dependencies", "remove", workingDir.Root, "--dependency-id", "b", "--framework", "net46" }, log); exitCode.Should().Be(0, log.GetMessages()); var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0.nupkg")); var groups = nuspecA.GetDependencyGroups().ToDictionary(e => e.TargetFramework.GetShortFolderName().ToLowerInvariant()); // Assert groups.Count().Should().Be(2); groups["net45"].Packages.ShouldBeEquivalentTo(depGroup1.Packages); groups["net46"].Packages.Should().BeEmpty(); } }
private Manifest TransformManifestToPackedPackageManifest(Manifest manifest) { ManifestMetadata manifestMetadata = manifest.Metadata; // Update Id string _packageNamePrefix = PackedPackageNamePrefix != null ? PackedPackageNamePrefix : _defaultPackedPackagePrefix; manifestMetadata.Id = $"{_packageNamePrefix}.{manifestMetadata.Id}"; // Update dependencies List <PackageDependencyGroup> packedPackageDependencyGroups = new List <PackageDependencyGroup>(); foreach (var dependencyGroup in manifestMetadata.DependencyGroups) { List <NuGet.Packaging.Core.PackageDependency> packages = new List <NuGet.Packaging.Core.PackageDependency>(); foreach (var dependency in dependencyGroup.Packages) { NuGet.Packaging.Core.PackageDependency package = new NuGet.Packaging.Core.PackageDependency($"{_packageNamePrefix}.{dependency.Id}", dependency.VersionRange, dependency.Include, dependency.Exclude); packages.Add(package); } PackageDependencyGroup packageDependencyGroup = new PackageDependencyGroup(dependencyGroup.TargetFramework, packages); packedPackageDependencyGroups.Add(packageDependencyGroup); } manifestMetadata.DependencyGroups = packedPackageDependencyGroups; // Update runtime.json List <ManifestFile> manifestFiles = new List <ManifestFile>(); foreach (ManifestFile file in manifest.Files) { string fileName = file.Source; if (Path.GetFileName(fileName) == "runtime.json" && file.Target == "") { string packedPackageSourcePath = Path.Combine(Path.GetDirectoryName(fileName), string.Join(".", _packageNamePrefix, Path.GetFileName(fileName))); file.Source = File.Exists(packedPackageSourcePath) ? packedPackageSourcePath : fileName; file.Target = "runtime.json"; } manifestFiles.Add(file); } Manifest packedPackageManifest = new Manifest(manifestMetadata, manifestFiles); return(manifest); }
public async Task Command_DependenciesClearCommand_Filter() { using (var workingDir = new TestFolder()) { // Arrange var testPackage = new TestNupkg() { Nuspec = new TestNuspec() { Id = "a", Version = "1.0.0" } }; var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] { new PackageDependency("b", VersionRange.Parse("2.0.0-alpha")), new PackageDependency("c", VersionRange.Parse("[1.0.0-beta]")) }); var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("netstandard1.6"), new[] { new PackageDependency("b", VersionRange.Parse("2.0.0-alpha")), new PackageDependency("c", VersionRange.Parse("[1.0.0-beta]")) }); testPackage.Nuspec.Dependencies.Add(depGroup1); testPackage.Nuspec.Dependencies.Add(depGroup2); var zipFile = testPackage.Save(workingDir.Root); var log = new TestLogger(); // Act var exitCode = await Program.MainCore(new[] { "nuspec", "dependencies", "clear", zipFile.FullName, "-f", "net45" }, log); var nuspec = GetNuspec(zipFile.FullName); // Assert Assert.Equal(0, exitCode); Assert.Equal(1, nuspec.GetDependencyGroups().Count()); } }
public static string CreateTestPackage( string packageId, string version, string path, string framework, string dependencyPackageId, string dependencyPackageVersion) { var group = new PackageDependencyGroup(NuGetFramework.AnyFramework, new List <PackageDependency>() { new PackageDependency(dependencyPackageId, VersionRange.Parse(dependencyPackageVersion)) }); return(CreateTestPackage(packageId, version, path, new List <NuGetFramework>() { NuGetFramework.Parse(framework) }, new List <PackageDependencyGroup>() { group })); }
public PackageDependencySetMetadata(PackageDependencyGroup dependencyGroup) { if (dependencyGroup == null) { TargetFrameworkDisplay = Resources.Text_NoDependencies; } else { TargetFramework = dependencyGroup.TargetFramework; TargetFrameworkDisplay = TargetFramework.ToString(); if (dependencyGroup.Packages.Any()) { Dependencies = dependencyGroup.Packages .Select(d => new PackageDependencyMetadata(d)) .ToList() .AsReadOnly(); } else { Dependencies = NoDependenciesPlaceholder; } } }
public static void AddDependencyGroups(IEnumerable <LibraryDependency> dependencies, NuGetFramework framework, PackageBuilder builder) { ISet <PackageDependency> packageDependencies = new HashSet <PackageDependency>(); foreach (var dependency in dependencies) { LibraryIncludeFlags effectiveInclude = dependency.IncludeType & ~dependency.SuppressParent; if (dependency.IncludeType == LibraryIncludeFlags.None || dependency.SuppressParent == LibraryIncludeFlags.All) { continue; } if (dependency.LibraryRange.TypeConstraint == LibraryDependencyTarget.Reference) { var reference = builder.FrameworkReferences.FirstOrDefault(r => r.AssemblyName == dependency.Name); if (reference == null) { builder.FrameworkReferences.Add(new FrameworkAssemblyReference(dependency.Name, new NuGetFramework [] { framework })); } else { if (!reference.SupportedFrameworks.Contains(framework)) { // Add another framework reference by replacing the existing reference var newReference = new FrameworkAssemblyReference(reference.AssemblyName, reference.SupportedFrameworks.Concat(new NuGetFramework[] { framework })); int index = builder.FrameworkReferences.IndexOf(reference); builder.FrameworkReferences.Remove(reference); builder.FrameworkReferences.Insert(index, newReference); } } } else { List <string> includes = new List <string>(); List <string> excludes = new List <string>(); if (effectiveInclude == LibraryIncludeFlags.All) { includes.Add(LibraryIncludeFlags.All.ToString()); } else if ((effectiveInclude & LibraryIncludeFlags.ContentFiles) == LibraryIncludeFlags.ContentFiles) { includes.AddRange(effectiveInclude.ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)); } else { if ((LibraryIncludeFlagUtils.NoContent & ~effectiveInclude) != LibraryIncludeFlags.None) { excludes.AddRange((LibraryIncludeFlagUtils.NoContent & ~effectiveInclude).ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)); } } VersionRange version = dependency.LibraryRange.VersionRange; if (!version.HasLowerBound && !version.HasUpperBound) { version = new VersionRange(builder.Version); } packageDependencies.Add(new PackageDependency(dependency.Name, version, includes, excludes)); } } var dependencyGroup = builder.DependencyGroups.FirstOrDefault(r => r.TargetFramework.Equals(framework)); if (dependencyGroup != null) { var existingDependencies = new HashSet <PackageDependency>(dependencyGroup.Packages); foreach (var packageDependency in packageDependencies) { PackCommandRunner.AddPackageDependency(packageDependency, existingDependencies); } var newDependencyGroup = new PackageDependencyGroup(framework, existingDependencies); builder.DependencyGroups.Remove(dependencyGroup); builder.DependencyGroups.Add(newDependencyGroup); } else { builder.DependencyGroups.Add(new PackageDependencyGroup(framework, packageDependencies)); } }
private void FilterDependencies(string targetPath, ISet <string> dependencyToRemove) { var fileName = Path.GetFileName(targetPath); Log.LogMessage($"Updating {fileName}"); using (var fileStream = File.Open(targetPath, FileMode.Open)) using (var package = new ZipArchive(fileStream, ZipArchiveMode.Update)) using (var packageReader = new PackageArchiveReader(fileStream, leaveStreamOpen: true)) { var referencesFrameworkOnlyAssembly = false; var nuspecFile = packageReader.GetNuspecFile(); using (var stream = package.OpenFile(nuspecFile)) { var reader = Manifest.ReadFrom(stream, validateSchema: true); stream.Position = 0; var packageBuilder = new PackageBuilder(stream, basePath: null); var updatedGroups = new List <PackageDependencyGroup>(); foreach (var group in packageBuilder.DependencyGroups) { var packages = new List <PackageDependency>(); var updatedGroup = new PackageDependencyGroup(group.TargetFramework, packages); foreach (var dependency in group.Packages) { if (dependencyToRemove.Contains(dependency.Id)) { referencesFrameworkOnlyAssembly = true; Log.LogMessage($" Remove dependency on '{dependency.Id}'"); continue; } packages.Add(dependency); } updatedGroups.Add(updatedGroup); } if (referencesFrameworkOnlyAssembly) { packageBuilder.DependencyGroups.Clear(); packageBuilder.DependencyGroups.AddRange(updatedGroups); var updatedManifest = Manifest.Create(packageBuilder); var inMemory = new MemoryStream(); updatedManifest.Save(inMemory); inMemory.Position = 0; // Hack the raw nuspec to add the <frameworkReference> dependency var rawNuspec = XDocument.Load(inMemory, LoadOptions.PreserveWhitespace); var ns = rawNuspec.Root.GetDefaultNamespace(); var metadata = rawNuspec.Root.Descendants(ns + "metadata").Single(); metadata.Add( new XElement(ns + "frameworkReferences", new XElement(ns + "group", new XAttribute("targetFramework", NuGetFramework.Parse(SharedFrameworkTargetFramework).GetFrameworkString()), new XElement(ns + "frameworkReference", new XAttribute("name", "Microsoft.AspNetCore.App"))))); stream.Position = 0; stream.SetLength(0); rawNuspec.Save(stream); Log.LogMessage(MessageImportance.High, "Added <frameworkReference> to {0}", fileName); } else { Log.LogMessage($"No changes made to {fileName}"); } } } }
/// <summary> /// For each package in our registry.json, query NuGet, extract package metadata, and convert them to unity packages. /// </summary> private async Task BuildInternal() { var packageMetadataResource = _sourceRepository.GetResource <PackageMetadataResource>(); foreach (var packageDesc in _registry) { var packageName = packageDesc.Key; var packageEntry = packageDesc.Value; // A package entry is ignored but allowed in the registry (case of Microsoft.CSharp) if (packageEntry.Ignored) { continue; } var packageMetaIt = await packageMetadataResource.GetMetadataAsync(packageName, false, false, _sourceCacheContext, Logger, CancellationToken.None); var packageMetas = packageMetaIt.ToList(); foreach (var packageMeta in packageMetas) { var packageIdentity = packageMeta.Identity; var packageId = packageIdentity.Id.ToLowerInvariant(); var npmPackageId = $"{UnityScope}.{packageId}"; if (!packageEntry.Version.Satisfies(packageMeta.Identity.Version)) { continue; } PackageDependencyGroup netstd20Dependency = null; foreach (var dependencySet in packageMeta.DependencySets) { if (dependencySet.TargetFramework == NuGetFrameworkNetStandard20) { netstd20Dependency = dependencySet; break; } } if (netstd20Dependency == null) { Logger.LogWarning($"The package `{packageIdentity}` doesn't support `netstandard2.0`"); continue; } if (!_npmPackageRegistry.Packages.TryGetValue(npmPackageId, out var npmPackage)) { npmPackage = new NpmPackage(); _npmPackageRegistry.Packages.Add(npmPackageId, npmPackage); } // One NpmPackage (for package request) var packageInfoList = packageEntry.Listed ? _npmPackageRegistry.ListedPackageInfos : _npmPackageRegistry.UnlistedPackageInfos; if (!packageInfoList.Packages.TryGetValue(npmPackageId, out var npmPackageInfo)) { npmPackageInfo = new NpmPackageInfo(); packageInfoList.Packages.Add(npmPackageId, npmPackageInfo); } // Update latest version var currentVersion = packageIdentity.Version; var update = !npmPackage.DistTags.TryGetValue("latest", out var latestVersion) || (currentVersion > NuGetVersion.Parse(latestVersion)); string npmCurrentVersion = $"{currentVersion.Major}.{currentVersion.Minor}.{currentVersion.Patch}"; if (currentVersion.Revision != 0) { npmCurrentVersion += $"-{currentVersion.Revision}"; } if (update) { npmPackage.DistTags["latest"] = npmCurrentVersion; npmPackageInfo.Versions.Clear(); npmPackageInfo.Versions[npmCurrentVersion] = "latest"; npmPackage.Id = npmPackageId; npmPackage.License = packageMeta.LicenseMetadata?.License ?? packageMeta.LicenseUrl?.ToString(); npmPackage.Name = npmPackageId; npmPackageInfo.Name = npmPackageId; npmPackage.Description = packageMeta.Description; npmPackageInfo.Description = packageMeta.Description; npmPackageInfo.Author = packageMeta.Authors; if (packageMeta.Owners != null) { npmPackageInfo.Maintainers.Clear(); npmPackageInfo.Maintainers.AddRange(SplitCommaSeparatedString(packageMeta.Owners)); } if (packageMeta.Tags != null) { npmPackageInfo.Keywords.Clear(); npmPackageInfo.Keywords.Add("nuget"); npmPackageInfo.Keywords.AddRange(SplitCommaSeparatedString(packageMeta.Tags)); } } var npmVersion = new NpmPackageVersion { Id = $"{npmPackageId}@{npmCurrentVersion}", Version = npmCurrentVersion, Name = npmPackageId, Description = packageMeta.Description, Author = AuthorNameUnityGroup, DisplayName = $"{packageMeta.Title} ({npmPackageInfo.Author})" }; npmVersion.Distribution.Tarball = new Uri($"{RootHttpUrl}/{npmPackage.Id}/-/{GetUnityPackageFileName(packageIdentity, npmVersion)}"); npmVersion.Unity = MinimumUnityVersion; npmPackage.Versions[npmVersion.Version] = npmVersion; bool hasDependencyErrors = false; foreach (var deps in netstd20Dependency.Packages) { var depsId = deps.Id.ToLowerInvariant(); if (!_registry.TryGetValue(deps.Id, out var packageEntryDep)) { LogError($"The package `{packageIdentity}` has a dependency on `{deps.Id}` which is not in the registry. You must add this dependency to the registry.json file."); hasDependencyErrors = true; } else if (packageEntryDep.Ignored) { // A package that is ignored is not declared as an explicit dependency continue; } else if (!deps.VersionRange.IsSubSetOrEqualTo(packageEntryDep.Version)) { LogError($"The version range `{deps.VersionRange}` for the dependency `{deps.Id}` for the package `{packageIdentity}` doesn't match the range allowed from the registry.json: `{packageEntryDep.Version}`"); hasDependencyErrors = true; } // Otherwise add the package as a dependency npmVersion.Dependencies.Add($"{UnityScope}.{depsId}", deps.VersionRange.MinVersion.ToString()); } // If we don't have any dependencies error, generate the package if (!hasDependencyErrors) { await ConvertNuGetToUnityPackageIfDoesNotExist(packageIdentity, npmPackageInfo, npmVersion, packageMeta); npmPackage.Time[npmCurrentVersion] = packageMeta.Published?.UtcDateTime ?? GetUnityPackageFileInfo(packageIdentity, npmVersion).CreationTimeUtc; // Copy repository info if necessary if (update) { npmPackage.Repository = npmVersion.Repository?.Clone(); } } } } }
/// <summary> /// Creates a Nuget package from a SmartInk Package /// </summary> /// <param name="package">Package to use for Nuget creation</param> /// <param name="destination">File handle for saving the Nuget package</param> public async Task PublishPackageAsync(ISmartInkPackage package, IStorageFile destination) { if (package == null) { throw new ArgumentNullException($"{nameof(package)} cannot be null"); } if (destination == null) { throw new ArgumentNullException($"{nameof(destination)} cannot be null"); } Debug.WriteLine($"Publish package"); ManifestMetadata metadata = new ManifestMetadata() { Title = $"{package.Name}", Owners = new string[] { "jabj" }, Authors = new string[] { "mauvo" }, Version = new NuGet.Versioning.NuGetVersion(new Version(package.Version)), Id = $"SmartInk.{package.Name}", Description = $"{package.Description}", MinClientVersionString = "3.3.0" }; NuGet.Frameworks.NuGetFramework targetFramework = new NuGet.Frameworks.NuGetFramework(new NuGet.Frameworks.NuGetFramework(".NETStandard2.0")); IEnumerable <NuGet.Packaging.Core.PackageDependency> packages = new NuGet.Packaging.Core.PackageDependency[] { new NuGet.Packaging.Core.PackageDependency("NETStandard.Library", new NuGet.Versioning.VersionRange(new NuGet.Versioning.NuGetVersion(2, 0, 0))) }; var dependencyGroup = new PackageDependencyGroup(targetFramework, packages); metadata.DependencyGroups = new PackageDependencyGroup[] { dependencyGroup }; PackageBuilder builder = new PackageBuilder(); builder.Populate(metadata); builder.ContentFiles.Add(new ManifestContentFiles() { Include = $"**/SmartInkPackages/*", CopyToOutput = "true", Flatten = "false", BuildAction = "None" }); builder.ContentFiles.Add(new ManifestContentFiles() { Include = $"**/SmartInkPackages/{package.Name}/*", CopyToOutput = "true", Flatten = "false", BuildAction = "None" }); builder.ContentFiles.Add(new ManifestContentFiles() { Include = $"**/SmartInkPackages/{package.Name}/Model/*", CopyToOutput = "true", Flatten = "false", BuildAction = "None" }); builder.ContentFiles.Add(new ManifestContentFiles() { Include = $"**/SmartInkPackages/{package.Name}/Icons/*", CopyToOutput = "true", Flatten = "false", BuildAction = "None" }); var root = $"{_provider.RootFolderPath}\\{package.Name}\\"; List <ManifestFile> manifestFiles = new List <ManifestFile>(); var rootFolder = await StorageFolder.GetFolderFromPathAsync(root); var files = await rootFolder.GetFilesAsync(Windows.Storage.Search.CommonFileQuery.OrderByName); foreach (var file in files) { ManifestFile manifestFile = new ManifestFile(); manifestFile.Source = file.Path; manifestFile.Target = $"contentFiles\\cs\\uap10.0\\SmartInkPackages{file.Path.Replace(_provider.RootFolderPath, "")}"; manifestFiles.Add(manifestFile); } builder.PopulateFiles(root, manifestFiles); using (var fileaccess = await destination.OpenAsync(FileAccessMode.ReadWrite)) { Debug.WriteLine($"Publish package: {builder.ToString()}"); var stream = fileaccess.AsStreamForWrite(); builder.Save(stream); await stream.FlushAsync(); } }
public async Task GetDependenciesAsync_WhenPackageIsSelectedWithAssetTargetFallback_AndLegacyDependencyResolutionVariableIsSpecified_CorrectDependenciesAreSelected(string envValue, bool areDependenciesSelected) { // Arrange var testLogger = new TestLogger(); var cacheContext = new SourceCacheContext(); var findResource = new Mock <FindPackageByIdResource>(); var wrapper = new TestEnvironmentVariableReader(new Dictionary <string, string> { { "NUGET_USE_LEGACY_ASSET_TARGET_FALLBACK_DEPENDENCY_RESOLUTION", envValue } }); var net472 = FrameworkConstants.CommonFrameworks.Net472; var net60 = FrameworkConstants.CommonFrameworks.Net60; var inputFramework = new AssetTargetFallbackFramework(net60, new List <NuGetFramework> { net472 }); var packageDependencyGroups = new List <PackageDependencyGroup>(); var net472Group = new PackageDependencyGroup(net472, new PackageDependency[] { new PackageDependency("full.framework", VersionRange.Parse("1.0.0")) }); packageDependencyGroups.Add(net472Group); findResource.Setup(s => s.GetDependencyInfoAsync( It.IsAny <string>(), It.IsAny <NuGetVersion>(), It.IsAny <SourceCacheContext>(), It.IsAny <ILogger>(), It.IsAny <CancellationToken>())) .ReturnsAsync(new FindPackageByIdDependencyInfo( new PackageIdentity("x", NuGetVersion.Parse("1.0.0-beta")), packageDependencyGroups, Enumerable.Empty <FrameworkSpecificGroup>())); var source = new Mock <SourceRepository>(); source.Setup(s => s.GetResourceAsync <FindPackageByIdResource>()) .ReturnsAsync(findResource.Object); source.SetupGet(s => s.PackageSource) .Returns(new PackageSource("http://test/index.json")); var provider = new SourceRepositoryDependencyProvider( source.Object, testLogger, cacheContext, ignoreFailedSources: true, ignoreWarning: true, fileCache: null, isFallbackFolderSource: false, wrapper); // Act var library = await provider.GetDependenciesAsync( new LibraryIdentity("x", NuGetVersion.Parse("1.0.0-beta"), LibraryType.Package), inputFramework, cacheContext, testLogger, CancellationToken.None); // Assert if (areDependenciesSelected) { library.Dependencies.Should().HaveCount(1); var dependencies = library.Dependencies.Single(); dependencies.Name.Should().Be("full.framework"); } else { library.Dependencies.Should().HaveCount(0); } }
private void AddFlattennedPackageDependency( PackageDependencyGroup dependencyGroup, Packaging.Core.PackageDependency packageDependency, StringBuilder builder) { if (builder.Length > 0) { builder.Append("|"); } builder.Append(packageDependency.Id); builder.Append(":"); if (!packageDependency.VersionRange.Equals(VersionRange.All)) { builder.Append(packageDependency.VersionRange?.ToString("S", new VersionRangeFormatter())); } AddFlattenedFrameworkDependency(dependencyGroup, builder); }
private void AddFlattenedFrameworkDependency(PackageDependencyGroup dependencyGroup, StringBuilder builder) { if (!SpecialFrameworks.Contains(dependencyGroup.TargetFramework)) { try { builder.Append(":"); builder.Append(dependencyGroup.TargetFramework?.GetShortFolderName()); } catch (FrameworkException) { // ignoring FrameworkException on purpose - we don't want the job crashing // whenever someone uploads an unsupported framework } } }
public EditablePackageDependencySet(PackageDependencyGroup packageDependencySet) { _targetFramework = packageDependencySet.TargetFramework; Dependencies = new ObservableCollection <PackageDependency>(packageDependencySet.Packages); }
public async Task Command_ReleaseCommand_MultipleNewVersions_EachTFMTakesCorrectVersion() { using (var workingDir = new TestFolder()) { // Arrange var testPackageA = new TestNupkg() { Nuspec = new TestNuspec() { Id = "a", Version = "1.0.0" } }; var depGroup1 = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] { new PackageDependency("b", VersionRange.Parse("1.0.0")) }); var depGroup2 = new PackageDependencyGroup(NuGetFramework.Parse("net46"), new[] { new PackageDependency("b", VersionRange.Parse("2.0.0")) }); testPackageA.Nuspec.Dependencies.Add(depGroup1); testPackageA.Nuspec.Dependencies.Add(depGroup2); var testPackageB1 = new TestNupkg() { Nuspec = new TestNuspec() { Id = "b", Version = "1.0.0" } }; var testPackageB2 = new TestNupkg() { Nuspec = new TestNuspec() { Id = "b", Version = "2.0.0" } }; var testPackageB3 = new TestNupkg() { Nuspec = new TestNuspec() { Id = "b", Version = "0.1.0" } }; var testPackageB4 = new TestNupkg() { Nuspec = new TestNuspec() { Id = "b", Version = "9.0.0" } }; var zipFileA = testPackageA.Save(workingDir.Root); var zipFileB1 = testPackageB1.Save(workingDir.Root); var zipFileB2 = testPackageB2.Save(workingDir.Root); var log = new TestLogger(); // Act var exitCode = await Program.MainCore(new[] { "release", workingDir.Root, "-r", "beta" }, log); var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0-beta.nupkg")); var dependencyBNet45 = nuspecA.GetDependencyGroups().Single(e => e.TargetFramework == NuGetFramework.Parse("net45")).Packages.Single(e => e.Id == "b"); var dependencyBNet46 = nuspecA.GetDependencyGroups().Single(e => e.TargetFramework == NuGetFramework.Parse("net46")).Packages.Single(e => e.Id == "b"); // Assert Assert.Equal(0, exitCode); Assert.Equal("1.0.0-beta", dependencyBNet45.VersionRange.ToLegacyShortString()); Assert.Equal("2.0.0-beta", dependencyBNet46.VersionRange.ToLegacyShortString()); } }
private void BuildNuSpecManifest_After(object sender, BuildNuSpecManifestEventArgs e) { // Change the name e.Manifest.Metadata.Title = "Kentico Page Builder Containers"; e.Manifest.Metadata.SetProjectUrl("https://github.com/KenticoDevTrev/PageBuilderContainers"); e.Manifest.Metadata.SetIconUrl("https://www.hbs.net/HBS/media/Favicon/favicon-96x96.png"); e.Manifest.Metadata.Tags = "Kentico MVC Page Builder Containers"; e.Manifest.Metadata.Id = "PageBuilderContainers.Kentico"; e.Manifest.Metadata.ReleaseNotes = "Release for Kentico Xperience 13"; // Add nuget dependencies // Add dependencies List <PackageDependency> NetStandardDependencies = new List <PackageDependency>() { new PackageDependency("Kentico.Xperience.Libraries", new VersionRange(new NuGetVersion("13.0.0")), new string[] { }, new string[] { "Build", "Analyzers" }), new PackageDependency("PageBuilderContainers.Kentico.Base", new VersionRange(new NuGetVersion("13.0.1")), new string[] { }, new string[] { "Build", "Analyzers" }) }; PackageDependencyGroup PackageGroup = new PackageDependencyGroup(new NuGet.Frameworks.NuGetFramework(".NETStandard2.0"), NetStandardDependencies); e.Manifest.Metadata.DependencyGroups = new PackageDependencyGroup[] { PackageGroup }; // Add in Designer.cs and .cs files since really hard to include these in class library due to depenencies string BaseDir = HttpContext.Current.Server.MapPath("~").Trim('\\'); e.Manifest.Files.AddRange(new ManifestFile[] { new ManifestFile() { Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\General.ascx.cs", Target = "\\Content\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\General.ascx.cs", }, new ManifestFile() { Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\General.ascx.designer.cs", Target = "\\Content\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\General.ascx.designer.cs", }, new ManifestFile() { Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\PageBuilderContainerCode.ascx.cs", Target = "\\Content\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\PageBuilderContainerCode.ascx.cs", }, new ManifestFile() { Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\PageBuilderContainerCode.ascx.designer.cs", Target = "\\Content\\CMSModules\\PageBuilderContainers\\Controls\\PageBuilderContainers\\PageBuilderContainerCode.ascx.designer.cs", }, new ManifestFile() { Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_Edit_General.aspx.cs", Target = "\\Content\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_Edit_General.aspx.cs", }, new ManifestFile() { Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_Edit_General.aspx.designer.cs", Target = "\\Content\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_Edit_General.aspx.designer.cs", }, new ManifestFile() { Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_New.aspx.cs", Target = "\\Content\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_New.aspx.cs", }, new ManifestFile() { Source = BaseDir + "\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_New.aspx.designer.cs", Target = "\\Content\\CMSModules\\PageBuilderContainers\\UI\\PageBuilderContainers\\Container_New.aspx.designer.cs", } }); }
public async Task Command_ReleaseCommand_Label() { using (var workingDir = new TestFolder()) { // Arrange var testPackageA = new TestNupkg() { Nuspec = new TestNuspec() { Id = "a", Version = "1.0.0-beta.1.2" } }; var depGroup = new PackageDependencyGroup(NuGetFramework.Parse("net45"), new[] { new PackageDependency("b", VersionRange.Parse("2.0.0-alpha")), new PackageDependency("c", VersionRange.Parse("[1.0.0-beta]")) }); testPackageA.Nuspec.Dependencies.Add(depGroup); var testPackageB = new TestNupkg() { Nuspec = new TestNuspec() { Id = "b", Version = "2.0.0-alpha" } }; var testPackageC = new TestNupkg() { Nuspec = new TestNuspec() { Id = "c", Version = "1.0.0-beta" } }; var zipFileA = testPackageA.Save(workingDir.Root); var zipFileB = testPackageB.Save(workingDir.Root); var zipFileC = testPackageC.Save(workingDir.Root); var log = new TestLogger(); // Act var exitCode = await Program.MainCore(new[] { "release", workingDir.Root, "--label", "rc.1" }, log); var nuspecA = GetNuspec(Path.Combine(workingDir.Root, "a.1.0.0-rc.1.nupkg")); var nuspecB = GetNuspec(Path.Combine(workingDir.Root, "b.2.0.0-rc.1.nupkg")); var nuspecC = GetNuspec(Path.Combine(workingDir.Root, "c.1.0.0-rc.1.nupkg")); // Assert Assert.Equal(0, exitCode); Assert.Equal("1.0.0-rc.1", nuspecA.GetVersion().ToString()); Assert.Equal("2.0.0-rc.1", nuspecB.GetVersion().ToString()); Assert.Equal("1.0.0-rc.1", nuspecC.GetVersion().ToString()); Assert.Equal("2.0.0-rc.1", nuspecA.GetDependencyGroups().Single().Packages.Single(e => e.Id == "b").VersionRange.ToLegacyShortString()); Assert.Equal("[1.0.0-rc.1]", nuspecA.GetDependencyGroups().Single().Packages.Single(e => e.Id == "c").VersionRange.ToLegacyShortString()); } }
public static FrameworkGroup ToFrameworkGroup(this PackageDependencyGroup dependency) => new FrameworkGroup(dependency.TargetFramework.ToFramework(), dependency.Packages.Select(d => new PackageIdentity(d.Id, d.VersionRange.MinVersion.ToPackageVersion())));
private static JProperty WritePackageDependencySet(PackageDependencyGroup item) { return(new JProperty( item.TargetFramework?.ToString() ?? "*", WriteObject(item.Packages, WritePackageDependency))); }
void AddDependenciesToSearchMetadata (params PackageDependency [] dependencies) { var dependencyGroup = new PackageDependencyGroup ( new NuGetFramework ("any"), dependencies); packageSearchMetadata.DependencySetsList.Add (dependencyGroup); }