private static void PopulateDependencies(
string packageSpecPath,
IList <LibraryDependency> results,
JObject settings,
string propertyName,
bool isGacOrFrameworkReference)
{
var dependencies = settings[propertyName] as JObject;
if (dependencies != null)
{
foreach (var dependency in dependencies)
{
if (string.IsNullOrEmpty(dependency.Key))
{
throw FileFormatException.Create(
"Unable to resolve dependency ''.",
dependency.Value,
packageSpecPath);
}
// Support
// "dependencies" : {
// "Name" : "1.0"
// }
var dependencyValue = dependency.Value;
var dependencyTypeValue = LibraryDependencyType.Default;
var dependencyIncludeFlagsValue = LibraryIncludeFlags.All;
var dependencyExcludeFlagsValue = LibraryIncludeFlags.None;
var suppressParentFlagsValue = LibraryIncludeFlagUtils.DefaultSuppressParent;
var noWarn = new List <NuGetLogCode>();
// This method handles both the dependencies and framework assembly sections.
// Framework references should be limited to references.
// Dependencies should allow everything but framework references.
var targetFlagsValue = isGacOrFrameworkReference
? LibraryDependencyTarget.Reference
: LibraryDependencyTarget.All & ~LibraryDependencyTarget.Reference;
var autoReferenced = false;
string dependencyVersionValue = null;
var dependencyVersionToken = dependencyValue;
if (dependencyValue.Type == JTokenType.String)
{
dependencyVersionValue = dependencyValue.Value <string>();
}
else
{
if (dependencyValue.Type == JTokenType.Object)
{
dependencyVersionToken = dependencyValue["version"];
if (dependencyVersionToken != null &&
dependencyVersionToken.Type == JTokenType.String)
{
dependencyVersionValue = dependencyVersionToken.Value <string>();
}
}
IEnumerable <string> strings;
if (TryGetStringEnumerable(dependencyValue["type"], out strings))
{
dependencyTypeValue = LibraryDependencyType.Parse(strings);
// Types are used at pack time, they should be translated to suppressParent to
// provide a matching effect for project to project references.
// This should be set before suppressParent is checked.
if (!dependencyTypeValue.Contains(LibraryDependencyTypeFlag.BecomesNupkgDependency))
{
suppressParentFlagsValue = LibraryIncludeFlags.All;
}
else if (dependencyTypeValue.Contains(LibraryDependencyTypeFlag.SharedFramework))
{
dependencyIncludeFlagsValue =
LibraryIncludeFlags.Build |
LibraryIncludeFlags.Compile |
LibraryIncludeFlags.Analyzers;
}
}
if (TryGetStringEnumerable(dependencyValue["include"], out strings))
{
dependencyIncludeFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
if (TryGetStringEnumerable(dependencyValue["exclude"], out strings))
{
dependencyExcludeFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
if (TryGetStringEnumerable(dependencyValue["suppressParent"], out strings))
{
// This overrides any settings that came from the type property.
suppressParentFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
noWarn = GetNuGetLogCodeEnumerableFromJArray(dependencyValue["noWarn"])
.ToList();
var targetToken = dependencyValue["target"];
if (targetToken != null)
{
var targetString = targetToken.Value <string>();
targetFlagsValue = LibraryDependencyTargetUtils.Parse(targetString);
// Verify that the value specified is package, project, or external project
if (!ValidateDependencyTarget(targetFlagsValue))
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.InvalidDependencyTarget,
targetString);
throw FileFormatException.Create(message, targetToken, packageSpecPath);
}
}
autoReferenced = GetBoolOrFalse(dependencyValue, "autoReferenced", packageSpecPath);
}
VersionRange dependencyVersionRange = null;
if (!string.IsNullOrEmpty(dependencyVersionValue))
{
try
{
dependencyVersionRange = VersionRange.Parse(dependencyVersionValue);
}
catch (Exception ex)
{
throw FileFormatException.Create(
ex,
dependencyVersionToken,
packageSpecPath);
}
}
// Projects and References may have empty version ranges, Packages may not
if (dependencyVersionRange == null)
{
if ((targetFlagsValue & LibraryDependencyTarget.Package) == LibraryDependencyTarget.Package)
{
throw FileFormatException.Create(
new ArgumentException(Strings.MissingVersionOnDependency),
dependency.Value,
packageSpecPath);
}
else
{
// Projects and references with no version property allow all versions
dependencyVersionRange = VersionRange.All;
}
}
// the dependency flags are: Include flags - Exclude flags
var includeFlags = dependencyIncludeFlagsValue & ~dependencyExcludeFlagsValue;
results.Add(new LibraryDependency()
{
LibraryRange = new LibraryRange()
{
Name = dependency.Key,
TypeConstraint = targetFlagsValue,
VersionRange = dependencyVersionRange,
},
Type = dependencyTypeValue,
IncludeType = includeFlags,
SuppressParent = suppressParentFlagsValue,
AutoReferenced = autoReferenced,
NoWarn = noWarn.ToList()
});
}
}
}
private static void PopulateDependencies(
string projectPath,
IList <ProjectLibraryDependency> results,
JObject settings,
string propertyName,
bool isGacOrFrameworkReference)
{
var dependencies = settings.Value <JToken>(propertyName) as JObject;
if (dependencies != null)
{
foreach (var dependency in dependencies)
{
if (string.IsNullOrEmpty(dependency.Key))
{
throw FileFormatException.Create(
"Unable to resolve dependency ''.",
dependency.Key,
projectPath);
}
var dependencyValue = dependency.Value;
var dependencyTypeValue = LibraryDependencyType.Default;
var dependencyIncludeFlagsValue = LibraryIncludeFlags.All;
var dependencyExcludeFlagsValue = LibraryIncludeFlags.None;
var suppressParentFlagsValue = LibraryIncludeFlagUtils.DefaultSuppressParent;
var target = isGacOrFrameworkReference ? LibraryDependencyTarget.Reference : LibraryDependencyTarget.All;
string dependencyVersionAsString = null;
if (dependencyValue.Type == JTokenType.Object)
{
// "dependencies" : { "Name" : { "version": "1.0", "type": "build", "target": "project" } }
dependencyVersionAsString = dependencyValue.Value <string>("version");
var type = dependencyValue.Value <string>("type");
if (type != null)
{
dependencyTypeValue = LibraryDependencyType.Parse(new [] { type });
}
// Read the target if specified
if (!isGacOrFrameworkReference)
{
var targetStr = dependencyValue.Value <string>("target");
target = LibraryDependencyTargetUtils.Parse(targetStr);
}
IEnumerable <string> strings;
if (TryGetStringEnumerable(dependencyValue["include"], out strings))
{
dependencyIncludeFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
if (TryGetStringEnumerable(dependencyValue["exclude"], out strings))
{
dependencyExcludeFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
if (TryGetStringEnumerable(dependencyValue["suppressParent"], out strings))
{
// This overrides any settings that came from the type property.
suppressParentFlagsValue = LibraryIncludeFlagUtils.GetFlags(strings);
}
}
else if (dependencyValue.Type == JTokenType.String)
{
// "dependencies" : { "Name" : "1.0" }
dependencyVersionAsString = dependencyValue.Value <string>();
}
else
{
throw FileFormatException.Create(
string.Format(
"Invalid dependency version: {0}. The format is not recognizable.",
dependency.Key),
dependencyValue,
projectPath);
}
VersionRange dependencyVersionRange = null;
if (!string.IsNullOrEmpty(dependencyVersionAsString))
{
try
{
dependencyVersionRange = VersionRange.Parse(dependencyVersionAsString);
}
catch (Exception ex)
{
throw FileFormatException.Create(ex, dependencyValue, projectPath);
}
}
// the dependency flags are: Include flags - Exclude flags
var includeFlags = dependencyIncludeFlagsValue & ~dependencyExcludeFlagsValue;
var lineInfo = (IJsonLineInfo)dependencyValue;
results.Add(new ProjectLibraryDependency
{
LibraryRange = new LibraryRange(
dependency.Key,
dependencyVersionRange,
target),
Type = dependencyTypeValue,
IncludeType = includeFlags,
SuppressParent = suppressParentFlagsValue,
SourceFilePath = projectPath,
SourceLine = lineInfo.LineNumber,
SourceColumn = lineInfo.LinePosition
});
}
}
}
private static void PopulateDependencies(
string projectPath,
IList <LibraryRange> results,
JsonObject settings,
string propertyName,
bool isGacOrFrameworkReference)
{
var dependencies = settings.ValueAsJsonObject(propertyName);
if (dependencies != null)
{
foreach (var dependencyKey in dependencies.Keys)
{
if (string.IsNullOrEmpty(dependencyKey))
{
throw FileFormatException.Create(
"Unable to resolve dependency ''.",
dependencies.Value(dependencyKey),
projectPath);
}
var dependencyValue = dependencies.Value(dependencyKey);
var dependencyTypeValue = LibraryDependencyType.Default;
JsonString dependencyVersionAsString = null;
LibraryType target = isGacOrFrameworkReference ? LibraryType.ReferenceAssembly : LibraryType.Unspecified;
if (dependencyValue is JsonObject)
{
// "dependencies" : { "Name" : { "version": "1.0", "type": "build", "target": "project" } }
var dependencyValueAsObject = (JsonObject)dependencyValue;
dependencyVersionAsString = dependencyValueAsObject.ValueAsString("version");
var type = dependencyValueAsObject.ValueAsString("type");
if (type != null)
{
dependencyTypeValue = LibraryDependencyType.Parse(type.Value);
}
// Read the target if specified
if (!isGacOrFrameworkReference)
{
LibraryType parsedTarget;
var targetStr = dependencyValueAsObject.ValueAsString("target");
if (!string.IsNullOrEmpty(targetStr) && LibraryType.TryParse(targetStr, out parsedTarget))
{
target = parsedTarget;
}
}
}
else if (dependencyValue is JsonString)
{
// "dependencies" : { "Name" : "1.0" }
dependencyVersionAsString = (JsonString)dependencyValue;
}
else
{
throw FileFormatException.Create(
string.Format("Invalid dependency version: {0}. The format is not recognizable.", dependencyKey),
dependencyValue,
projectPath);
}
VersionRange dependencyVersionRange = null;
if (!string.IsNullOrEmpty(dependencyVersionAsString?.Value))
{
try
{
dependencyVersionRange = VersionRange.Parse(dependencyVersionAsString.Value);
}
catch (Exception ex)
{
throw FileFormatException.Create(
ex,
dependencyValue,
projectPath);
}
}
results.Add(new LibraryRange(
dependencyKey,
dependencyVersionRange,
target,
dependencyTypeValue,
projectPath,
dependencies.Value(dependencyKey).Line,
dependencies.Value(dependencyKey).Column));
}
}
}
private static void PopulateDependencies(
string projectPath,
IList <LibraryDependency> results,
JObject settings,
string propertyName,
bool isGacOrFrameworkReference)
{
var dependencies = settings[propertyName] as JObject;
if (dependencies != null)
{
foreach (var dependency in dependencies)
{
if (string.IsNullOrEmpty(dependency.Key))
{
throw ProjectFormatException.Create(
"Unable to resolve dependency ''.",
dependency.Value,
projectPath);
}
// Support
// "dependencies" : {
// "Name" : "1.0"
// }
var dependencyValue = dependency.Value;
var dependencyTypeValue = LibraryDependencyType.Default;
string dependencyVersionValue = null;
JToken dependencyVersionToken = dependencyValue;
if (dependencyValue.Type == JTokenType.String)
{
dependencyVersionValue = dependencyValue.Value <string>();
}
else
{
if (dependencyValue.Type == JTokenType.Object)
{
dependencyVersionToken = dependencyValue["version"];
if (dependencyVersionToken != null && dependencyVersionToken.Type == JTokenType.String)
{
dependencyVersionValue = dependencyVersionToken.Value <string>();
}
}
IEnumerable <string> strings;
if (TryGetStringEnumerable(dependencyValue["type"], out strings))
{
dependencyTypeValue = LibraryDependencyType.Parse(strings);
}
}
NuGetVersionRange dependencyVersionRange = null;
if (!string.IsNullOrEmpty(dependencyVersionValue))
{
try
{
dependencyVersionRange = NuGetVersionRange.Parse(dependencyVersionValue);
}
catch (Exception ex)
{
throw ProjectFormatException.Create(
ex,
dependencyVersionToken,
projectPath);
}
}
results.Add(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = dependency.Key,
VersionRange = dependencyVersionRange,
IsGacOrFrameworkReference = isGacOrFrameworkReference,
},
Type = dependencyTypeValue
});
}
}
}
