public void GetFlags_WhenFlagsIsMultipleValues_ReturnsCombinationOfValues()
{
LibraryIncludeFlags[] expectedFlags = new[]
{
LibraryIncludeFlags.Runtime,
LibraryIncludeFlags.Compile,
LibraryIncludeFlags.Build
};
LibraryIncludeFlags flags = LibraryIncludeFlagUtils.GetFlags(expectedFlags.Select(flag => flag.ToString()));
Assert.Equal("Runtime, Compile, Build", flags.ToString());
}
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 ProjectItemElement AddPackageReference(ProjectItemGroupElement itemGroupElement, PackageReference package)
{
LibraryIncludeFlags includeAssets = LibraryIncludeFlags.All;
LibraryIncludeFlags excludeAssets = LibraryIncludeFlags.None;
LibraryIncludeFlags privateAssets = LibraryIncludeFlags.None;
if (package.HasFolder("build") && package.Imports.Count == 0)
{
excludeAssets |= LibraryIncludeFlags.Build;
}
if (package.HasFolder("lib") && package.AssemblyReferences.Count == 0)
{
excludeAssets |= LibraryIncludeFlags.Compile;
excludeAssets |= LibraryIncludeFlags.Runtime;
}
if (package.HasFolder("analyzers") && package.AnalyzerItems.Count == 0)
{
excludeAssets |= LibraryIncludeFlags.Analyzers;
}
if (package.IsDevelopmentDependency)
{
privateAssets |= LibraryIncludeFlags.All;
}
if (package.IsMissingTransitiveDependency)
{
includeAssets = LibraryIncludeFlags.None;
excludeAssets = LibraryIncludeFlags.None;
privateAssets = LibraryIncludeFlags.All;
}
ProjectItemElement itemElement = itemGroupElement.AppendItem("PackageReference", package.PackageIdentity.Id);
itemElement.AddMetadataAsAttribute("Version", package.PackageVersion.ToNormalizedString());
if (includeAssets != LibraryIncludeFlags.All)
{
itemElement.AddMetadataAsAttribute("IncludeAssets", includeAssets.ToString());
}
if (excludeAssets != LibraryIncludeFlags.None)
{
itemElement.AddMetadataAsAttribute("ExcludeAssets", excludeAssets.ToString());
}
if (privateAssets != LibraryIncludeFlags.None)
{
itemElement.AddMetadataAsAttribute("PrivateAssets", privateAssets.ToString());
}
if (package.GeneratePathProperty)
{
itemElement.AddMetadataAsAttribute("GeneratePathProperty", bool.TrueString);
}
return(itemElement);
}
public void GetFlags_WhenFlagsIsSingleValue_ReturnsFlag(
LibraryIncludeFlags input,
LibraryIncludeFlags expectedResult)
{
LibraryIncludeFlags actualResult = LibraryIncludeFlagUtils.GetFlags(new[] { input.ToString() });
Assert.Equal(expectedResult, actualResult);
}
