private void ProcessOptions(IProjectRuleSnapshot snapshot)
{
// We just pass all options to Roslyn
string commandlineArguments = string.Join(" ", snapshot.Items.Keys);
_context.SetOptions(commandlineArguments);
}
private static EnumCollection Transform(IProjectSubscriptionUpdate input)
{
IProjectRuleSnapshot snapshot = input.CurrentState[SupportedTargetFrameworkAlias.SchemaName];
return(snapshot.Items.Select(ToEnumValue)
.ToList());
}
public TestProjectChangeDescription(IProjectRuleSnapshot before, IProjectRuleSnapshot after)
{
Before = before;
After = after;
Difference = Diff.Create(before, after);
}
private string GetUnresolvedReferenceItemType(
string unresolvedItemSpec,
IEnumerable <IProjectRuleSnapshot> unresolvedReferenceSnapshots,
IProjectCatalogSnapshot catalogs,
out IProjectRuleSnapshot unresolvedReferenceSnapshot)
{
Requires.NotNull(unresolvedItemSpec, nameof(unresolvedItemSpec));
Requires.NotNull(unresolvedReferenceSnapshots, nameof(unresolvedReferenceSnapshots));
Requires.NotNull(catalogs, nameof(catalogs));
unresolvedReferenceSnapshot = null;
foreach (var referenceSnapshot in unresolvedReferenceSnapshots)
{
if (referenceSnapshot.Items.ContainsKey(unresolvedItemSpec))
{
var itemType = GetItemTypeFromRuleName(referenceSnapshot.RuleName, catalogs, true);
if (itemType != null)
{
unresolvedReferenceSnapshot = referenceSnapshot;
return(itemType);
}
}
}
return(null);
}
private void ProcessOptions(IProjectRuleSnapshot snapshot)
{
Assumes.NotNull(_context);
// We just pass all options to Roslyn
_context.SetOptions(snapshot.Items.Keys.ToImmutableArray());
}
private ISet <WorkloadDescriptor> CreateWorkloadDescriptor(IImmutableDictionary <string, IProjectRuleSnapshot> currentState)
{
IProjectRuleSnapshot suggestedWorkloads = currentState.GetSnapshotOrEmpty(SuggestedWorkload.SchemaName);
if (suggestedWorkloads.Items.Count == 0)
{
return(ImmutableHashSet <WorkloadDescriptor> .Empty);
}
var workloadDescriptors = suggestedWorkloads.Items.Select(item =>
{
string workloadName = item.Key;
if (!string.IsNullOrWhiteSpace(workloadName) &&
(item.Value.TryGetStringProperty(SuggestedWorkload.VisualStudioComponentIdsProperty, out string?vsComponentIds) ||
item.Value.TryGetStringProperty(SuggestedWorkload.VisualStudioComponentIdProperty, out vsComponentIds)))
{
return(new WorkloadDescriptor(workloadName, vsComponentIds));
}
return(WorkloadDescriptor.Empty);
});
return(new HashSet <WorkloadDescriptor>(workloadDescriptors));
}
public static IProjectChangeDescription Implement(IProjectRuleSnapshot after = null,
IProjectRuleSnapshot before = null,
IProjectChangeDiff difference = null,
MockBehavior?mockBehavior = null)
{
var behavior = mockBehavior ?? MockBehavior.Default;
var mock = new Mock <IProjectChangeDescription>(behavior);
if (after != null)
{
mock.Setup(x => x.After).Returns(after);
}
if (before != null)
{
mock.Setup(x => x.Before).Returns(before);
}
if (difference != null)
{
mock.Setup(x => x.Difference).Returns(difference);
}
return(mock.Object);
}
/// <summary>
/// Converts an immutable dictionary of rule snapshot data into an <see cref="IVsProjectRestoreInfo"/> instance.
/// </summary>
public static ProjectRestoreInfo ToProjectRestoreInfo(IImmutableDictionary <string, IProjectRuleSnapshot> update)
{
IImmutableDictionary <string, string> properties = update.GetSnapshotOrEmpty(NuGetRestore.SchemaName).Properties;
IProjectRuleSnapshot frameworkReferences = update.GetSnapshotOrEmpty(CollectedFrameworkReference.SchemaName);
IProjectRuleSnapshot packageDownloads = update.GetSnapshotOrEmpty(CollectedPackageDownload.SchemaName);
IProjectRuleSnapshot projectReferences = update.GetSnapshotOrEmpty(ProjectReference.SchemaName);
IProjectRuleSnapshot packageReferences = update.GetSnapshotOrEmpty(PackageReference.SchemaName);
IProjectRuleSnapshot toolReferences = update.GetSnapshotOrEmpty(DotNetCliToolReference.SchemaName);
// For certain project types such as UWP, "TargetFrameworkMoniker" != the moniker that restore uses
string targetMoniker = properties.GetPropertyOrEmpty(NuGetRestore.NuGetTargetMonikerProperty);
if (targetMoniker.Length == 0)
{
targetMoniker = properties.GetPropertyOrEmpty(NuGetRestore.TargetFrameworkMonikerProperty);
}
IVsTargetFrameworkInfo2 frameworkInfo = new TargetFrameworkInfo(
targetMoniker,
ToReferenceItems(frameworkReferences.Items),
ToReferenceItems(packageDownloads.Items),
ToReferenceItems(projectReferences.Items),
ToReferenceItems(packageReferences.Items),
ToProjectProperties(properties));
return(new ProjectRestoreInfo(
properties.GetPropertyOrEmpty(NuGetRestore.MSBuildProjectExtensionsPathProperty),
properties.GetPropertyOrEmpty(NuGetRestore.ProjectAssetsFileProperty),
properties.GetPropertyOrEmpty(NuGetRestore.TargetFrameworksProperty),
new TargetFrameworks(new[] { frameworkInfo }),
ToReferenceItems(toolReferences.Items)));
}
private IDependencyModel CreateDependencyModelForRule(
string itemSpec,
bool resolved,
IProjectRuleSnapshot projectRuleSnapshot,
ITargetFramework targetFramework)
{
var properties = GetProjectItemProperties(projectRuleSnapshot, itemSpec);
var originalItemSpec = itemSpec;
if (resolved)
{
originalItemSpec = GetOriginalItemSpec(properties);
}
var isImplicit = false;
if (properties != null &&
properties.TryGetValue(ProjectItemMetadata.IsImplicitlyDefined, out string isImplicitlyDefinedString) &&
bool.TryParse(isImplicitlyDefinedString, out bool isImplicitlyDefined))
{
isImplicit = isImplicitlyDefined;
}
return(CreateDependencyModel(
ProviderType,
itemSpec,
originalItemSpec,
resolved,
isImplicit,
properties));
}
/// <summary>
/// Converts an immutable dictionary of rule snapshot data into an <see cref="IVsProjectRestoreInfo"/> instance.
/// </summary>
public static IVsProjectRestoreInfo2 ToProjectRestoreInfo(IImmutableDictionary <string, IProjectRuleSnapshot> update)
{
Requires.NotNull(update, nameof(update));
IImmutableDictionary <string, string> properties = update.GetSnapshotOrEmpty(NuGetRestore.SchemaName).Properties;
IProjectRuleSnapshot frameworkReferences = update.GetSnapshotOrEmpty(CollectedFrameworkReference.SchemaName);
IProjectRuleSnapshot packageDownloads = update.GetSnapshotOrEmpty(CollectedPackageDownload.SchemaName);
IProjectRuleSnapshot projectReferences = update.GetSnapshotOrEmpty(ProjectReference.SchemaName);
IProjectRuleSnapshot packageReferences = update.GetSnapshotOrEmpty(PackageReference.SchemaName);
IProjectRuleSnapshot toolReferences = update.GetSnapshotOrEmpty(DotNetCliToolReference.SchemaName);
IVsTargetFrameworkInfo2 frameworkInfo = new TargetFrameworkInfo(
properties.GetPropertyOrEmpty(NuGetRestore.TargetFrameworkMonikerProperty),
ToReferenceItems(frameworkReferences.Items),
ToReferenceItems(packageDownloads.Items),
ToReferenceItems(projectReferences.Items),
ToReferenceItems(packageReferences.Items),
ToProjectProperties(properties));
return(new ProjectRestoreInfo(
properties.GetPropertyOrEmpty(NuGetRestore.MSBuildProjectExtensionsPathProperty),
properties.GetPropertyOrEmpty(NuGetRestore.TargetFrameworksProperty),
new TargetFrameworks(new[] { frameworkInfo }),
ToReferenceItems(toolReferences.Items)));
}
private IDependencyModel?CreateDependencyModelForRule(string itemSpec, IProjectRuleSnapshot evaluationRuleSnapshot, IProjectRuleSnapshot updatedRuleSnapshot, bool isResolved, string projectFullPath)
{
IImmutableDictionary <string, string>?properties = updatedRuleSnapshot.GetProjectItemProperties(itemSpec);
Assumes.NotNull(properties);
string originalItemSpec = isResolved
? properties.GetStringProperty(ProjectItemMetadata.OriginalItemSpec) ?? itemSpec
: itemSpec;
IImmutableDictionary <string, string>?evaluationProperties = evaluationRuleSnapshot.GetProjectItemProperties(originalItemSpec);
if (evaluationProperties == null)
{
if (ResolvedItemRequiresEvaluatedItem)
{
// This item is present in build results, but not in evaluation.
return(null);
}
evaluationProperties = properties;
}
bool isImplicit = IsImplicit(projectFullPath, evaluationProperties);
return(CreateDependencyModel(
itemSpec,
originalItemSpec,
isResolved,
isImplicit,
properties));
}
private void ProcessProjectBuildFailure(IProjectRuleSnapshot snapshot)
{
// If 'CompileDesignTime' didn't run due to a preceding failed target, or a failure in itself, IsEvaluationSucceeded returns false.
//
// We still forward those 'removes' of references, sources, etc onto Roslyn to avoid duplicate/incorrect results when the next
// successful build occurs, because it will be diff between it and this failed build.
_context.LastDesignTimeBuildSucceeded = snapshot.IsEvaluationSucceeded();
}
private async Task <ProjectContextInitData> GetProjectContextInitDataAsync(ConfiguredProject project)
{
Guid projectGuid = await _projectGuidService.GetProjectGuidAsync();
IProjectRuleSnapshot snapshot = await GetLatestSnapshotAsync(project);
return(ProjectContextInitData.GetProjectContextInitData(snapshot, projectGuid, project.ProjectConfiguration));
}
/// <summary>
/// Finds the resolved reference item for a given unresolved reference.
/// </summary>
/// <param name="projectRuleSnapshot">Resolved reference project items snapshot to search.</param>
/// <param name="itemSpec">The unresolved reference item name.</param>
/// <returns>The key is item name and the value is the metadata dictionary.</returns>
public static IImmutableDictionary <string, string> GetProjectItemProperties(this IProjectRuleSnapshot projectRuleSnapshot, string itemSpec)
{
Requires.NotNull(projectRuleSnapshot, nameof(projectRuleSnapshot));
Requires.NotNullOrEmpty(itemSpec, nameof(itemSpec));
return(projectRuleSnapshot.Items.TryGetValue(itemSpec, out IImmutableDictionary <string, string> properties)
? properties
: null);
}
public static Diff Create(IProjectRuleSnapshot before, IProjectRuleSnapshot after)
{
var addedItems = new HashSet <string>(after.Items.Keys);
addedItems.ExceptWith(before.Items.Keys);
var removedItems = new HashSet <string>(before.Items.Keys);
removedItems.ExceptWith(after.Items.Keys);
// changed items must be present in both sets, but have different properties.
var changedItems = new HashSet <string>(before.Items.Keys);
changedItems.IntersectWith(after.Items.Keys);
changedItems.RemoveWhere(key =>
{
var x = before.Items[key];
var y = after.Items[key];
if (x.Count != y.Count)
{
return(true);
}
foreach (var kvp in x)
{
if (!y.Contains(kvp))
{
return(true);
}
}
return(false);
});
var changedProperties = new HashSet <string>(before.Properties.Keys);
changedProperties.RemoveWhere(key =>
{
var x = before.Properties[key];
var y = after.Properties[key];
return(object.Equals(x, y));
});
return(new Diff()
{
AddedItems = addedItems.ToImmutableHashSet(),
RemovedItems = removedItems.ToImmutableHashSet(),
ChangedItems = changedItems.ToImmutableHashSet(),
// We ignore renamed items.
RenamedItems = ImmutableDictionary <string, string> .Empty,
ChangedProperties = changedProperties.ToImmutableHashSet(),
});
}
public static IProjectRuleSnapshot Add(this IProjectRuleSnapshot snapshot, string propertyName, string propertyValue)
{
var mock = Mock.Get(snapshot);
var dictionary = snapshot.Properties.Add(propertyName, propertyValue);
mock.SetupGet(r => r.Properties)
.Returns(dictionary);
return(mock.Object);
}
public static ProjectContextInitData GetProjectContextInitData(IProjectRuleSnapshot snapshot, Guid projectGuid, ProjectConfiguration configuration)
{
var data = new ProjectContextInitData();
snapshot.Properties.TryGetValue(ConfigurationGeneral.LanguageServiceNameProperty, out data.LanguageName);
snapshot.Properties.TryGetValue(ConfigurationGeneral.TargetPathProperty, out data.BinOutputPath);
snapshot.Properties.TryGetValue(ConfigurationGeneral.MSBuildProjectFullPathProperty, out data.ProjectFilePath);
data.ProjectGuid = projectGuid;
data.WorkspaceProjectContextId = GetWorkspaceProjectContextId(data.ProjectFilePath, projectGuid, configuration);
return(data);
}
private FileWatchData CreateFileWatch(IImmutableDictionary <string, IProjectRuleSnapshot> update)
{
IProjectRuleSnapshot snapshot = update.GetSnapshotOrEmpty(ItemSchemaName);
var fullPaths = snapshot.Items.Select(item => item.Value.GetValueOrDefault(Compile.FullPathProperty))
.Where(item => item != null)
.ToImmutableList();
return(new FileWatchData(
this,
fullPaths,
FileWatchChangeKinds));
}
protected override EnumCollection Transform(IProjectSubscriptionUpdate input)
{
IProjectRuleSnapshot?configurationGeneral = input.CurrentState[ConfigurationGeneral.SchemaName];
string?targetFrameworkIdentifier = configurationGeneral.Properties[ConfigurationGeneral.TargetFrameworkIdentifierProperty];
string ruleName;
if (StringComparers.FrameworkIdentifiers.Equals(targetFrameworkIdentifier, TargetFrameworkIdentifiers.NetCoreApp))
{
ruleName = SupportedNETCoreAppTargetFramework.SchemaName;
}
else if (StringComparers.FrameworkIdentifiers.Equals(targetFrameworkIdentifier, TargetFrameworkIdentifiers.NetFramework))
{
ruleName = SupportedNETFrameworkTargetFramework.SchemaName;
}
else if (StringComparers.FrameworkIdentifiers.Equals(targetFrameworkIdentifier, TargetFrameworkIdentifiers.NetStandard))
{
ruleName = SupportedNETStandardTargetFramework.SchemaName;
}
else
{
string?storedTargetFramework = configurationGeneral.Properties[ConfigurationGeneral.TargetFrameworkProperty];
string?storedTargetFrameworkIdentifier = configurationGeneral.Properties[ConfigurationGeneral.TargetFrameworkIdentifierProperty];
string?storedTargetFrameworkMoniker = configurationGeneral.Properties[ConfigurationGeneral.TargetFrameworkMonikerProperty];
var result = new List <IEnumValue>();
// This is the case where the TargetFrameworkProperty has a value we recognize but it's not in the supported lists the SDK sends us.
// We decided we will show it in the UI.
if (!Strings.IsNullOrEmpty(storedTargetFramework))
{
result.Add(new PageEnumValue(new EnumValue
{
Name = (!Strings.IsNullOrEmpty(storedTargetFrameworkMoniker))? storedTargetFrameworkMoniker : storedTargetFramework,
DisplayName = (!Strings.IsNullOrEmpty(storedTargetFrameworkIdentifier)) ? storedTargetFrameworkIdentifier : storedTargetFramework
}));
}
return(result);
}
IProjectRuleSnapshot snapshot = input.CurrentState[ruleName];
int capacity = snapshot.Items.Count;
var list = new List <IEnumValue>(capacity);
list.AddRange(snapshot.Items.Select(ToEnumValue));
list.Sort(SortValues); // TODO: This is a hotfix for item ordering. Remove this when completing: https://github.com/dotnet/project-system/issues/7025
return(list);
}
private void ProcessProjectBuildFailure(IProjectRuleSnapshot snapshot)
{
// If 'CompileDesignTime' didn't run due to a preceding failed target, or a failure in itself, IsEvaluationSucceeded returns false.
//
// We still forward those 'removes' of references, sources, etc onto Roslyn to avoid duplicate/incorrect results when the next
// successful build occurs, because it will be diff between it and this failed build.
bool succeeded = snapshot.IsEvaluationSucceeded();
if (_context.LastDesignTimeBuildSucceeded != succeeded)
{
_logger.WriteLine(succeeded ? "Last design-time build succeeded, turning semantic errors back on." : "Last design-time build failed, turning semantic errors off.");
_context.LastDesignTimeBuildSucceeded = succeeded;
}
}
private IDependencyModel CreateDependencyModelForRule(string itemSpec, IProjectRuleSnapshot projectRuleSnapshot, bool isResolved)
{
IImmutableDictionary <string, string> properties = projectRuleSnapshot.GetProjectItemProperties(itemSpec) !;
string originalItemSpec = isResolved
? properties.GetStringProperty(ProjectItemMetadata.OriginalItemSpec) ?? itemSpec
: itemSpec;
bool isImplicit = properties.GetBoolProperty(ProjectItemMetadata.IsImplicitlyDefined) ?? false;
return(CreateDependencyModel(
itemSpec,
originalItemSpec,
isResolved,
isImplicit,
properties));
}
private static string ResolveFallbackIntermediateOutputPath(IProjectRuleSnapshot rule, string intermediateOutputPathValue)
{
if (!rule.Properties.TryGetValue(MSBuildProjectDirectoryPropertyName, out var projectDirectory))
{
// Can't resolve the project, bail.
return(null);
}
var joinedPath = Path.Combine(projectDirectory, intermediateOutputPathValue);
if (!Directory.Exists(joinedPath))
{
return(null);
}
return(joinedPath);
}
protected virtual void HandleAddedItem(
string projectFullPath,
string addedItem,
bool resolved,
IProjectChangeDescription projectChange,
IProjectRuleSnapshot evaluationRuleSnapshot,
DependenciesChangesBuilder changesBuilder,
TargetFramework targetFramework,
Func <string, bool>?isEvaluatedItemSpec)
{
IDependencyModel?model = CreateDependencyModelForRule(addedItem, evaluationRuleSnapshot, projectChange.After, resolved, projectFullPath);
if (model != null && (isEvaluatedItemSpec == null || isEvaluatedItemSpec(model.Id)))
{
changesBuilder.Added(model);
}
}
/// <summary>
/// Finds the resolved reference item for a given unresolved reference.
/// </summary>
/// <param name="projectRuleSnapshot">Resolved reference project items snapshot to search.</param>
/// <param name="unresolvedItemSpec">The unresolved reference item name.</param>
/// <returns>The key is item name and the value is the metadata dictionary.</returns>
protected static IImmutableDictionary <string, string> GetProjectItemProperties(
IProjectRuleSnapshot projectRuleSnapshot,
string unresolvedItemSpec)
{
Contract.Requires(projectRuleSnapshot != null);
Contract.Requires(!string.IsNullOrEmpty(unresolvedItemSpec));
foreach (var item in projectRuleSnapshot.Items)
{
string originalItemSpec = item.Key;
if (string.Equals(originalItemSpec, unresolvedItemSpec, StringComparison.OrdinalIgnoreCase))
{
return(item.Value);
}
}
return(null);
}
protected virtual void HandleRemovedItem(
string projectFullPath,
string removedItem,
bool resolved,
IProjectChangeDescription projectChange,
IProjectRuleSnapshot evaluationRuleSnapshot,
DependenciesChangesBuilder changesBuilder,
TargetFramework targetFramework,
Func <string, bool>?isEvaluatedItemSpec)
{
string dependencyId = resolved
? projectChange.Before.GetProjectItemProperties(removedItem) !.GetStringProperty(ProjectItemMetadata.OriginalItemSpec) ?? removedItem
: removedItem;
if (isEvaluatedItemSpec == null || isEvaluatedItemSpec(dependencyId))
{
changesBuilder.Removed(ProviderType, removedItem);
}
}
private IDependencyModel?CreateDependencyModelForRule(
string itemSpec,
IProjectRuleSnapshot evaluationRuleSnapshot,
IProjectRuleSnapshot updatedRuleSnapshot,
bool isResolved,
DependenciesChangesBuilder changesBuilder,
TargetFramework targetFramework,
string projectFullPath)
{
IImmutableDictionary <string, string>?properties = updatedRuleSnapshot.GetProjectItemProperties(itemSpec);
Assumes.NotNull(properties);
string originalItemSpec = isResolved
? properties.GetStringProperty(ProjectItemMetadata.OriginalItemSpec) ?? itemSpec
: itemSpec;
IImmutableDictionary <string, string>?evaluationProperties = evaluationRuleSnapshot.GetProjectItemProperties(originalItemSpec);
if (evaluationProperties == null)
{
if (ResolvedItemRequiresEvaluatedItem)
{
// This item is present in build results, but not in evaluation.
return(null);
}
evaluationProperties = properties;
}
bool isImplicit = IsImplicit(projectFullPath, evaluationProperties);
// When we only have evaluation data, mark the dependency as resolved if we currently have a corresponding resolved item
isResolved = isResolved || changesBuilder.HasResolvedItem(targetFramework, ProviderType, originalItemSpec);
return(CreateDependencyModel(
itemSpec,
originalItemSpec,
isResolved,
isImplicit,
properties));
}
private IDependencyModel CreateDependencyModelForRule(string itemSpec, IProjectRuleSnapshot projectRuleSnapshot, bool isResolved)
{
IImmutableDictionary <string, string> properties = projectRuleSnapshot.GetProjectItemProperties(itemSpec) !;
string originalItemSpec = isResolved
? properties.GetStringProperty(ProjectItemMetadata.OriginalItemSpec) ?? itemSpec
: itemSpec;
// NOTE the SDK only sets this for a default set of implicit dependencies. At this point, this data
// does not reflect implicit dependencies brought in by imported project files. That behaviour is
// added by ImplicitDependenciesSnapshotFilter.
bool isImplicit = properties.GetBoolProperty(ProjectItemMetadata.IsImplicitlyDefined) ?? false;
return(CreateDependencyModel(
itemSpec,
originalItemSpec,
isResolved,
isImplicit,
properties));
}
protected override EnumCollection Transform(IProjectSubscriptionUpdate input)
{
IProjectRuleSnapshot snapshot = input.CurrentState[_ruleName];
int capacity = snapshot.Items.Count + (_useNoneValue ? 1 : 0);
var list = new List <IEnumValue>(capacity);
if (_useNoneValue)
{
list.Add(new PageEnumValue(new EnumValue
{
Name = string.Empty,
DisplayName = Resources.Property_NoneValue
}));
}
list.AddRange(snapshot.Items.Select(ToEnumValue));
list.Sort(SortValues); // TODO: This is a hotfix for item ordering. Remove this when completing: https://github.com/dotnet/project-system/issues/7025
return(list);
}
protected virtual void HandleChangedItem(
string projectFullPath,
string changedItem,
bool resolved,
IProjectChangeDescription projectChange,
IProjectRuleSnapshot evaluationRuleSnapshot,
DependenciesChangesBuilder changesBuilder,
TargetFramework targetFramework,
Func <string, bool>?isEvaluatedItemSpec)
{
IDependencyModel?model = CreateDependencyModelForRule(changedItem, evaluationRuleSnapshot, projectChange.After, resolved, projectFullPath);
if (model != null && (isEvaluatedItemSpec == null || isEvaluatedItemSpec(model.Id)))
{
// For changes we try to add new dependency. If it is a resolved dependency, it would just override
// old one with new properties. If it is unresolved dependency, it would be added only when there is
// no resolved version in the snapshot (due to UnresolvedDependenciesSnapshotFilter).
changesBuilder.Added(model);
}
}
private HostDocument[] GetCurrentDocuments(IProjectSubscriptionUpdate update)
{
IProjectRuleSnapshot rule = null;
var documents = new List <HostDocument>();
if (update.CurrentState.TryGetValue(Rules.RazorComponentWithTargetPath.SchemaName, out rule))
{
foreach (var kvp in rule.Items)
{
if (kvp.Value.TryGetValue(Rules.RazorComponentWithTargetPath.TargetPathProperty, out var targetPath) &&
!string.IsNullOrWhiteSpace(kvp.Key) &&
!string.IsNullOrWhiteSpace(targetPath))
{
var filePath = CommonServices.UnconfiguredProject.MakeRooted(kvp.Key);
var fileKind = FileKinds.GetComponentFileKindFromFilePath(filePath);
documents.Add(new HostDocument(filePath, targetPath, fileKind));
}
}
}
if (update.CurrentState.TryGetValue(Rules.RazorGenerateWithTargetPath.SchemaName, out rule))
{
foreach (var kvp in rule.Items)
{
if (kvp.Value.TryGetValue(Rules.RazorGenerateWithTargetPath.TargetPathProperty, out var targetPath) &&
!string.IsNullOrWhiteSpace(kvp.Key) &&
!string.IsNullOrWhiteSpace(targetPath))
{
var filePath = CommonServices.UnconfiguredProject.MakeRooted(kvp.Key);
documents.Add(new HostDocument(filePath, targetPath, FileKinds.Legacy));
}
}
}
return(documents.ToArray());
}
