private void PopulateFrameworkReferences(PackageBuilder builder, IPackTaskRequest <IMSBuildItem> request)
{
var tfmSpecificRefs = new Dictionary <string, ISet <string> >();
foreach (var tfmRef in request.FrameworkReferences)
{
var targetFramework = tfmRef.GetProperty("TargetFramework");
if (tfmSpecificRefs.ContainsKey(targetFramework))
{
tfmSpecificRefs[targetFramework].Add(tfmRef.Identity);
}
else
{
tfmSpecificRefs.Add(targetFramework, new HashSet <string>(FrameworkReference.FrameworkReferenceNameComparer)
{
tfmRef.Identity
});
}
}
builder.FrameworkReferenceGroups.AddRange(
tfmSpecificRefs.Select(e =>
new FrameworkReferenceGroup(
NuGetFramework.Parse(e.Key),
e.Value.Select(fr => new FrameworkReference(fr)))));
}
private void PopulateFrameworkAssemblyReferences(PackageBuilder builder, IPackTaskRequest <IMSBuildItem> request)
{
// First add all the assembly references which are not specific to a certain TFM.
var tfmSpecificRefs = new Dictionary <string, IList <string> >(StringComparer.OrdinalIgnoreCase);
// Then add the TFM specific framework assembly references, and ignore any which have already been added above.
foreach (var tfmRef in request.FrameworkAssemblyReferences)
{
var targetFramework = tfmRef.GetProperty("TargetFramework");
if (tfmSpecificRefs.ContainsKey(tfmRef.Identity))
{
tfmSpecificRefs[tfmRef.Identity].Add(targetFramework);
}
else
{
tfmSpecificRefs.Add(tfmRef.Identity, new List <string>()
{
targetFramework
});
}
}
builder.FrameworkReferences.AddRange(
tfmSpecificRefs.Select(
t => new FrameworkAssemblyReference(
t.Key, t.Value.Select(
k => NuGetFramework.Parse(k))
)));
}
private ISet <NuGetFramework> ParseFrameworks(IPackTaskRequest <IMSBuildItem> request)
{
var nugetFrameworks = new HashSet <NuGetFramework>();
if (request.TargetFrameworks != null)
{
nugetFrameworks = new HashSet <NuGetFramework>(request.TargetFrameworks.Select(t => NuGetFramework.Parse(t)));
}
return(nugetFrameworks);
}
private void InitNuspecOutputPath(IPackTaskRequest <IMSBuildItem> request, PackArgs packArgs)
{
if (Path.IsPathRooted(request.NuspecOutputPath))
{
packArgs.PackTargetArgs.NuspecOutputPath = request.NuspecOutputPath;
}
else
{
packArgs.PackTargetArgs.NuspecOutputPath = Path.Combine(
packArgs.CurrentDirectory,
request.NuspecOutputPath);
}
}
public PackCommandRunner GetPackCommandRunner(
IPackTaskRequest <IMSBuildItem> request,
PackArgs packArgs,
PackageBuilder packageBuilder)
{
var runner = new PackCommandRunner(
packArgs,
MSBuildProjectFactory.ProjectCreator,
packageBuilder);
runner.GenerateNugetPackage = request.ContinuePackingAfterGeneratingNuspec;
return(runner);
}
private ISet <string> CalculateFilesToExcludeInPack(IPackTaskRequest <IMSBuildItem> request)
{
var excludeFiles = new HashSet <string>();
if (request.PackageFilesToExclude != null)
{
foreach (var file in request.PackageFilesToExclude)
{
var sourcePath = GetSourcePath(file);
excludeFiles.Add(sourcePath);
}
}
return(excludeFiles);
}
private string[] GetTargetPathsToAssemblies(IPackTaskRequest <IMSBuildItem> request)
{
if (request.TargetPathsToAssemblies == null)
{
return(new string[0]);
}
return(request.TargetPathsToAssemblies
.Where(path => path != null)
.Select(path => path.Trim())
.Where(path => path != string.Empty)
.Distinct()
.ToArray());
}
private IPackTaskRequest <IMSBuildItem> GetRequest(PackTask target)
{
// Arrange
IPackTaskRequest <IMSBuildItem> request = null;
var logic = new Mock <IPackTaskLogic>();
logic
.Setup(x => x.GetPackArgs(It.IsAny <IPackTaskRequest <IMSBuildItem> >()))
.Callback <IPackTaskRequest <IMSBuildItem> >(r => request = r);
target.PackTaskLogic = logic.Object;
// Act
var result = target.Execute();
// Assert
return(request);
}
private ISet <NuGetFramework> ParseFrameworks(IPackTaskRequest <IMSBuildItem> request, IDictionary <string, string> aliases)
{
var nugetFrameworks = new HashSet <NuGetFramework>();
if (request.TargetFrameworks != null)
{
nugetFrameworks = new HashSet <NuGetFramework>(request.TargetFrameworks.Select(targetFramework => {
string translated = null;
var succeeded = aliases.TryGetValue(targetFramework, out translated);
if (succeeded)
{
targetFramework = translated;
}
return(NuGetFramework.Parse(targetFramework));
}));
}
return(nugetFrameworks);
}
private static Version GetLicenseExpressionVersion(IPackTaskRequest <IMSBuildItem> request)
{
Version version;
if (string.IsNullOrEmpty(request.PackageLicenseExpressionVersion))
{
version = LicenseMetadata.EmptyVersion;
}
else
{
if (!Version.TryParse(request.PackageLicenseExpressionVersion, out version))
{
throw new PackagingException(NuGetLogCode.NU5034, string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidLicenseExpressionVersion,
request.PackageLicenseExpressionVersion));
}
}
return(version);
}
private IDictionary <string, string> GetSourceFiles(IPackTaskRequest <IMSBuildItem> request, string currentProjectDirectory)
{
var sourceFiles = new Dictionary <string, string>();
if (request.SourceFiles != null)
{
foreach (var src in request.SourceFiles)
{
var sourcePath = GetSourcePath(src);
var sourceProjectFile = currentProjectDirectory;
if (src.Properties.Contains("MSBuildSourceProjectFile"))
{
sourceProjectFile = src.GetProperty("MSBuildSourceProjectFile");
sourceProjectFile = Path.GetDirectoryName(sourceProjectFile);
}
sourceFiles[sourcePath] = sourceProjectFile;
}
}
return(sourceFiles);
}
private ICollection <PackageType> ParsePackageTypes(IPackTaskRequest <IMSBuildItem> request)
{
var listOfPackageTypes = new List <PackageType>();
if (request.PackageTypes != null)
{
foreach (var packageType in request.PackageTypes)
{
var packageTypeSplitInPart = packageType.Split(new char[] { ',' });
var packageTypeName = packageTypeSplitInPart[0].Trim();
var version = PackageType.EmptyVersion;
if (packageTypeSplitInPart.Length > 1)
{
var versionString = packageTypeSplitInPart[1];
Version.TryParse(versionString, out version);
}
listOfPackageTypes.Add(new PackageType(packageTypeName, version));
}
}
return(listOfPackageTypes);
}
private LockFile GetAssetsFile(IPackTaskRequest <IMSBuildItem> request)
{
if (request.PackItem == null)
{
throw new PackagingException(NuGetLogCode.NU5028, Strings.NoPackItemProvided);
}
string assetsFilePath = Path.Combine(request.RestoreOutputPath, LockFileFormat.AssetsFileName);
if (!File.Exists(assetsFilePath))
{
throw new InvalidOperationException(string.Format(
CultureInfo.CurrentCulture,
Strings.AssetsFileNotFound,
assetsFilePath));
}
// The assets file is necessary for project and package references. Pack should not do any traversal,
// so we leave that work up to restore (which produces the assets file).
var lockFileFormat = new LockFileFormat();
return(lockFileFormat.Read(assetsFilePath));
}
private void InitCurrentDirectoryAndFileName(IPackTaskRequest <IMSBuildItem> request, PackArgs packArgs)
{
if (request.PackItem == null)
{
throw new PackagingException(NuGetLogCode.NU5028, Strings.NoPackItemProvided);
}
packArgs.CurrentDirectory = Path.Combine(
request.PackItem.GetProperty("RootDir"),
request.PackItem.GetProperty("Directory")).TrimEnd(Path.DirectorySeparatorChar);
packArgs.Arguments = new string[]
{
!string.IsNullOrEmpty(request.NuspecFile)
? request.NuspecFile
: string.Concat(request.PackItem.GetProperty("FileName"), request.PackItem.GetProperty("Extension"))
};
packArgs.Path = !string.IsNullOrEmpty(request.NuspecFile)
? request.NuspecFile
: request.PackItem.GetProperty("FullPath");
packArgs.Exclude = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
}
public void PackTask_DelegatesToPackLogic()
{
// Arrange
var packArgs = new PackArgs();
var packageBuilder = new PackageBuilder();
var packCommandRunner = new PackCommandRunner(null, null);
IPackTaskRequest <IMSBuildItem> request = null;
var logic = new Mock <IPackTaskLogic>();
logic
.Setup(x => x.GetPackArgs(It.IsAny <IPackTaskRequest <IMSBuildItem> >()))
.Returns(packArgs)
.Callback <IPackTaskRequest <IMSBuildItem> >(r => request = r);
logic
.Setup(x => x.GetPackageBuilder(It.IsAny <IPackTaskRequest <IMSBuildItem> >()))
.Returns(packageBuilder);
logic
.Setup(x => x.GetPackCommandRunner(It.IsAny <IPackTaskRequest <IMSBuildItem> >(), packArgs, packageBuilder))
.Returns(packCommandRunner);
var target = new PackTask();
target.PackTaskLogic = logic.Object;
// Act
var result = target.Execute();
// Assert
// We cannot mock the PackCommandRunner because it's not overridable.
Assert.False(result);
Assert.NotNull(request);
logic.Verify(x => x.GetPackArgs(request));
logic.Verify(x => x.GetPackageBuilder(request));
logic.Verify(x => x.GetPackCommandRunner(request, packArgs, packageBuilder));
logic.Verify(x => x.BuildPackage(packCommandRunner));
}
private Dictionary <string, IEnumerable <ContentMetadata> > ProcessContentToIncludeInPackage(
IPackTaskRequest <IMSBuildItem> request,
PackArgs packArgs)
{
// This maps from source path on disk to target path inside the nupkg.
var fileModel = new Dictionary <string, IEnumerable <ContentMetadata> >();
if (request.PackageFiles != null)
{
var excludeFiles = CalculateFilesToExcludeInPack(request);
foreach (var packageFile in request.PackageFiles)
{
var sourcePath = GetSourcePath(packageFile);
if (excludeFiles.Contains(sourcePath))
{
continue;
}
var totalContentMetadata = GetContentMetadata(packageFile, sourcePath, packArgs, request.ContentTargetFolders);
if (fileModel.ContainsKey(sourcePath))
{
var existingContentMetadata = fileModel[sourcePath];
fileModel[sourcePath] = existingContentMetadata.Concat(totalContentMetadata);
}
else
{
var existingContentMetadata = new List <ContentMetadata>();
existingContentMetadata.AddRange(totalContentMetadata);
fileModel.Add(sourcePath, existingContentMetadata);
}
}
}
return(fileModel);
}
public PackageBuilder GetPackageBuilder(IPackTaskRequest <IMSBuildItem> request)
{
// Load the assets JSON file produced by restore.
var assetsFilePath = Path.Combine(request.RestoreOutputPath, LockFileFormat.AssetsFileName);
if (!File.Exists(assetsFilePath))
{
throw new PackagingException(NuGetLogCode.NU5023, string.Format(
CultureInfo.CurrentCulture,
Strings.AssetsFileNotFound,
assetsFilePath));
}
var builder = new PackageBuilder(request.Deterministic)
{
Id = request.PackageId,
Description = request.Description,
Title = request.Title,
Copyright = request.Copyright,
ReleaseNotes = request.ReleaseNotes,
RequireLicenseAcceptance = request.RequireLicenseAcceptance,
PackageTypes = ParsePackageTypes(request)
};
if (request.DevelopmentDependency)
{
builder.DevelopmentDependency = true;
}
if (request.PackageVersion != null)
{
NuGetVersion version;
if (!NuGetVersion.TryParse(request.PackageVersion, out version))
{
throw new PackagingException(NuGetLogCode.NU5024, string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidPackageVersion,
request.PackageVersion));
}
builder.Version = version;
}
else
{
builder.Version = new NuGetVersion("1.0.0");
}
if (request.Authors != null)
{
builder.Authors.AddRange(request.Authors);
}
if (request.Tags != null)
{
builder.Tags.AddRange(request.Tags);
}
Uri tempUri;
if (Uri.TryCreate(request.LicenseUrl, UriKind.Absolute, out tempUri))
{
builder.LicenseUrl = tempUri;
}
if (Uri.TryCreate(request.ProjectUrl, UriKind.Absolute, out tempUri))
{
builder.ProjectUrl = tempUri;
}
if (Uri.TryCreate(request.IconUrl, UriKind.Absolute, out tempUri))
{
builder.IconUrl = tempUri;
}
if (!string.IsNullOrEmpty(request.RepositoryUrl) || !string.IsNullOrEmpty(request.RepositoryType))
{
builder.Repository = new RepositoryMetadata(
request.RepositoryType,
request.RepositoryUrl,
request.RepositoryBranch,
request.RepositoryCommit);
}
builder.LicenseMetadata = BuildLicenseMetadata(request);
builder.Icon = request.PackageIcon;
if (request.MinClientVersion != null)
{
Version version;
if (!Version.TryParse(request.MinClientVersion, out version))
{
throw new PackagingException(NuGetLogCode.NU5022, string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidMinClientVersion,
request.MinClientVersion));
}
builder.MinClientVersion = version;
}
// The assets file is necessary for project and package references. Pack should not do any traversal,
// so we leave that work up to restore (which produces the assets file).
var lockFileFormat = new LockFileFormat();
var assetsFile = lockFileFormat.Read(assetsFilePath);
if (assetsFile.PackageSpec == null)
{
throw new PackagingException(NuGetLogCode.NU5025, string.Format(
CultureInfo.CurrentCulture,
Strings.AssetsFileDoesNotHaveValidPackageSpec,
assetsFilePath));
}
var projectRefToVersionMap = new Dictionary <string, string>(PathUtility.GetStringComparerBasedOnOS());
if (request.ProjectReferencesWithVersions != null && request.ProjectReferencesWithVersions.Any())
{
projectRefToVersionMap = request
.ProjectReferencesWithVersions
.ToDictionary(msbuildItem => msbuildItem.Identity,
msbuildItem => msbuildItem.GetProperty("ProjectVersion"), PathUtility.GetStringComparerBasedOnOS());
}
var nuGetFrameworkComparer = new NuGetFrameworkFullComparer();
var frameworksWithSuppressedDependencies = new HashSet <NuGetFramework>(nuGetFrameworkComparer);
if (request.FrameworksWithSuppressedDependencies != null && request.FrameworksWithSuppressedDependencies.Any())
{
frameworksWithSuppressedDependencies =
new HashSet <NuGetFramework>(request.FrameworksWithSuppressedDependencies
.Select(t => NuGetFramework.Parse(t.Identity)).ToList(), nuGetFrameworkComparer);
}
PopulateProjectAndPackageReferences(builder,
assetsFile,
projectRefToVersionMap,
frameworksWithSuppressedDependencies);
PopulateFrameworkAssemblyReferences(builder, request);
PopulateFrameworkReferences(builder, assetsFile);
return(builder);
}
public PackArgs GetPackArgs(IPackTaskRequest <IMSBuildItem> request)
{
var packArgs = new PackArgs
{
Logger = request.Logger,
OutputDirectory = request.PackageOutputPath,
Serviceable = request.Serviceable,
Tool = request.IsTool,
Symbols = request.IncludeSymbols,
BasePath = request.NuspecBasePath,
NoPackageAnalysis = request.NoPackageAnalysis,
PackTargetArgs = new MSBuildPackTargetArgs
{
TargetPathsToAssemblies = InitLibFiles(request.BuildOutputInPackage),
TargetPathsToSymbols = InitLibFiles(request.TargetPathsToSymbols),
AssemblyName = request.AssemblyName,
IncludeBuildOutput = request.IncludeBuildOutput,
BuildOutputFolder = request.BuildOutputFolder,
TargetFrameworks = ParseFrameworks(request)
}
};
if (request.MinClientVersion != null)
{
Version version;
if (!Version.TryParse(request.MinClientVersion, out version))
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidMinClientVersion,
request.MinClientVersion));
}
packArgs.MinClientVersion = version;
}
if (request.NuspecProperties != null && request.NuspecProperties.Any())
{
packArgs.Properties.AddRange(ParsePropertiesAsDictionary(request.NuspecProperties));
if (packArgs.Properties.ContainsKey("version"))
{
packArgs.Version = packArgs.Properties["version"];
}
}
InitCurrentDirectoryAndFileName(request, packArgs);
InitNuspecOutputPath(request, packArgs);
if (request.IncludeSource)
{
packArgs.PackTargetArgs.SourceFiles = GetSourceFiles(request, packArgs.CurrentDirectory);
packArgs.Symbols = request.IncludeSource;
}
PackCommandRunner.SetupCurrentDirectory(packArgs);
var contentFiles = ProcessContentToIncludeInPackage(request, packArgs);
packArgs.PackTargetArgs.ContentFiles = contentFiles;
return(packArgs);
}
public PackageBuilder GetPackageBuilder(IPackTaskRequest <IMSBuildItem> request)
{
// Load the assets JSON file produced by restore.
var assetsFilePath = Path.Combine(request.RestoreOutputPath, LockFileFormat.AssetsFileName);
if (!File.Exists(assetsFilePath))
{
throw new InvalidOperationException(string.Format(
CultureInfo.CurrentCulture,
Strings.AssetsFileNotFound,
assetsFilePath));
}
var builder = new PackageBuilder
{
Id = request.PackageId,
Description = request.Description,
Title = request.Title,
Copyright = request.Copyright,
ReleaseNotes = request.ReleaseNotes,
RequireLicenseAcceptance = request.RequireLicenseAcceptance,
PackageTypes = ParsePackageTypes(request)
};
if (request.DevelopmentDependency)
{
builder.DevelopmentDependency = true;
}
if (request.PackageVersion != null)
{
NuGetVersion version;
if (!NuGetVersion.TryParse(request.PackageVersion, out version))
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidPackageVersion,
request.PackageVersion));
}
builder.Version = version;
}
else
{
builder.Version = new NuGetVersion("1.0.0");
}
if (request.Authors != null)
{
builder.Authors.AddRange(request.Authors);
}
if (request.Tags != null)
{
builder.Tags.AddRange(request.Tags);
}
Uri tempUri;
if (Uri.TryCreate(request.LicenseUrl, UriKind.Absolute, out tempUri))
{
builder.LicenseUrl = tempUri;
}
if (Uri.TryCreate(request.ProjectUrl, UriKind.Absolute, out tempUri))
{
builder.ProjectUrl = tempUri;
}
if (Uri.TryCreate(request.IconUrl, UriKind.Absolute, out tempUri))
{
builder.IconUrl = tempUri;
}
if (!string.IsNullOrEmpty(request.RepositoryUrl) || !string.IsNullOrEmpty(request.RepositoryType))
{
builder.Repository = new RepositoryMetadata(request.RepositoryType, request.RepositoryUrl);
}
if (request.MinClientVersion != null)
{
Version version;
if (!Version.TryParse(request.MinClientVersion, out version))
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidMinClientVersion,
request.MinClientVersion));
}
builder.MinClientVersion = version;
}
// The assets file is necessary for project and package references. Pack should not do any traversal,
// so we leave that work up to restore (which produces the assets file).
var lockFileFormat = new LockFileFormat();
var assetsFile = lockFileFormat.Read(assetsFilePath);
if (assetsFile.PackageSpec == null)
{
throw new InvalidOperationException(string.Format(
CultureInfo.CurrentCulture,
Strings.AssetsFileDoesNotHaveValidPackageSpec,
assetsFilePath));
}
PopulateProjectAndPackageReferences(builder, assetsFile);
PopulateFrameworkAssemblyReferences(builder, request);
return(builder);
}
public PackArgs GetPackArgs(IPackTaskRequest <IMSBuildItem> request)
{
var packArgs = new PackArgs
{
InstallPackageToOutputPath = request.InstallPackageToOutputPath,
OutputFileNamesWithoutVersion = request.OutputFileNamesWithoutVersion,
OutputDirectory = request.PackageOutputPath,
Serviceable = request.Serviceable,
Tool = request.IsTool,
Symbols = request.IncludeSymbols,
SymbolPackageFormat = PackArgs.GetSymbolPackageFormat(request.SymbolPackageFormat),
BasePath = request.NuspecBasePath,
NoPackageAnalysis = request.NoPackageAnalysis,
NoDefaultExcludes = request.NoDefaultExcludes,
WarningProperties = WarningProperties.GetWarningProperties(request.TreatWarningsAsErrors, request.WarningsAsErrors, request.NoWarn),
PackTargetArgs = new MSBuildPackTargetArgs()
};
packArgs.Logger = new PackCollectorLogger(request.Logger, packArgs.WarningProperties);
if (request.MinClientVersion != null)
{
Version version;
if (!Version.TryParse(request.MinClientVersion, out version))
{
throw new PackagingException(NuGetLogCode.NU5022, string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidMinClientVersion,
request.MinClientVersion));
}
packArgs.MinClientVersion = version;
}
InitCurrentDirectoryAndFileName(request, packArgs);
InitNuspecOutputPath(request, packArgs);
PackCommandRunner.SetupCurrentDirectory(packArgs);
if (!string.IsNullOrEmpty(request.NuspecFile))
{
if (request.NuspecProperties != null && request.NuspecProperties.Any())
{
packArgs.Properties.AddRange(ParsePropertiesAsDictionary(request.NuspecProperties));
if (packArgs.Properties.ContainsKey("version"))
{
packArgs.Version = packArgs.Properties["version"];
}
}
}
else
{
// This only needs to happen when packing via csproj, not nuspec.
packArgs.PackTargetArgs.AllowedOutputExtensionsInPackageBuildOutputFolder = InitOutputExtensions(request.AllowedOutputExtensionsInPackageBuildOutputFolder);
packArgs.PackTargetArgs.AllowedOutputExtensionsInSymbolsPackageBuildOutputFolder = InitOutputExtensions(request.AllowedOutputExtensionsInSymbolsPackageBuildOutputFolder);
packArgs.PackTargetArgs.TargetPathsToAssemblies = InitLibFiles(request.BuildOutputInPackage);
packArgs.PackTargetArgs.TargetPathsToSymbols = InitLibFiles(request.TargetPathsToSymbols);
packArgs.PackTargetArgs.AssemblyName = request.AssemblyName;
packArgs.PackTargetArgs.IncludeBuildOutput = request.IncludeBuildOutput;
packArgs.PackTargetArgs.BuildOutputFolder = request.BuildOutputFolders;
packArgs.PackTargetArgs.TargetFrameworks = ParseFrameworks(request);
if (request.IncludeSource)
{
packArgs.PackTargetArgs.SourceFiles = GetSourceFiles(request, packArgs.CurrentDirectory);
packArgs.Symbols = request.IncludeSource;
}
var contentFiles = ProcessContentToIncludeInPackage(request, packArgs);
packArgs.PackTargetArgs.ContentFiles = contentFiles;
}
return(packArgs);
}
private LicenseMetadata BuildLicenseMetadata(IPackTaskRequest <IMSBuildItem> request)
{
var hasLicenseExpression = !string.IsNullOrEmpty(request.PackageLicenseExpression);
var hasLicenseFile = !string.IsNullOrEmpty(request.PackageLicenseFile);
if (hasLicenseExpression || hasLicenseFile)
{
if (!string.IsNullOrEmpty(request.LicenseUrl))
{
throw new PackagingException(NuGetLogCode.NU5035, string.Format(
CultureInfo.CurrentCulture,
Strings.NuGetLicenses_LicenseUrlCannotBeUsedInConjuctionWithLicense));
}
if (hasLicenseExpression && hasLicenseFile)
{
throw new PackagingException(NuGetLogCode.NU5033, string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidLicenseCombination,
request.PackageLicenseExpression));
}
var version = GetLicenseExpressionVersion(request);
if (hasLicenseExpression)
{
if (version.CompareTo(LicenseMetadata.CurrentVersion) <= 0)
{
try
{
var expression = NuGetLicenseExpression.Parse(request.PackageLicenseExpression);
return(new LicenseMetadata(
type: LicenseType.Expression,
license: request.PackageLicenseExpression,
expression: expression,
warningsAndErrors: null,
version: version));
}
catch (NuGetLicenseExpressionParsingException e)
{
throw new PackagingException(NuGetLogCode.NU5032, string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidLicenseExpression,
request.PackageLicenseExpression, e.Message),
e);
}
}
else
{
throw new PackagingException(NuGetLogCode.NU5034, string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidLicenseExppressionVersion_VersionTooHigh,
request.PackageLicenseExpressionVersion,
LicenseMetadata.CurrentVersion));
}
}
if (hasLicenseFile)
{
return(new LicenseMetadata(
type: LicenseType.File,
license: request.PackageLicenseFile,
expression: null,
warningsAndErrors: null,
version: version));
}
}
return(null);
}
