public void Implicit()
{
var properties = ImmutableStringDictionary <string> .EmptyOrdinal.Add("myProp", "myVal");
var dependencyIDs = new[] { "id1", "id2" };
var model = new PackageDependencyModel(
path: "c:\\myPath",
originalItemSpec: "myOriginalItemSpec",
name: "myPath",
version: "",
isResolved: true,
isImplicit: true,
properties: properties,
isTopLevel: true,
isVisible: true,
dependenciesIDs: dependencyIDs);
Assert.Equal(PackageRuleHandler.ProviderTypeString, model.ProviderType);
Assert.Equal("c:\\myPath", model.Path);
Assert.Equal("myPath", model.Name);
Assert.Equal("myOriginalItemSpec", model.OriginalItemSpec);
Assert.Equal("myOriginalItemSpec", model.Id);
Assert.Equal("", model.Version);
Assert.Equal("myPath", model.Caption);
Assert.Equal(ResolvedPackageReference.SchemaName, model.SchemaName);
Assert.Equal(PackageReference.PrimaryDataSourceItemType, model.SchemaItemType);
Assert.True(model.TopLevel);
Assert.True(model.Visible);
Assert.True(model.Resolved);
Assert.True(model.Implicit);
Assert.Equal(properties, model.Properties);
Assert.Equal(Dependency.PackageNodePriority, model.Priority);
Assert.Equal(ManagedImageMonikers.NuGetGreyPrivate, model.Icon);
Assert.Equal(ManagedImageMonikers.NuGetGreyPrivate, model.ExpandedIcon);
Assert.Equal(ManagedImageMonikers.NuGetGreyWarning, model.UnresolvedIcon);
Assert.Equal(ManagedImageMonikers.NuGetGreyWarning, model.UnresolvedExpandedIcon);
AssertEx.CollectionLength(model.DependencyIDs, 2);
Assert.Equal(
DependencyTreeFlags.NuGetSubTreeNodeFlags +
DependencyTreeFlags.PackageNodeFlags +
DependencyTreeFlags.SupportsHierarchy +
DependencyTreeFlags.GenericResolvedDependencyFlags -
DependencyTreeFlags.SupportsRemove,
model.Flags);
}
public void Unresolved()
{
var properties = ImmutableDictionary <string, string> .Empty.Add("myProp", "myVal");
var dependencyIDs = new[] { "id1", "id2" };
var flag = ProjectTreeFlags.Create("MyCustomFlag");
var model = new PackageDependencyModel(
providerType: "myProvider",
path: "c:\\myPath",
originalItemSpec: "myOriginalItemSpec",
name: "myPath",
flags: flag,
version: "myVersion",
resolved: false,
isImplicit: false,
properties: properties,
isTopLevel: true,
isVisible: true,
dependenciesIDs: dependencyIDs);
Assert.Equal("myProvider", model.ProviderType);
Assert.Equal("c:\\myPath", model.Path);
Assert.Equal("myPath", model.Name);
Assert.Equal("myOriginalItemSpec", model.OriginalItemSpec);
Assert.Equal("myOriginalItemSpec", model.Id);
Assert.Equal("myVersion", model.Version);
Assert.Equal("myPath (myVersion)", model.Caption);
Assert.Equal(PackageReference.SchemaName, model.SchemaName);
Assert.Equal(PackageReference.PrimaryDataSourceItemType, model.SchemaItemType);
Assert.True(model.TopLevel);
Assert.True(model.Visible);
Assert.False(model.Resolved);
Assert.False(model.Implicit);
Assert.Equal(properties, model.Properties);
Assert.Equal(Dependency.UnresolvedReferenceNodePriority, model.Priority);
Assert.Equal(ManagedImageMonikers.NuGetGrey, model.Icon);
Assert.Equal(ManagedImageMonikers.NuGetGrey, model.ExpandedIcon);
Assert.Equal(ManagedImageMonikers.NuGetGreyWarning, model.UnresolvedIcon);
Assert.Equal(ManagedImageMonikers.NuGetGreyWarning, model.UnresolvedExpandedIcon);
AssertEx.CollectionLength(model.DependencyIDs, 2);
Assert.True(model.Flags.Contains(DependencyTreeFlags.PackageNodeFlags));
Assert.True(model.Flags.Contains(DependencyTreeFlags.SupportsHierarchy));
Assert.True(model.Flags.Contains(flag));
}
private bool TryCreatePackageDependencyModel(
string itemSpec,
bool isResolved,
IImmutableDictionary <string, string> properties,
Func <string, bool>?isEvaluatedItemSpec,
ITargetFramework targetFramework,
[NotNullWhen(returnValue: true)] out PackageDependencyModel?dependencyModel)
{
Requires.NotNullOrEmpty(itemSpec, nameof(itemSpec));
Requires.NotNull(properties, nameof(properties));
bool isImplicitlyDefined = properties.GetBoolProperty(ProjectItemMetadata.IsImplicitlyDefined) ?? false;
if (isResolved)
{
// We have design-time build data
Requires.NotNull(targetFramework, nameof(targetFramework));
Requires.NotNull(isEvaluatedItemSpec !, nameof(isEvaluatedItemSpec));
string?name = properties.GetStringProperty(ProjectItemMetadata.Name);
string?dependencyType = properties.GetStringProperty(ProjectItemMetadata.Type);
if (dependencyType != null)
{
// LEGACY MODE
//
// In 16.7 (SDK 3.1.4xx) the format of ResolvedPackageReference items was changed in task PreprocessPackageDependenciesDesignTime.
//
// If we observe "Type" metadata then we are running with an older SDK and need to preserve some
// legacy behaviour to avoid breaking the dependencies node too much. Transitive dependencies will
// not be displayed, but we should be able to provide an equivalent experience for top-level items.
if (!StringComparers.PropertyLiteralValues.Equals(dependencyType, "Package"))
{
// Legacy behaviour included items of various types. We now only accept "Package".
dependencyModel = null;
return(false);
}
// Legacy behaviour was to return packages for all targets, even though we have a build per-target.
// The package's target was prefixed to its ItemSpec (for example: ".NETFramework,Version=v4.8/MetadataExtractor/2.3.0").
// We would then filter out items for the wrong target here.
//
// From 16.7 we no longer return items from other target frameworks during DTB, and we remove the target prefix from ItemSpec.
//
// This code preserves filtering logic when processing legacy items.
int slashIndex = itemSpec.IndexOf('/');
if (slashIndex != -1)
{
string targetFrameworkName = s_targetFrameworkInternPool.Intern(itemSpec.Substring(0, slashIndex));
if (_targetFrameworkProvider.GetTargetFramework(targetFrameworkName)?.Equals(targetFramework) != true)
{
// Item is not for the correct target
dependencyModel = null;
return(false);
}
}
// Name metadata is required in 16.7. Legacy behaviour uses ItemSpec as a fallback.
name ??= itemSpec;
}
else
{
if (Strings.IsNullOrEmpty(name))
{
// This should not happen as Name is required in PreprocessPackageDependenciesDesignTime from 16.7
dependencyModel = null;
return(false);
}
}
bool isTopLevel = isImplicitlyDefined || isEvaluatedItemSpec(name);
if (!isTopLevel)
{
// We no longer accept non-top-level dependencies from DTB data. See note above about legacy mode support.
dependencyModel = null;
return(false);
}
dependencyModel = new PackageDependencyModel(
originalItemSpec: name,
version: properties.GetStringProperty(ProjectItemMetadata.Version) ?? string.Empty,
isResolved: true,
isImplicitlyDefined,
isVisible: !isImplicitlyDefined,
properties);
}
else
{
// We only have evaluation data
System.Diagnostics.Debug.Assert(itemSpec.IndexOf('/') == -1);
dependencyModel = new PackageDependencyModel(
originalItemSpec: itemSpec,
version: properties.GetStringProperty(ProjectItemMetadata.Version) ?? string.Empty,
isResolved: false,
isImplicitlyDefined,
isVisible: !isImplicitlyDefined,
properties);
}
return(true);
}
private IDependencyModel GetDependencyModel(
string itemSpec,
bool resolved,
IImmutableDictionary <string, string> properties,
IProjectChangeDescription projectChange,
HashSet <string> unresolvedChanges,
ITargetFramework targetFramework)
{
PackageDependencyMetadata metadata;
bool isTopLevel = true;
bool isTarget = false;
if (resolved)
{
metadata = new PackageDependencyMetadata(itemSpec, properties);
isTopLevel = metadata.IsImplicitlyDefined ||
(metadata.DependencyType == DependencyType.Package &&
unresolvedChanges != null &&
unresolvedChanges.Contains(metadata.Name));
isTarget = metadata.IsTarget;
ITargetFramework packageTargetFramework = TargetFrameworkProvider.GetTargetFramework(metadata.Target);
if (!(packageTargetFramework?.Equals(targetFramework) == true))
{
return(null);
}
}
else
{
metadata = CreateUnresolvedMetadata(itemSpec, properties);
}
if (isTarget)
{
return(null);
}
string originalItemSpec = itemSpec;
if (resolved && isTopLevel)
{
originalItemSpec = metadata.Name;
}
IDependencyModel dependencyModel = null;
switch (metadata.DependencyType)
{
case DependencyType.Package:
dependencyModel = new PackageDependencyModel(
ProviderType,
itemSpec,
originalItemSpec,
metadata.Name,
DependencyTreeFlags.NuGetSubTreeNodeFlags,
metadata.Version,
resolved,
metadata.IsImplicitlyDefined,
isTopLevel,
!metadata.IsImplicitlyDefined /*visible*/,
properties,
metadata.DependenciesItemSpecs);
break;
case DependencyType.Assembly:
case DependencyType.FrameworkAssembly:
dependencyModel = new PackageAssemblyDependencyModel(
ProviderType,
itemSpec,
originalItemSpec,
metadata.Name,
DependencyTreeFlags.NuGetSubTreeNodeFlags,
resolved,
properties,
metadata.DependenciesItemSpecs);
break;
case DependencyType.AnalyzerAssembly:
dependencyModel = new PackageAnalyzerAssemblyDependencyModel(
ProviderType,
itemSpec,
originalItemSpec,
metadata.Name,
DependencyTreeFlags.NuGetSubTreeNodeFlags,
resolved,
properties,
metadata.DependenciesItemSpecs);
break;
case DependencyType.Diagnostic:
dependencyModel = new DiagnosticDependencyModel(
ProviderType,
itemSpec,
metadata.Severity,
metadata.DiagnosticCode,
metadata.Name,
DependencyTreeFlags.NuGetSubTreeNodeFlags,
isVisible: true,
properties: properties);
break;
default:
dependencyModel = new PackageUnknownDependencyModel(
ProviderType,
itemSpec,
originalItemSpec,
metadata.Name,
DependencyTreeFlags.NuGetSubTreeNodeFlags,
resolved,
properties,
metadata.DependenciesItemSpecs);
break;
}
return(dependencyModel);
}
