File: Commands\NewCommand.Legacy.cs
Web Access
Project: ..\..\..\src\Cli\Microsoft.TemplateEngine.Cli\Microsoft.TemplateEngine.Cli.csproj (Microsoft.TemplateEngine.Cli)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.CommandLine;
using System.CommandLine.Parsing;
using Microsoft.TemplateEngine.Abstractions;
 
namespace Microsoft.TemplateEngine.Cli.Commands
{
    internal partial class NewCommand : BaseCommand<NewCommandArgs>
    {
        private static readonly IReadOnlyList<FilterOptionDefinition> LegacyFilterDefinitions = new List<FilterOptionDefinition>()
        {
            FilterOptionDefinition.AuthorFilter,
            FilterOptionDefinition.BaselineFilter,
            FilterOptionDefinition.LanguageFilter,
            FilterOptionDefinition.TypeFilter,
            FilterOptionDefinition.TagFilter,
            FilterOptionDefinition.PackageFilter
        };
 
        internal IEnumerable<Option> LegacyOptions
        {
            get
            {
                yield return InteractiveOption;
                yield return AddSourceOption;
                yield return ColumnsAllOption;
                yield return ColumnsOption;
                foreach (Option filter in LegacyFilters.Values)
                {
                    yield return filter;
                }
            }
        }
 
        internal Option<bool> InteractiveOption { get; } = SharedOptionsFactory.CreateInteractiveOption().AsHidden();
 
        internal Option<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption().AsHidden().DisableAllowMultipleArgumentsPerToken();
 
        internal Option<bool> ColumnsAllOption { get; } = SharedOptionsFactory.CreateColumnsAllOption().AsHidden();
 
        internal Option<string[]> ColumnsOption { get; } = SharedOptionsFactory.CreateColumnsOption().AsHidden().DisableAllowMultipleArgumentsPerToken();
 
        internal IReadOnlyDictionary<FilterOptionDefinition, Option> LegacyFilters { get; private set; } = new Dictionary<FilterOptionDefinition, Option>();
 
        internal void AddNoLegacyUsageValidators(Command command, params Symbol[] except)
        {
            IEnumerable<Option> optionsToVerify = LegacyFilters.Values.Concat(new Option[] { ColumnsAllOption, ColumnsOption, InteractiveOption, AddSourceOption });
            IEnumerable<Argument> argumentsToVerify = new Argument[] { ShortNameArgument, RemainingArguments };
 
            foreach (Option option in optionsToVerify)
            {
                if (!except.Contains(option))
                {
                    command.Validators.Add(symbolResult => ValidateOptionUsage(symbolResult, option));
                }
            }
 
            foreach (Argument argument in argumentsToVerify)
            {
                if (!except.Contains(argument))
                {
                    command.Validators.Add(symbolResult => ValidateArgumentUsage(symbolResult, argument));
                }
            }
        }
 
        internal void ValidateShortNameArgumentIsNotUsed(CommandResult commandResult)
        {
            ValidateArgumentUsage(commandResult, ShortNameArgument);
        }
 
        internal void ValidateArgumentsAreNotUsed(CommandResult commandResult)
        {
            ValidateArgumentUsage(commandResult, ShortNameArgument, RemainingArguments);
        }
 
        internal void ValidateOptionUsage(CommandResult commandResult, Option option)
        {
            if (commandResult.Parent is not CommandResult parentResult)
            {
                return;
            }
 
            OptionResult? optionResult = parentResult.Children.OfType<OptionResult>().FirstOrDefault(result => result.Option == option);
            if (optionResult != null)
            {
                List<string> wrongTokens = new();
                if (optionResult.IdentifierToken is { } && !string.IsNullOrWhiteSpace(optionResult.IdentifierToken.Value))
                {
                    wrongTokens.Add($"'{optionResult.IdentifierToken.Value}'");
                }
                foreach (var token in optionResult.Tokens)
                {
                    if (token is { } t && !string.IsNullOrWhiteSpace(t.Value))
                    {
                        wrongTokens.Add($"'{t.Value}'");
                    }
                }
                //Unrecognized command or argument(s): {0}
                commandResult.AddError(string.Format(LocalizableStrings.Commands_Validator_WrongTokens, string.Join(",", wrongTokens)));
            }
        }
 
        private static void ValidateArgumentUsage(CommandResult commandResult, params Argument[] arguments)
        {
            if (commandResult.Parent is not CommandResult parentResult)
            {
                return;
            }
 
            List<string> wrongTokens = new();
            foreach (Argument argument in arguments)
            {
                var newCommandArgument = parentResult.Children.OfType<ArgumentResult>().FirstOrDefault(result => result.Argument == argument);
                if (newCommandArgument == null)
                {
                    continue;
                }
                foreach (var token in newCommandArgument.Tokens)
                {
                    if (!string.IsNullOrWhiteSpace(token.Value))
                    {
                        wrongTokens.Add($"'{token.Value}'");
                    }
                }
            }
            if (wrongTokens.Any())
            {
                //Unrecognized command or argument(s): {0}
                commandResult.AddError(string.Format(LocalizableStrings.Commands_Validator_WrongTokens, string.Join(",", wrongTokens)));
            }
        }
 
        private void BuildLegacySymbols(Func<ParseResult, ITemplateEngineHost> hostBuilder)
        {
            Arguments.Add(ShortNameArgument);
            Arguments.Add(RemainingArguments);
 
            //legacy options
            Dictionary<FilterOptionDefinition, Option> options = new();
            foreach (var filterDef in LegacyFilterDefinitions)
            {
                options[filterDef] = filterDef.OptionFactory().AsHidden();
                Options.Add(options[filterDef]);
            }
            LegacyFilters = options;
 
            Options.Add(InteractiveOption);
            Options.Add(AddSourceOption);
            Options.Add(ColumnsAllOption);
            Options.Add(ColumnsOption);
 
            TreatUnmatchedTokensAsErrors = true;
 
            Add(new LegacyInstallCommand(this, hostBuilder));
            Add(new LegacyUninstallCommand(this, hostBuilder));
            Add(new LegacyUpdateCheckCommand(this, hostBuilder));
            Add(new LegacyUpdateApplyCommand(this, hostBuilder));
            Add(new LegacySearchCommand(this, hostBuilder));
            Add(new LegacyListCommand(this, hostBuilder));
            Add(new LegacyAliasAddCommand(hostBuilder));
            Add(new LegacyAliasShowCommand(hostBuilder));
        }
    }
}