Create ConfigurableScriptRule class

Author: Kapil Borle

Rules/ConfigurableScriptRule.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Management.Automation.Language;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.Generic
+{
+    public abstract class ConfigurableScriptRule : IScriptRule
+    {
+        public bool IsRuleConfigured { get; protected set; } = false;
+
+        public void ConfigureRule()
+        {
+            var arguments = Helper.Instance.GetRuleArguments(this.GetName());
+            //var configurableProps = GetConfigurableProperties();
+            try
+            {
+                var properties = this.GetType().GetProperties();
+                foreach (var property in properties)
+                {
+                    if (arguments.ContainsKey(property.Name))
+                    {
+                        var type = property.PropertyType;
+                        var obj = arguments[property.Name];
+                        property.SetValue(
+                            this,
+                            System.Convert.ChangeType(obj, Type.GetTypeCode(type)));
+                    }
+                }
+            }
+            catch
+            {
+                // return arguments with defaults
+            }
+
+            IsRuleConfigured = true;
+        }
+
+        // private GetConfigurableProperties()
+        // {
+
+        // }
+
+        public abstract IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName);
+        public abstract string GetCommonName();
+        public abstract string GetDescription();
+        public abstract string GetName();
+        public abstract RuleSeverity GetSeverity();
+        public abstract string GetSourceName();
+        public abstract SourceType GetSourceType();
+    }
+
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+    public class ConfigurablePropertyAttribute : Attribute
+    {
+
+    }
+}

Rules/ScriptAnalyzerBuiltinRules.csproj

@@ -88,6 +88,7 @@
     <Compile Include="AvoidUsingPlainTextForPassword.cs" />
     <Compile Include="AvoidUsingWMICmdlet.cs" />
     <Compile Include="AvoidUsingWriteHost.cs" />
+    <Compile Include="ConfigurableScriptRule.cs" />
     <Compile Include="DscTestsPresent.cs" />
     <Compile Include="DscExamplesPresent.cs" />
     <Compile Include="MisleadingBacktick.cs" />

Rules/UseConsistentIndentation.cs

@@ -26,69 +26,28 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules
 #if !CORECLR
     [Export(typeof(IScriptRule))]
 #endif
-    class UseConsistentIndentation : IScriptRule
+    class UseConsistentIndentation : ConfigurableScriptRule
     {
-
-        private class RuleArguments
-        {
-            public int indentationSize { get; set; } = 4;
-
-            public static RuleArguments Create(Dictionary<string, object> arguments)
-            {
-                try
-                {
-                    var ruleArguments = new RuleArguments();
-                    var properties = ruleArguments.GetType().GetProperties();
-                    foreach (var property in properties)
-                    {
-                        if (arguments.ContainsKey(property.Name))
-                        {
-                            var type = property.PropertyType;
-                            var obj = arguments[property.Name];
-                            property.SetValue(ruleArguments, System.Convert.ChangeType(obj, Type.GetTypeCode(type)));
-                        }
-                    }
-
-                    return ruleArguments;
-                }
-                catch
-                {
-                    return new RuleArguments(); // return arguments with defaults
-                }
-            }
-        }
-
-        private bool isRuleConfigured;
-
-        private RuleArguments ruleArguments;
-
-        private int indentationSize;
         private enum IndentationKind { Space, Tab };
 
         // TODO make this configurable
         private readonly IndentationKind indentationKind = IndentationKind.Space;
-
-        private void ConfigureRule()
-        {
-            ruleArguments = RuleArguments.Create(Helper.Instance.GetRuleArguments(this.GetName()));
-            indentationSize = ruleArguments.indentationSize;
-            isRuleConfigured = true;
-        }
+        public int IndentationSize { get; protected set; } = 4;
 
         /// <summary>
         /// Analyzes the given ast to find the [violation]
         /// </summary>
         /// <param name="ast">AST to be analyzed. This should be non-null</param>
         /// <param name="fileName">Name of file that corresponds to the input AST.</param>
         /// <returns>A an enumerable type containing the violations</returns>
-        public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
+        public override IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
         {
             if (ast == null)
             {
                 throw new ArgumentNullException("ast");
             }
 
-            if (!isRuleConfigured)
+            if (!IsRuleConfigured)
             {
                 ConfigureRule();
             }
@@ -197,7 +156,7 @@ private int GetIndentationColumnNumber(int indentationLevel)
 
         private int GetIndentation(int indentationLevel)
         {
-            return indentationLevel * this.indentationSize;
+            return indentationLevel * this.IndentationSize;
         }
 
         private char GetIndentationChar()
@@ -213,23 +172,23 @@ private string GetIndentationString(int indentationLevel)
         /// <summary>
         /// Retrieves the common name of this rule.
         /// </summary>
-        public string GetCommonName()
+        public override string GetCommonName()
         {
             return string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentIndentationCommonName);
         }
 
         /// <summary>
         /// Retrieves the description of this rule.
         /// </summary>
-        public string GetDescription()
+        public override string GetDescription()
         {
             return string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentIndentationDescription);
         }
 
         /// <summary>
         /// Retrieves the name of this rule.
         /// </summary>
-        public string GetName()
+        public override string GetName()
         {
             return string.Format(
                 CultureInfo.CurrentCulture,
@@ -241,7 +200,7 @@ public string GetName()
         /// <summary>
         /// Retrieves the severity of the rule: error, warning or information.
         /// </summary>
-        public RuleSeverity GetSeverity()
+        public override RuleSeverity GetSeverity()
         {
             return RuleSeverity.Information;
         }
@@ -258,15 +217,15 @@ public DiagnosticSeverity GetDiagnosticSeverity()
         /// <summary>
         /// Retrieves the name of the module/assembly the rule is from.
         /// </summary>
-        public string GetSourceName()
+        public override string GetSourceName()
         {
             return string.Format(CultureInfo.CurrentCulture, Strings.SourceName);
         }
 
         /// <summary>
         /// Retrieves the type of the rule, Builtin, Managed or Module.
         /// </summary>
-        public SourceType GetSourceType()
+        public override SourceType GetSourceType()
         {
             return SourceType.Builtin;
         }