{

#region Private members

private IOutputWriter outputWriter;

private CompositionContainer container;

Dictionary<string, List<string>> validationResults = new Dictionary<string, List<string>>();

string[] includeRule;

string[] excludeRule;

string[] severity;

List<Regex> includeRegexList;

List<Regex> excludeRegexList;

bool suppressedOnly;

#endregion

#region Singleton

private static object syncRoot = new Object();

private static ScriptAnalyzer instance;

public static ScriptAnalyzer Instance

{

get

{

if (instance == null)

{

lock (syncRoot)

{

if (instance == null)

instance = new ScriptAnalyzer();

}

}

return instance;

}

}

#endregion

#region Properties

// Initializes via ImportMany

[ImportMany]

public IEnumerable<IScriptRule> ScriptRules { get; private set; }

[ImportMany]

public IEnumerable<ITokenRule> TokenRules { get; private set; }

[ImportMany]

public IEnumerable<ILogger> Loggers { get; private set; }

[ImportMany]

public IEnumerable<IDSCResourceRule> DSCResourceRules { get; private set; }

internal List<ExternalRule> ExternalRules { get; set; }

#endregion

#region Methods

/// <summary>

/// Initialize : Initializes default rules, loggers and helper.

/// </summary>

internal void Initialize<TCmdlet>(

TCmdlet cmdlet,

string[] customizedRulePath = null,

string[] includeRuleNames = null,

string[] excludeRuleNames = null,

string[] severity = null,

bool suppressedOnly = false,

string profile = null)

where TCmdlet : PSCmdlet, IOutputWriter

{

if (cmdlet == null)

{

throw new ArgumentNullException("cmdlet");

}

this.Initialize(

cmdlet,

cmdlet.SessionState.Path,

cmdlet.SessionState.InvokeCommand,

customizedRulePath,

includeRuleNames,

excludeRuleNames,

severity,

suppressedOnly,

profile);

}

/// <summary>

/// Initialize : Initializes default rules, loggers and helper.

/// </summary>

public void Initialize(

Runspace runspace,

IOutputWriter outputWriter,

string[] customizedRulePath = null,

string[] includeRuleNames = null,

string[] excludeRuleNames = null,

string[] severity = null,

bool suppressedOnly = false,

string profile = null)

{

if (runspace == null)

{

throw new ArgumentNullException("runspace");

}

this.Initialize(

outputWriter,

runspace.SessionStateProxy.Path,

runspace.SessionStateProxy.InvokeCommand,

customizedRulePath,

includeRuleNames,

excludeRuleNames,

severity,

suppressedOnly,

profile);

}

private void Initialize(

IOutputWriter outputWriter,

PathIntrinsics path,

CommandInvocationIntrinsics invokeCommand,

string[] customizedRulePath,

string[] includeRuleNames,

string[] excludeRuleNames,

string[] severity,

bool suppressedOnly = false,

string profile = null)

{

if (outputWriter == null)

{

throw new ArgumentNullException("outputWriter");

}

this.outputWriter = outputWriter;

#region Verifies rule extensions and loggers path

List<string> paths = this.GetValidCustomRulePaths(customizedRulePath, path);

#endregion

#region Initializes Rules

this.severity = severity;

this.suppressedOnly = suppressedOnly;

this.includeRule = includeRuleNames;

this.excludeRule = excludeRuleNames;

this.includeRegexList = new List<Regex>();

this.excludeRegexList = new List<Regex>();

if (!String.IsNullOrWhiteSpace(profile))

{

try

{

profile = path.GetResolvedPSPathFromPSPath(profile).First().Path;

}

catch

{

this.outputWriter.WriteError(new ErrorRecord(new FileNotFoundException(),

string.Format(CultureInfo.CurrentCulture, Strings.FileNotFound, profile),

ErrorCategory.InvalidArgument, this));

}

if (File.Exists(profile))

{

Token[] parserTokens = null;

ParseError[] parserErrors = null;

Ast profileAst = Parser.ParseFile(profile, out parserTokens, out parserErrors);

IEnumerable<Ast> hashTableAsts = profileAst.FindAll(item => item is HashtableAst, false);

foreach (HashtableAst hashTableAst in hashTableAsts)

{

foreach (var kvp in hashTableAst.KeyValuePairs)

{

if (!(kvp.Item1 is StringConstantExpressionAst))

{

this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),

string.Format(CultureInfo.CurrentCulture, Strings.WrongKeyFormat, kvp.Item1.Extent.StartLineNumber, kvp.Item1.Extent.StartColumnNumber, profile),

ErrorCategory.InvalidArgument, this));

continue;

}

// parse the item2 as array

PipelineAst pipeAst = kvp.Item2 as PipelineAst;

List<string> rhsList = new List<string>();

if (pipeAst != null)

{

ExpressionAst pureExp = pipeAst.GetPureExpression();

if (pureExp is StringConstantExpressionAst)

{

rhsList.Add((pureExp as StringConstantExpressionAst).Value);

}

else

{

ArrayLiteralAst arrayLitAst = pureExp as ArrayLiteralAst;

if (arrayLitAst == null && pureExp is ArrayExpressionAst)

{

ArrayExpressionAst arrayExp = pureExp as ArrayExpressionAst;

// Statements property is never null

if (arrayExp.SubExpression != null)

{

StatementAst stateAst = arrayExp.SubExpression.Statements.First();

if (stateAst != null && stateAst is PipelineAst)

{

CommandBaseAst cmdBaseAst = (stateAst as PipelineAst).PipelineElements.First();

if (cmdBaseAst != null && cmdBaseAst is CommandExpressionAst)

{

CommandExpressionAst cmdExpAst = cmdBaseAst as CommandExpressionAst;

if (cmdExpAst.Expression is StringConstantExpressionAst)

{

rhsList.Add((cmdExpAst.Expression as StringConstantExpressionAst).Value);

}

else

{

arrayLitAst = cmdExpAst.Expression as ArrayLiteralAst;

}

}

}

}

}

if (arrayLitAst != null)

{

foreach (var element in arrayLitAst.Elements)

{

if (!(element is StringConstantExpressionAst))

{

this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),

string.Format(CultureInfo.CurrentCulture, Strings.WrongValueFormat, element.Extent.StartLineNumber, element.Extent.StartColumnNumber, profile),

ErrorCategory.InvalidArgument, this));

continue;

}

rhsList.Add((element as StringConstantExpressionAst).Value);

}

}

}

}

if (rhsList.Count == 0)

{

this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),

string.Format(CultureInfo.CurrentCulture, Strings.WrongValueFormat, kvp.Item2.Extent.StartLineNumber, kvp.Item2.Extent.StartColumnNumber, profile),

ErrorCategory.InvalidArgument, this));

break;

}

switch ((kvp.Item1 as StringConstantExpressionAst).Value.ToLower())

{

case "severity":

if (this.severity == null)

{

this.severity = rhsList.ToArray();

}

else

{

this.severity = this.severity.Union(rhsList).ToArray();

}

break;

case "includerules":

if (this.includeRule == null)

{

this.includeRule = rhsList.ToArray();

}

else

{

this.includeRule = this.includeRule.Union(rhsList).ToArray();

}

break;

case "excluderules":

if (this.excludeRule == null)

{

this.excludeRule = rhsList.ToArray();

}

else

{

this.excludeRule = this.excludeRule.Union(rhsList).ToArray();

}

break;

default:

this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),

string.Format(CultureInfo.CurrentCulture, Strings.WrongKey, kvp.Item1.Extent.StartLineNumber, kvp.Item1.Extent.StartColumnNumber, profile),

ErrorCategory.InvalidArgument, this));

break;

}

}

}

}

}

//Check wild card input for the Include/ExcludeRules and create regex match patterns

if (this.includeRule != null)

{

foreach (string rule in includeRule)

{

Regex includeRegex = new Regex(String.Format("^{0}$", Regex.Escape(rule).Replace(@"\*", ".*")), RegexOptions.IgnoreCase);

this.includeRegexList.Add(includeRegex);

}

}

if (this.excludeRule != null)

{

foreach (string rule in excludeRule)

{

Regex excludeRegex = new Regex(String.Format("^{0}$", Regex.Escape(rule).Replace(@"\*", ".*")), RegexOptions.IgnoreCase);

this.excludeRegexList.Add(excludeRegex);

}

}

try

{

this.LoadRules(this.validationResults, invokeCommand);

}

catch (Exception ex)

{

this.outputWriter.ThrowTerminatingError(

new ErrorRecord(

ex,

ex.HResult.ToString("X", CultureInfo.CurrentCulture),

ErrorCategory.NotSpecified, this));

}

#endregion

#region Verify rules

// Safely get one non-duplicated list of rules

IEnumerable<IRule> rules =

Enumerable.Union<IRule>(

Enumerable.Union<IRule>(

this.ScriptRules ?? Enumerable.Empty<IRule>(),

this.TokenRules ?? Enumerable.Empty<IRule>()),

this.ExternalRules ?? Enumerable.Empty<IExternalRule>());

// Ensure that rules were actually loaded

if (rules == null || rules.Any() == false)

{

this.outputWriter.ThrowTerminatingError(

new ErrorRecord(

new Exception(),

string.Format(

CultureInfo.CurrentCulture,

Strings.RulesNotFound),

ErrorCategory.ResourceExists,

this));

}

#endregion

}

private List<string> GetValidCustomRulePaths(string[] customizedRulePath, PathIntrinsics path)

{

List<string> paths = new List<string>();

if (customizedRulePath != null)

{

paths.AddRange(

customizedRulePath.ToList());

}

if (paths.Count > 0)

{

this.validationResults = this.CheckRuleExtension(paths.ToArray(), path);

foreach (string extension in this.validationResults["InvalidPaths"])

{

this.outputWriter.WriteWarning(string.Format(CultureInfo.CurrentCulture, Strings.MissingRuleExtension, extension));

}

}

else

{

this.validationResults = new Dictionary<string, List<string>>();

this.validationResults.Add("InvalidPaths", new List<string>());

this.validationResults.Add("ValidModPaths", new List<string>());

this.validationResults.Add("ValidDllPaths", new List<string>());

}

return paths;

}

private void LoadRules(Dictionary<string, List<string>> result, CommandInvocationIntrinsics invokeCommand)

{

List<string> paths = new List<string>();

// Initialize helper

Helper.Instance = new Helper(invokeCommand, this.outputWriter);

Helper.Instance.Initialize();

// Clear external rules for each invoke.

this.ScriptRules = null;

this.TokenRules = null;

this.ExternalRules = null;

// An aggregate catalog that combines multiple catalogs.

using (AggregateCatalog catalog = new AggregateCatalog())

{

// Adds all the parts found in the same directory.

string dirName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

catalog.Catalogs.Add(

new SafeDirectoryCatalog(

dirName,

this.outputWriter));

// Adds user specified directory

paths = result.ContainsKey("ValidDllPaths") ? result["ValidDllPaths"] : result["ValidPaths"];

foreach (string path in paths)

{

if (String.Equals(Path.GetExtension(path), ".dll", StringComparison.OrdinalIgnoreCase))

{

catalog.Catalogs.Add(new AssemblyCatalog(path));

}

else

{

catalog.Catalogs.Add(

new SafeDirectoryCatalog(

path,

this.outputWriter));

}

}

// Creates the CompositionContainer with the parts in the catalog.

container = new CompositionContainer(catalog);

// Fills the imports of this object.

try

{

container.ComposeParts(this);

}

catch (CompositionException compositionException)

{

this.outputWriter.WriteWarning(compositionException.ToString());

}

}

// Gets external rules.

if (result.ContainsKey("ValidModPaths") && result["ValidModPaths"].Count > 0)

ExternalRules = GetExternalRule(result["ValidModPaths"].ToArray());

}

internal string[] GetValidModulePaths()

{

List<string> validModulePaths = null;

if (!this.validationResults.TryGetValue("ValidModPaths", out validModulePaths))

{

validModulePaths = new List<string>();

}

return validModulePaths.ToArray();

}

public IEnumerable<IRule> GetRule(string[] moduleNames, string[] ruleNames)

{

IEnumerable<IRule> results = null;

IEnumerable<IExternalRule> externalRules = null;

// Combines C# rules.

IEnumerable<IRule> rules = ScriptRules.Union<IRule>(TokenRules)

.Union<IRule>(DSCResourceRules);

// Gets PowerShell Rules.

if (moduleNames != null)

{

externalRules = GetExternalRule(moduleNames);

rules = rules.Union<IRule>(externalRules);

}

if (ruleNames != null)

{

//Check wild card input for -Name parameter and create regex match patterns

List<Regex> regexList = new List<Regex>();

foreach (string ruleName in ruleNames)

{

Regex includeRegex = new Regex(String.Format("^{0}$", Regex.Escape(ruleName).Replace(@"\*", ".*")), RegexOptions.IgnoreCase);

regexList.Add(includeRegex);

}

results = from rule in rules

from regex in regexList

where regex.IsMatch(rule.GetName())

select rule;

}

else

{

results = rules;

}

return results;

}

private List<ExternalRule> GetExternalRule(string[] moduleNames)

{

List<ExternalRule> rules = new List<ExternalRule>();

if (moduleNames == null) return rules;

// Converts module path to module name.

foreach (string moduleName in moduleNames)

{

string shortModuleName = string.Empty;

// Imports modules by using full path.

InitialSessionState state = InitialSessionState.CreateDefault2();

state.ImportPSModule(new string[] { moduleName });

using (System.Management.Automation.PowerShell posh =

System.Management.Automation.PowerShell.Create(state))

{

string script = string.Format(CultureInfo.CurrentCulture, "Get-Module -Name '{0}' -ListAvailable", moduleName);

shortModuleName = posh.AddScript(script).Invoke<PSModuleInfo>().First().Name;

// Invokes Update-Help for this module

// Required since when invoking Get-Help later on, the cmdlet prompts for Update-Help interactively

// By invoking Update-Help first, Get-Help will not prompt for downloading help later

script = string.Format(CultureInfo.CurrentCulture, "Update-Help -Module '{0}' -Force", shortModuleName);

posh.AddScript(script).Invoke();

// Invokes Get-Command and Get-Help for each functions in the module.

script = string.Format(CultureInfo.CurrentCulture, "Get-Command -Module '{0}'", shortModuleName);

var psobjects = posh.AddScript(script).Invoke();

foreach (PSObject psobject in psobjects)

{

posh.Commands.Clear();

FunctionInfo funcInfo = (FunctionInfo)psobject.ImmediateBaseObject;

ParameterMetadata param = funcInfo.Parameters.Values

.First<ParameterMetadata>(item => item.Name.EndsWith("ast", StringComparison.OrdinalIgnoreCase) ||

item.Name.EndsWith("token", StringComparison.OrdinalIgnoreCase));

//Only add functions that are defined as rules.

if (param != null)

{

script = string.Format(CultureInfo.CurrentCulture, "(Get-Help -Name {0}).Description | Out-String", funcInfo.Name);

string desc = posh.AddScript(script).Invoke()[0].ImmediateBaseObject.ToString()

.Replace("\r\n", " ").Trim();

rules.Add(new ExternalRule(funcInfo.Name, funcInfo.Name, desc, param.Name, param.ParameterType.FullName,

funcInfo.ModuleName, funcInfo.Module.Path));

}

}

}

}

return rules;

}

/// <summary>

/// GetExternalRecord: Get external rules in parallel using RunspacePool and run each rule in its own runspace.

/// </summary>

/// <param name="ast"></param>

/// <param name="token"></param>

/// <param name="rules"></param>

/// <param name="command"></param>

/// <param name="filePath"></param>

/// <returns></returns>

internal IEnumerable<DiagnosticRecord> GetExternalRecord(Ast ast, Token[] token, ExternalRule[] rules, string filePath)

{

// Defines InitialSessionState.

InitialSessionState state = InitialSessionState.CreateDefault2();

// Groups rules by module paths and imports them.

Dictionary<string, List<ExternalRule>> modules = rules

.GroupBy<ExternalRule, string>(item => item.GetFullModulePath())

.ToDictionary(item => item.Key, item => item.ToList());

state.ImportPSModule(modules.Keys.ToArray<string>());

// Creates and opens RunspacePool

RunspacePool rsp = RunspaceFactory.CreateRunspacePool(state);

rsp.SetMinRunspaces(1);

rsp.SetMaxRunspaces(5);

rsp.Open();

// Groups rules by AstType and Tokens.

Dictionary<string, List<ExternalRule>> astRuleGroups = rules

.Where<ExternalRule>(item => item.GetParameter().EndsWith("ast", StringComparison.OrdinalIgnoreCase))

.GroupBy<ExternalRule, string>(item => item.GetParameterType())

.ToDictionary(item => item.Key, item => item.ToList());

Dictionary<string, List<ExternalRule>> tokenRuleGroups = rules

.Where<ExternalRule>(item => item.GetParameter().EndsWith("token", StringComparison.OrdinalIgnoreCase))

.GroupBy<ExternalRule, string>(item => item.GetParameterType())

.ToDictionary(item => item.Key, item => item.ToList());

using (rsp)

{

// Defines the commands to be run.

List<System.Management.Automation.PowerShell> powerShellCommands

= new List<System.Management.Automation.PowerShell>();

// Defines the command results.

List<IAsyncResult> powerShellCommandResults = new List<IAsyncResult>();

#region Builds and invokes commands list

foreach (KeyValuePair<string, List<ExternalRule>> tokenRuleGroup in tokenRuleGroups)

{

foreach (IExternalRule rule in tokenRuleGroup.Value)

{

System.Management.Automation.PowerShell posh =

System.Management.Automation.PowerShell.Create();

posh.RunspacePool = rsp;

// Adds command to run external analyzer rule, like

// Measure-CurlyBracket -ScriptBlockAst $ScriptBlockAst

// Adds module name (source name) to handle ducplicate function names in different modules.

string ruleName = string.Format("{0}\\{1}", rule.GetSourceName(), rule.GetName());

posh.Commands.AddCommand(ruleName);

posh.Commands.AddParameter(rule.GetParameter(), token);

// Merges results because external analyzer rules may throw exceptions.

posh.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error,

PipelineResultTypes.Output);

powerShellCommands.Add(posh);

powerShellCommandResults.Add(posh.BeginInvoke());

}

}

foreach (KeyValuePair<string, List<ExternalRule>> astRuleGroup in astRuleGroups)

{

// Find all AstTypes that appeared in rule groups.

IEnumerable<Ast> childAsts = ast.FindAll(new Func<Ast, bool>((testAst) =>

(astRuleGroup.Key.IndexOf(testAst.GetType().FullName, StringComparison.OrdinalIgnoreCase) != -1)), false);

foreach (Ast childAst in childAsts)

{

foreach (IExternalRule rule in astRuleGroup.Value)

{

System.Management.Automation.PowerShell posh =

System.Management.Automation.PowerShell.Create();

posh.RunspacePool = rsp;

// Adds command to run external analyzer rule, like

// Measure-CurlyBracket -ScriptBlockAst $ScriptBlockAst

// Adds module name (source name) to handle ducplicate function names in different modules.

string ruleName = string.Format("{0}\\{1}", rule.GetSourceName(), rule.GetName());

posh.Commands.AddCommand(ruleName);

posh.Commands.AddParameter(rule.GetParameter(), childAst);

// Merges results because external analyzer rules may throw exceptions.

posh.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error,

PipelineResultTypes.Output);

powerShellCommands.Add(posh);

powerShellCommandResults.Add(posh.BeginInvoke());

}

}

}

#endregion

#region Collects the results from commands.

List<DiagnosticRecord> diagnostics = new List<DiagnosticRecord>();

try

{

for (int i = 0; i < powerShellCommands.Count; i++)

{

// EndInvoke will wait for each command to finish, so we will be getting the commands

// in the same order that they have been invoked withy BeginInvoke.

PSDataCollection<PSObject> psobjects = powerShellCommands[i].EndInvoke(powerShellCommandResults[i]);

foreach (var psobject in psobjects)

{

DiagnosticSeverity severity;

IScriptExtent extent;

string message = string.Empty;

string ruleName = string.Empty;

if (psobject != null && psobject.ImmediateBaseObject != null)

{

// Because error stream is merged to output stream,

// we need to handle the error records.

if (psobject.ImmediateBaseObject is ErrorRecord)

{

ErrorRecord record = (ErrorRecord)psobject.ImmediateBaseObject;

this.outputWriter.WriteError(record);

continue;

}

// DiagnosticRecord may not be correctly returned from external rule.

try

{

Enum.TryParse<DiagnosticSeverity>(psobject.Properties["Severity"].Value.ToString().ToUpper(), out severity);

message = psobject.Properties["Message"].Value.ToString();

extent = (IScriptExtent)psobject.Properties["Extent"].Value;

ruleName = psobject.Properties["RuleName"].Value.ToString();

}

catch (Exception ex)

{

this.outputWriter.WriteError(new ErrorRecord(ex, ex.HResult.ToString("X"), ErrorCategory.NotSpecified, this));

continue;

}

if (!string.IsNullOrEmpty(message))

{

diagnostics.Add(new DiagnosticRecord(message, extent, ruleName, severity, null));

}

}

}

}

}

//Catch exception where customized defined rules have exceptins when doing invoke

catch (Exception ex)

{

this.outputWriter.WriteError(new ErrorRecord(ex, ex.HResult.ToString("X"), ErrorCategory.NotSpecified, this));

}

return diagnostics;

#endregion

}

}

public Dictionary<string, List<string>> CheckRuleExtension(string[] path, PathIntrinsics basePath)

{

Dictionary<string, List<string>> results = new Dictionary<string, List<string>>();

List<string> invalidPaths = new List<string>();

List<string> validDllPaths = new List<string>();

List<string> validModPaths = new List<string>();

// Gets valid module names

foreach (string childPath in path)

{

try

{

this.outputWriter.WriteVerbose(string.Format(CultureInfo.CurrentCulture, Strings.CheckModuleName, childPath));

string resolvedPath = string.Empty;

// Users may provide a valid module path or name,

// We have to identify the childPath is really a directory or just a module name.

// You can also consider following two commands.

// Get-ScriptAnalyzerRule -RuleExtension "ContosoAnalyzerRules"

// Get-ScriptAnalyzerRule -RuleExtension "%USERPROFILE%\WindowsPowerShell\Modules\ContosoAnalyzerRules"

if (Path.GetDirectoryName(childPath) == string.Empty)

{

resolvedPath = childPath;

}

else

{

resolvedPath = basePath

.GetResolvedPSPathFromPSPath(childPath).First().ToString();

}

using (System.Management.Automation.PowerShell posh =

System.Management.Automation.PowerShell.Create())

{

string script = string.Format(CultureInfo.CurrentCulture, "Get-Module -Name '{0}' -ListAvailable", resolvedPath);

PSModuleInfo moduleInfo = posh.AddScript(script).Invoke<PSModuleInfo>().First();

// Adds original path, otherwise path.Except<string>(validModPaths) will fail.

// It's possible that user can provide something like this:

// "..\..\..\ScriptAnalyzer.UnitTest\modules\CommunityAnalyzerRules\CommunityAnalyzerRules.psd1"

if (moduleInfo.ExportedFunctions.Count > 0) validModPaths.Add(childPath);

}

}

catch

{

// User may provide an invalid module name, like c:\temp.

// It's a invalid name for a Windows PowerShell module,

// But we need test it further since we allow user to provide a folder to extend rules.

// You can also consider following two commands.

// Get-ScriptAnalyzerRule -RuleExtension "ContosoAnalyzerRules", "C:\Temp\ExtendScriptAnalyzerRules.dll"

// Get-ScriptAnalyzerRule -RuleExtension "ContosoAnalyzerRules", "C:\Temp\"

continue;

}

}

// Gets valid dll paths

foreach (string childPath in path.Except<string>(validModPaths))

{

try

{

string resolvedPath = basePath

.GetResolvedPSPathFromPSPath(childPath).First().ToString();

this.outputWriter.WriteDebug(string.Format(CultureInfo.CurrentCulture, Strings.CheckAssemblyFile, resolvedPath));

if (String.Equals(Path.GetExtension(resolvedPath), ".dll", StringComparison.OrdinalIgnoreCase))

{

if (!File.Exists(resolvedPath))

{

invalidPaths.Add(resolvedPath);

continue;

}

}

else

{

if (!Directory.Exists(resolvedPath))

{

invalidPaths.Add(resolvedPath);

continue;

}

}