Add beginnings of PSScriptAnalyzer 2.0

ScriptAnalyzer2/Builder/BuiltinRulesBuilder.cs

@@ -0,0 +1,43 @@
+using Microsoft.PowerShell.ScriptAnalyzer.Builtin;
+using Microsoft.PowerShell.ScriptAnalyzer.Configuration;
+using Microsoft.PowerShell.ScriptAnalyzer.Instantiation;
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.PowerShell.ScriptAnalyzer.Builder
+{
+    public class BuiltinRulesBuilder
+    {
+        private IReadOnlyDictionary<string, IRuleConfiguration> _ruleConfiguration;
+
+        private IRuleComponentProvider _ruleComponents;
+
+        public BuiltinRulesBuilder WithRuleConfiguration(IReadOnlyDictionary<string, IRuleConfiguration> ruleConfigurationCollection)
+        {
+            _ruleConfiguration = ruleConfigurationCollection;
+            return this;
+        }
+
+        public BuiltinRulesBuilder WithRuleComponentProvider(IRuleComponentProvider ruleComponentProvider)
+        {
+            _ruleComponents = ruleComponentProvider;
+            return this;
+        }
+
+        public BuiltinRulesBuilder WithRuleComponentBuilder(Action<RuleComponentProviderBuilder> configureRuleComponents)
+        {
+            var ruleComponentProviderBuilder = new RuleComponentProviderBuilder();
+            configureRuleComponents(ruleComponentProviderBuilder);
+            _ruleComponents = ruleComponentProviderBuilder.Build();
+            return this;
+        }
+
+        public TypeRuleProvider Build()
+        {
+            return TypeRuleProvider.FromTypes(
+                _ruleConfiguration ?? Default.RuleConfiguration,
+                _ruleComponents ?? Default.RuleComponentProvider,
+                BuiltinRules.DefaultRules);
+        }
+    }
+}

ScriptAnalyzer2/Builder/ConfiguredBuilding.cs

@@ -0,0 +1,57 @@
+using Microsoft.PowerShell.ScriptAnalyzer.Configuration;
+using Microsoft.PowerShell.ScriptAnalyzer.Execution;
+using Microsoft.PowerShell.ScriptAnalyzer.Instantiation;
+using Microsoft.PowerShell.ScriptAnalyzer.Utils;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace Microsoft.PowerShell.ScriptAnalyzer.Builder
+{
+    public static class ConfiguredBuilding
+    {
+        public static ScriptAnalyzer CreateScriptAnalyzer(this IScriptAnalyzerConfiguration configuration)
+        {
+            var analyzerBuilder = new ScriptAnalyzerBuilder();
+
+            switch (configuration.BuiltinRules ?? BuiltinRulePreference.Default)
+            {
+                case BuiltinRulePreference.Aggressive:
+                case BuiltinRulePreference.Default:
+                    analyzerBuilder.AddBuiltinRules();
+                    break;
+            }
+
+            switch (configuration.RuleExecution ?? RuleExecutionMode.Default)
+            {
+                case RuleExecutionMode.Default:
+                case RuleExecutionMode.Parallel:
+                    analyzerBuilder.WithRuleExecutorFactory(new ParallelLinqRuleExecutorFactory());
+                    break;
+
+                case RuleExecutionMode.Sequential:
+                    analyzerBuilder.WithRuleExecutorFactory(new SequentialRuleExecutorFactory());
+                    break;
+            }
+
+            var componentProvider = new RuleComponentProviderBuilder().Build();
+
+            if (configuration.RulePaths != null)
+            {
+                foreach (string rulePath in configuration.RulePaths)
+                {
+                    string extension = Path.GetExtension(rulePath);
+
+                    if (extension.CaseInsensitiveEquals(".dll"))
+                    {
+                        analyzerBuilder.AddRuleProvider(TypeRuleProvider.FromAssemblyFile(configuration.RuleConfiguration, componentProvider, rulePath));
+                        break;
+                    }
+                }
+            }
+
+            return analyzerBuilder.Build();
+        }
+    }
+}

ScriptAnalyzer2/Builder/ScriptAnalyzerBuilder.cs

@@ -0,0 +1,58 @@
+using Microsoft.PowerShell.ScriptAnalyzer.Builtin;
+using Microsoft.PowerShell.ScriptAnalyzer.Execution;
+using Microsoft.PowerShell.ScriptAnalyzer.Instantiation;
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.PowerShell.ScriptAnalyzer.Builder
+{
+    public class ScriptAnalyzerBuilder
+    {
+        private readonly List<IRuleProvider> _ruleProviders;
+
+        private IRuleExecutorFactory _ruleExecutorFactory;
+
+        public ScriptAnalyzerBuilder()
+        {
+            _ruleProviders = new List<IRuleProvider>();
+        }
+
+        public ScriptAnalyzerBuilder WithRuleExecutorFactory(IRuleExecutorFactory ruleExecutorFactory)
+        {
+            _ruleExecutorFactory = ruleExecutorFactory;
+            return this;
+        }
+
+        public ScriptAnalyzerBuilder AddRuleProvider(IRuleProvider ruleProvider)
+        {
+            _ruleProviders.Add(ruleProvider);
+            return this;
+        }
+
+        public ScriptAnalyzerBuilder AddBuiltinRules()
+        {
+            _ruleProviders.Add(TypeRuleProvider.FromTypes(
+                Default.RuleConfiguration,
+                Default.RuleComponentProvider,
+                BuiltinRules.DefaultRules));
+            return this;
+        }
+
+        public ScriptAnalyzerBuilder AddBuiltinRules(Action<BuiltinRulesBuilder> configureBuiltinRules)
+        {
+            var builtinRulesBuilder = new BuiltinRulesBuilder();
+            configureBuiltinRules(builtinRulesBuilder);
+            _ruleProviders.Add(builtinRulesBuilder.Build());
+            return this;
+        }
+
+        public ScriptAnalyzer Build()
+        {
+            IRuleProvider ruleProvider = _ruleProviders.Count == 1
+                ? _ruleProviders[0]
+                : new CompositeRuleProvider(_ruleProviders);
+
+            return new ScriptAnalyzer(ruleProvider, _ruleExecutorFactory ?? Default.RuleExecutorFactory);
+        }
+    }
+}

ScriptAnalyzer2/Builtin/BuiltinRuleProvider.cs

@@ -0,0 +1,61 @@
+using Microsoft.PowerShell.ScriptAnalyzer.Builder;
+using Microsoft.PowerShell.ScriptAnalyzer.Builtin.Rules;
+using Microsoft.PowerShell.ScriptAnalyzer.Configuration;
+using Microsoft.PowerShell.ScriptAnalyzer.Execution;
+using Microsoft.PowerShell.ScriptAnalyzer.Runtime;
+using Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules;
+using System;
+using System.Collections.Generic;
+using System.Management.Automation.Runspaces;
+
+namespace Microsoft.PowerShell.ScriptAnalyzer.Builtin
+{
+    public static class BuiltinRules
+    {
+        public static IReadOnlyList<Type> DefaultRules { get; } = new[]
+        {
+            typeof(AvoidEmptyCatchBlock),
+            typeof(AvoidGlobalVars),
+            typeof(AvoidPositionalParameters),
+            typeof(AvoidUsingWMICmdlet),
+            typeof(UseDeclaredVarsMoreThanAssignments),
+            typeof(UseShouldProcessForStateChangingFunctions),
+        };
+    }
+
+    public static class Default
+    {
+        private static readonly Lazy<IRuleComponentProvider> s_ruleComponentProviderLazy = new Lazy<IRuleComponentProvider>(BuildRuleComponentProvider);
+
+        public static IReadOnlyDictionary<string, IRuleConfiguration> RuleConfiguration { get; } = new Dictionary<string, IRuleConfiguration>(StringComparer.OrdinalIgnoreCase)
+        {
+            { "PS/AvoidUsingEmptyCatchBlock", null },
+            { "PS/AvoidGlobalVars", null },
+            { "PS/AvoidUsingPositionalParameters", null },
+            { "PS/AvoidUsingWMICmdlet", null },
+            { "PS/UseDeclaredVarsMoreThanAssignments", null },
+            { "PS/UseShouldProcessForStateChangingFunctions", null },
+        };
+
+        public static IRuleExecutorFactory RuleExecutorFactory { get; } = new ParallelLinqRuleExecutorFactory();
+
+        public static IRuleComponentProvider RuleComponentProvider => s_ruleComponentProviderLazy.Value;
+
+        private static IRuleComponentProvider BuildRuleComponentProvider()
+        {
+            return new RuleComponentProviderBuilder()
+                .AddSingleton(InstantiatePowerShellCommandDatabase())
+                .Build();
+        }
+
+        private static IPowerShellCommandDatabase InstantiatePowerShellCommandDatabase()
+        {
+            using (Runspace runspace = RunspaceFactory.CreateRunspace())
+            {
+                runspace.Open();
+                return SessionStateCommandDatabase.Create(runspace.SessionStateProxy.InvokeCommand);
+            }
+        }
+    }
+
+}

ScriptAnalyzer2/Builtin/Rules/AvoidEmptyCatchBlock.cs

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Management.Automation.Language;
+using System.Globalization;
+using Microsoft.PowerShell.ScriptAnalyzer.Rules;
+
+namespace Microsoft.PowerShell.ScriptAnalyzer.Builtin.Rules
+{
+    /// <summary>
+    /// AvoidEmptyCatchBlock: Check if any empty catch block is used.
+    /// </summary>
+    [IdempotentRule]
+    [ThreadsafeRule]
+    [RuleDescription(typeof(Strings), nameof(Strings.AvoidUsingEmptyCatchBlockDescription))]
+    [Rule("AvoidUsingEmptyCatchBlock")]
+    public class AvoidEmptyCatchBlock : ScriptRule
+    {
+        public AvoidEmptyCatchBlock(RuleInfo ruleInfo)
+            : base(ruleInfo)
+        {
+        }
+
+        /// <summary>
+        /// AnalyzeScript: Analyze the script to check if any empty catch block is used.
+        /// </summary>
+        public override IEnumerable<ScriptDiagnostic> AnalyzeScript(Ast ast, IReadOnlyList<Token> tokens, string fileName)
+        {
+            if (ast == null) throw new ArgumentNullException(Strings.NullAstErrorMessage);
+
+            // Finds all CommandAsts.
+            IEnumerable<Ast> foundAsts = ast.FindAll(testAst => testAst is CatchClauseAst, true);
+
+            // Iterates all CatchClauseAst and check the statements count.
+            foreach (Ast foundAst in foundAsts)
+            {
+                CatchClauseAst catchAst = (CatchClauseAst)foundAst;
+
+                if (catchAst.Body.Statements.Count == 0)
+                {
+                    yield return CreateDiagnostic(
+                        string.Format(CultureInfo.CurrentCulture, Strings.AvoidEmptyCatchBlockError),
+                        catchAst);
+                }
+            }
+        }
+    }
+}
+
+
+
+

ScriptAnalyzer2/Builtin/Rules/AvoidGlobalVars.cs

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Management.Automation.Language;
+using System.Globalization;
+using Microsoft.PowerShell.ScriptAnalyzer.Rules;
+using Microsoft.PowerShell.ScriptAnalyzer;
+using Microsoft.PowerShell.ScriptAnalyzer.Builtin.Rules;
+
+namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules
+{
+    /// <summary>
+    /// AvoidGlobalVars: Analyzes the ast to check that global variables are not used.
+    /// </summary>
+    [IdempotentRule]
+    [ThreadsafeRule]
+    [RuleDescription(typeof(Strings), nameof(Strings.AvoidGlobalVarsDescription))]
+    [Rule("AvoidGlobalVars")]
+    public class AvoidGlobalVars : ScriptRule
+    {
+        public AvoidGlobalVars(RuleInfo ruleInfo) : base(ruleInfo)
+        {
+        }
+
+        /// <summary>
+        /// AnalyzeScript: Analyzes the ast to check that global variables are not used. From the ILintScriptRule interface.
+        /// </summary>
+        /// <param name="ast">The script's ast</param>
+        /// <param name="fileName">The script's file name</param>
+        /// <returns>A List of diagnostic results of this rule</returns>
+        public override IEnumerable<ScriptDiagnostic> AnalyzeScript(Ast ast, IReadOnlyList<Token> tokens, string fileName)
+        {
+            IEnumerable<Ast> varAsts = ast.FindAll(testAst => testAst is VariableExpressionAst, true);
+
+            if (varAsts == null)
+            {
+                yield break;
+            }
+
+            foreach (VariableExpressionAst varAst in varAsts)
+            {
+                if (varAst.VariablePath.IsGlobal)
+                {
+                    yield return CreateDiagnostic(
+                            string.Format(CultureInfo.CurrentCulture, Strings.AvoidGlobalVarsError, varAst.VariablePath.UserPath),
+                            varAst);
+                }
+            }
+        }
+    }
+}
+
+
+
+