|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Microsoft.TemplateEngine.Abstractions;
using Microsoft.TemplateEngine.Utils;
using System.Text.Json;
using System.Text.Json.Nodes;
namespace Microsoft.TemplateEngine.Cli.Alias
{
internal class AliasRegistry
{
private readonly IEngineEnvironmentSettings _environmentSettings;
private readonly string _aliasesFilePath;
private AliasModel? _aliases;
internal AliasRegistry(IEngineEnvironmentSettings environmentSettings)
{
_environmentSettings = environmentSettings;
_aliasesFilePath = Path.Combine(_environmentSettings.Paths.HostVersionSettingsDir, "aliases.json");
}
internal IReadOnlyDictionary<string, IReadOnlyList<string>> AllAliases
{
get
{
EnsureLoaded();
//ensure loaded sets aliases
return new Dictionary<string, IReadOnlyList<string>>(_aliases!.CommandAliases, StringComparer.OrdinalIgnoreCase);
}
}
internal AliasManipulationResult TryCreateOrRemoveAlias(string aliasName, IReadOnlyList<string> aliasTokens)
{
EnsureLoaded();
if (aliasName == null)
{
// the input was malformed. Alias flag without alias name
return new AliasManipulationResult(AliasManipulationStatus.InvalidInput);
}
else if (aliasTokens.Count == 0)
{
// the command was just "--alias <alias name>"
// remove the alias
//ensure loaded sets aliases
if (_aliases!.TryRemoveCommandAlias(aliasName, out IReadOnlyList<string>? removedAliasTokens))
{
Save();
return new AliasManipulationResult(AliasManipulationStatus.Removed, aliasName, removedAliasTokens);
}
else
{
return new AliasManipulationResult(AliasManipulationStatus.RemoveNonExistentFailed, aliasName, null);
}
}
//ensure loaded sets aliases
Dictionary<string, IReadOnlyList<string>> aliasesWithCandidate = new(_aliases!.CommandAliases);
aliasesWithCandidate[aliasName] = aliasTokens;
if (!TryExpandCommandAliases(aliasesWithCandidate, aliasTokens, out IReadOnlyList<string>? expandedInputTokens))
{
return new AliasManipulationResult(AliasManipulationStatus.WouldCreateCycle, aliasName, aliasTokens);
}
_aliases.AddCommandAlias(aliasName, aliasTokens);
Save();
return new AliasManipulationResult(AliasManipulationStatus.Created, aliasName, aliasTokens);
}
// Attempts to expand aliases on the input string, using the aliases in _aliases
internal bool TryExpandCommandAliases(IReadOnlyList<string> inputTokens, out IReadOnlyList<string> expandedInputTokens)
{
EnsureLoaded();
if (inputTokens.Count == 0)
{
expandedInputTokens = new List<string>(inputTokens);
return true;
}
//ensure loaded sets aliases
if (TryExpandCommandAliases(_aliases!.CommandAliases, inputTokens, out expandedInputTokens!))
{
return true;
}
// TryExpandCommandAliases() returned false because was an expansion error
expandedInputTokens = new List<string>();
return false;
}
private static bool TryExpandCommandAliases(IReadOnlyDictionary<string, IReadOnlyList<string>> aliases, IReadOnlyList<string> inputTokens, out IReadOnlyList<string>? expandedTokens)
{
bool expansionOccurred = false;
HashSet<string> seenAliases = new();
expandedTokens = new List<string>(inputTokens);
do
{
string candidateAliasName = expandedTokens[0];
if (aliases.TryGetValue(candidateAliasName, out IReadOnlyList<string>? aliasExpansion))
{
if (!seenAliases.Add(candidateAliasName))
{
// a cycle has occurred.... not allowed.
expandedTokens = null;
return false;
}
// The expansion is the combination of the aliasExpansion (expands the 0th token of the previously expandedTokens)
// and the rest of the previously expandedTokens
expandedTokens = new CombinedList<string>(aliasExpansion, expandedTokens.ToList().GetRange(1, expandedTokens.Count - 1));
expansionOccurred = true;
}
else
{
expansionOccurred = false;
}
}
while (expansionOccurred);
return true;
}
private void EnsureLoaded()
{
if (_aliases != null)
{
return;
}
if (!_environmentSettings.Host.FileSystem.FileExists(_aliasesFilePath))
{
_aliases = new AliasModel();
return;
}
JsonObject parsed = _environmentSettings.Host.FileSystem.ReadObject(_aliasesFilePath);
IReadOnlyDictionary<string, IReadOnlyList<string>> commandAliases = ToStringListDictionary(parsed, StringComparer.OrdinalIgnoreCase, "CommandAliases");
_aliases = new AliasModel(commandAliases);
}
private void Save()
{
if (_aliases is AliasModel { CommandAliases: { Count: > 0 } })
{
JsonObject root = new();
JsonObject commandAliases = new();
foreach (var kvp in _aliases.CommandAliases)
{
JsonArray arr = new();
foreach (string item in kvp.Value)
{
arr.Add((JsonNode)JsonValue.Create(item)!);
}
commandAliases[kvp.Key] = arr;
}
root["CommandAliases"] = commandAliases;
_environmentSettings.Host.FileSystem.WriteObject(_aliasesFilePath, root);
}
else
{
_environmentSettings.Host.FileSystem.FileDelete(_aliasesFilePath);
}
}
// reads a dictionary whose values can either be string literals, or arrays of strings.
private IReadOnlyDictionary<string, IReadOnlyList<string>> ToStringListDictionary(JsonObject token, StringComparer? comparer = null, string? propertyName = null)
{
Dictionary<string, IReadOnlyList<string>> result = new(comparer ?? StringComparer.Ordinal);
if (propertyName == null)
{
return result;
}
// Case-insensitive property lookup for compatibility with Newtonsoft.Json behavior
JsonNode? element = null;
foreach (var prop in token)
{
if (string.Equals(prop.Key, propertyName, StringComparison.OrdinalIgnoreCase))
{
element = prop.Value;
break;
}
}
if (element is not JsonObject jObj)
{
return result;
}
foreach (KeyValuePair<string, JsonNode?> property in jObj)
{
if (property.Value == null)
{
continue;
}
else if (property.Value.GetValueKind() == JsonValueKind.String)
{
result[property.Key] = new List<string>() { property.Value.GetValue<string>() };
}
else if (property.Value is JsonArray arr)
{
List<string> values = new();
foreach (JsonNode? item in arr)
{
if (item != null && item.GetValueKind() == JsonValueKind.String)
{
values.Add(item.GetValue<string>());
}
}
result[property.Key] = values;
}
}
return result;
}
}
}
|