[system-command-line] instantiate logic

src/Microsoft.TemplateEngine.Cli/CliTemplateInfo.cs

@@ -0,0 +1,108 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using Microsoft.TemplateEngine.Abstractions;
+
+namespace Microsoft.TemplateEngine.Cli
+{
+    /// <summary>
+    /// <see cref="ITemplateInfo"/> + <see cref="HostSpecificTemplateData"/>.
+    /// </summary>
+    internal class CliTemplateInfo : ITemplateInfo
+    {
+        private readonly ITemplateInfo _templateInfo;
+        private readonly HostSpecificTemplateData _cliData;
+
+        internal CliTemplateInfo(ITemplateInfo templateInfo, HostSpecificTemplateData cliData)
+        {
+            _templateInfo = templateInfo ?? throw new ArgumentNullException(nameof(templateInfo));
+            _cliData = cliData ?? throw new ArgumentNullException(nameof(cliData));
+        }
+
+        public string? Author => _templateInfo.Author;
+
+        public string? Description => _templateInfo.Description;
+
+        public IReadOnlyList<string> Classifications => _templateInfo.Classifications;
+
+        public string? DefaultName => _templateInfo.DefaultName;
+
+        public string Identity => _templateInfo.Identity;
+
+        public Guid GeneratorId => _templateInfo.GeneratorId;
+
+        public string? GroupIdentity => _templateInfo.GroupIdentity;
+
+        public int Precedence => _templateInfo.Precedence;
+
+        public string Name => _templateInfo.Name;
+
+        [Obsolete]
+        public string ShortName => _templateInfo.ShortName;
+
+        [Obsolete]
+        public IReadOnlyDictionary<string, ICacheTag> Tags => _templateInfo.Tags;
+
+        public IReadOnlyDictionary<string, string> TagsCollection => _templateInfo.TagsCollection;
+
+        [Obsolete]
+        public IReadOnlyDictionary<string, ICacheParameter> CacheParameters => _templateInfo.CacheParameters;
+
+        public IReadOnlyList<ITemplateParameter> Parameters => _templateInfo.Parameters;
+
+        public string MountPointUri => _templateInfo.MountPointUri;
+
+        public string ConfigPlace => _templateInfo.ConfigPlace;
+
+        public string? LocaleConfigPlace => _templateInfo.LocaleConfigPlace;
+
+        public string? HostConfigPlace => _templateInfo.HostConfigPlace;
+
+        public string? ThirdPartyNotices => _templateInfo.ThirdPartyNotices;
+
+        public IReadOnlyDictionary<string, IBaselineInfo> BaselineInfo => _templateInfo.BaselineInfo;
+
+        [Obsolete]
+        public bool HasScriptRunningPostActions { get => _templateInfo.HasScriptRunningPostActions; set => _templateInfo.HasScriptRunningPostActions = value; }
+
+        public IReadOnlyList<string> ShortNameList => _templateInfo.ShortNameList;
+
+        internal HostSpecificTemplateData CliData => _cliData;
+
+        internal bool IsHidden => _cliData.IsHidden;
+
+        internal static IEnumerable<CliTemplateInfo> FromTemplateInfo(IEnumerable<ITemplateInfo> templateInfos, IHostSpecificDataLoader hostSpecificDataLoader)
+        {
+            if (templateInfos is null)
+            {
+                throw new ArgumentNullException(nameof(templateInfos));
+            }
+
+            if (hostSpecificDataLoader is null)
+            {
+                throw new ArgumentNullException(nameof(hostSpecificDataLoader));
+            }
+
+            return templateInfos.Select(templateInfo => new CliTemplateInfo(templateInfo, hostSpecificDataLoader.ReadHostSpecificTemplateData(templateInfo)));
+        }
+
+        internal IEnumerable<CliTemplateParameter> GetParameters()
+        {
+            HashSet<string> processedParameters = new HashSet<string>();
+            List<CliTemplateParameter> parameters = new List<CliTemplateParameter>();
+
+            foreach (ITemplateParameter parameter in Parameters.Where(param => param.Type == "parameter"))
+            {
+                if (!processedParameters.Add(parameter.Name))
+                {
+                    //TODO:
+                    throw new Exception($"Template {Identity} defines {parameter.Name} twice.");
+                }
+                parameters.Add(new CliTemplateParameter(parameter, CliData));
+            }
+            return parameters;
+        }
+    }
+}

src/Microsoft.TemplateEngine.Cli/CliTemplateParameter.cs

@@ -0,0 +1,107 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using Microsoft.TemplateEngine.Abstractions;
+
+namespace Microsoft.TemplateEngine.Cli
+{
+    internal enum ParameterType
+    {
+        Boolean,
+        Choice,
+        Float,
+        Integer,
+        Hex,
+        String
+    }
+
+    internal class CliTemplateParameter
+    {
+        private List<string> _shortNameOverrides = new List<string>();
+
+        private List<string> _longNameOverrides = new List<string>();
+
+        private Dictionary<string, ParameterChoice> _choices = new Dictionary<string, ParameterChoice>(StringComparer.OrdinalIgnoreCase);
+
+        internal CliTemplateParameter(ITemplateParameter parameter, HostSpecificTemplateData data)
+        {
+            Name = parameter.Name;
+            Description = parameter.Description ?? string.Empty;
+            Type = ParseType(parameter.DataType);
+            DefaultValue = parameter.DefaultValue;
+            DefaultIfOptionWithoutValue = parameter.DefaultIfOptionWithoutValue ?? string.Empty;
+            IsRequired = parameter.Priority == TemplateParameterPriority.Required && parameter.DefaultValue == null;
+            IsHidden = parameter.Priority == TemplateParameterPriority.Implicit || data.HiddenParameterNames.Contains(parameter.Name);
+
+            if (parameter.Choices != null)
+            {
+                _choices = parameter.Choices.ToDictionary(kvp => kvp.Key, kvp => kvp.Value, StringComparer.OrdinalIgnoreCase);
+            }
+            if (data.ShortNameOverrides.ContainsKey(parameter.Name))
+            {
+                _shortNameOverrides.Add(data.ShortNameOverrides[parameter.Name]);
+            }
+            if (data.LongNameOverrides.ContainsKey(parameter.Name))
+            {
+                _longNameOverrides.Add(data.LongNameOverrides[parameter.Name]);
+            }
+        }
+
+        /// <summary>
+        /// Unit test constructor.
+        /// </summary>
+        internal CliTemplateParameter(
+            string name,
+            ParameterType type = ParameterType.String,
+            IEnumerable<string>? shortNameOverrides = null,
+            IEnumerable<string>? longNameOverrides = null,
+            int precedence = 0)
+        {
+            Name = name;
+            Type = type;
+            _shortNameOverrides = shortNameOverrides?.ToList() ?? new List<string>();
+            _longNameOverrides = longNameOverrides?.ToList() ?? new List<string>();
+
+            Description = string.Empty;
+            DefaultValue = string.Empty;
+            DefaultIfOptionWithoutValue = string.Empty;
+        }
+
+        internal string Name { get; private set; }
+
+        internal string Description { get; private set; }
+
+        internal ParameterType Type { get; private set; }
+
+        internal string? DefaultValue { get; private set; }
+
+        internal bool IsRequired { get; private set; }
+
+        internal bool IsHidden { get; private set; }
+
+        internal IReadOnlyDictionary<string, ParameterChoice>? Choices => _choices;
+
+        internal IReadOnlyList<string> ShortNameOverrides => _shortNameOverrides;
+
+        internal IReadOnlyList<string> LongNameOverrides => _longNameOverrides;
+
+        //TODO: decide if we handle it
+        internal string DefaultIfOptionWithoutValue { get; private set; }
+
+        private static ParameterType ParseType(string dataType)
+        {
+            return dataType switch
+            {
+                "bool" => ParameterType.Boolean,
+                "boolean" => ParameterType.Boolean,
+                "choice" => ParameterType.Choice,
+                "float" => ParameterType.Float,
+                "int" => ParameterType.Integer,
+                "integer" => ParameterType.Integer,
+                _ => ParameterType.String
+            };
+        }
+    }
+}