{

get

{

if (instance == null)

{

Instance = new Helper();

}

return instance;

}

internal set

{

lock (syncRoot)

{

if (instance == null)

{

instance = value;

}

}

}

CommandInvocationIntrinsics invokeCommand,

IOutputWriter outputWriter) : this()

{

this.invokeCommand = invokeCommand;

this.outputWriter = outputWriter;

{

CmdletToAliasDictionary = new Dictionary<String, List<String>>(StringComparer.OrdinalIgnoreCase);

AliasToCmdletDictionary = new Dictionary<String, String>(StringComparer.OrdinalIgnoreCase);

KeywordBlockDictionary = new Dictionary<String, List<Tuple<int, int>>>(StringComparer.OrdinalIgnoreCase);

VariableAnalysisDictionary = new Dictionary<Ast, VariableAnalysis>();

ruleArguments = new Dictionary<string, Dictionary<string, object>>(StringComparer.OrdinalIgnoreCase);

IEnumerable<CommandInfo> aliases = this.invokeCommand.GetCommands("*", CommandTypes.Alias, true);

foreach (AliasInfo aliasInfo in aliases)

{

if (!CmdletToAliasDictionary.ContainsKey(aliasInfo.Definition))

{

CmdletToAliasDictionary.Add(aliasInfo.Definition, new List<String>() { aliasInfo.Name });

}

else

{

CmdletToAliasDictionary[aliasInfo.Definition].Add(aliasInfo.Name);

}

AliasToCmdletDictionary.Add(aliasInfo.Name, aliasInfo.Definition);

}

{

if (ruleArguments.ContainsKey(ruleName))

{

return ruleArguments[ruleName];

}

return null;

{

if (ruleArgs == null)

{

return;

}

if (ruleArgs.Comparer != StringComparer.OrdinalIgnoreCase)

{

throw new ArgumentException(

"Input dictionary should have OrdinalIgnoreCase comparer.",

"ruleArgs");

}

var ruleArgsDict = new Dictionary<string, Dictionary<string, object>>();

foreach (var rule in ruleArgs.Keys)

{

var argsDict = ruleArgs[rule] as Dictionary<string, object>;

if (argsDict == null)

{

return;

}

ruleArgsDict[rule] = argsDict;

}

ruleArguments = ruleArgsDict;

{

List<String> results = new List<String>();

results.Add(Cmdlet);

if (CmdletToAliasDictionary.ContainsKey(Cmdlet))

{

results.AddRange(CmdletToAliasDictionary[Cmdlet]);

}

return results;

{

if (AliasToCmdletDictionary.ContainsKey(Alias))

{

return AliasToCmdletDictionary[Alias];

}

return String.Empty;

{

DirectoryInfo dscResourceParent = Directory.GetParent(filePath);

if (null != dscResourceParent)

{

DirectoryInfo dscResourcesFolder = Directory.GetParent(dscResourceParent.ToString());

if (null != dscResourcesFolder)

{

if (String.Equals(dscResourcesFolder.Name, "dscresources", StringComparison.OrdinalIgnoreCase))

{

// Step 2: Ensure there is a Schema.mof in the same folder as the artifact

string schemaMofParentFolder = Directory.GetParent(filePath).ToString();

string[] schemaMofFile = Directory.GetFiles(schemaMofParentFolder, "*.schema.mof");

// Ensure Schema file exists and is the only one in the DSCResource folder

if (schemaMofFile != null && schemaMofFile.Count() == 1)

{

// Run DSC Rules only on module that matches the schema.mof file name without extension

if (String.Equals(schemaMofFile[0].Replace("schema.mof", "psm1"), filePath, StringComparison.OrdinalIgnoreCase))

{

return true;

}

}

}

}

}

return false;

{

errorRecord = null;

PSModuleInfo psModuleInfo = null;

Collection<PSObject> psObj = null;

// Test-ModuleManifest is not thread safe

lock (_testModuleManifestLock)

{

using (var ps = System.Management.Automation.PowerShell.Create())

{

ps.AddCommand("Test-ModuleManifest")

.AddParameter("Path", filePath)

.AddParameter("WarningAction", ActionPreference.SilentlyContinue);

try

{

psObj = ps.Invoke();

}

catch (CmdletInvocationException e)

{

// Invoking Test-ModuleManifest on a module manifest that doesn't have all the valid keys

// throws a NullReferenceException. This is probably a bug in Test-ModuleManifest and hence

// we consume it to allow execution of the of this method.

if (e.InnerException == null || e.InnerException.GetType() != typeof(System.NullReferenceException))

{

throw;

}

}

if (ps.HadErrors && ps.Streams != null && ps.Streams.Error != null)

{

var errorRecordArr = new ErrorRecord[ps.Streams.Error.Count];

ps.Streams.Error.CopyTo(errorRecordArr, 0);

errorRecord = errorRecordArr;

}

if (psObj != null && psObj.Any() && psObj[0] != null)

{

psModuleInfo = psObj[0].ImmediateBaseObject as PSModuleInfo;

}

}

}

return psModuleInfo;

{

return errorRecord.CategoryInfo != null

&& errorRecord.CategoryInfo.Category == ErrorCategory.ResourceUnavailable

&& string.Equals("MissingMemberException", errorRecord.CategoryInfo.Reason, StringComparison.OrdinalIgnoreCase);

{

if (exprAst == null)

{

throw new ArgumentNullException("exprAst");

}

var result = new List<string>();

if (exprAst is StringConstantExpressionAst)

{

result.Add((exprAst as StringConstantExpressionAst).Value);

}

// Array of the form "v-n", "v-n1"

else if (exprAst is ArrayLiteralAst)

{

result.AddRange(Helper.Instance.GetStringsFromArrayLiteral(exprAst as ArrayLiteralAst));

}

// Array of the form @("v-n", "v-n1")

else if (exprAst is ArrayExpressionAst)

{

ArrayExpressionAst arrExAst = exprAst as ArrayExpressionAst;

if (arrExAst.SubExpression != null && arrExAst.SubExpression.Statements != null)

{

foreach (StatementAst stAst in arrExAst.SubExpression.Statements)

{

if (stAst is PipelineAst)

{

PipelineAst pipeAst = stAst as PipelineAst;

if (pipeAst.PipelineElements != null)

{

foreach (CommandBaseAst cmdBaseAst in pipeAst.PipelineElements)

{

if (cmdBaseAst is CommandExpressionAst)

{

result.AddRange(Helper.Instance.GetStringsFromArrayLiteral((cmdBaseAst as CommandExpressionAst).Expression as ArrayLiteralAst));

}

}

}

}

}

}

}

return result;

{

HashSet<string> exportedFunctions = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

List<string> exportFunctionsCmdlet = Helper.Instance.CmdletNameAndAliases("export-modulemember");

// find functions exported

IEnumerable<Ast> cmdAsts = ast.FindAll(item => item is CommandAst

&& exportFunctionsCmdlet.Contains((item as CommandAst).GetCommandName(), StringComparer.OrdinalIgnoreCase), true);

CommandInfo exportMM = Helper.Instance.GetCommandInfo("export-modulemember", CommandTypes.Cmdlet);

// switch parameters

IEnumerable<ParameterMetadata> switchParams = (exportMM != null) ? exportMM.Parameters.Values.Where<ParameterMetadata>(pm => pm.SwitchParameter) : Enumerable.Empty<ParameterMetadata>();

if (exportMM == null)

{

return exportedFunctions;

}

foreach (CommandAst cmdAst in cmdAsts)

{

if (cmdAst.CommandElements == null || cmdAst.CommandElements.Count < 2)

{

continue;

}

int i = 1;

while (i < cmdAst.CommandElements.Count)

{

CommandElementAst ceAst = cmdAst.CommandElements[i];

ExpressionAst exprAst = null;

if (ceAst is CommandParameterAst)

{

var paramAst = ceAst as CommandParameterAst;

var param = exportMM.ResolveParameter(paramAst.ParameterName);

if (param == null)

{

i += 1;

continue;

}

if (string.Equals(param.Name, "function", StringComparison.OrdinalIgnoreCase))

{

// checks for the case of -Function:"verb-nouns"

if (paramAst.Argument != null)

{

exprAst = paramAst.Argument;

}

// checks for the case of -Function "verb-nouns"

else if (i < cmdAst.CommandElements.Count - 1)

{

i += 1;

exprAst = cmdAst.CommandElements[i] as ExpressionAst;

}

}

// some other parameter. we just checks whether the one after this is positional

else if (i < cmdAst.CommandElements.Count - 1)

{

// the next element is a parameter like -module so just move to that one

if (cmdAst.CommandElements[i + 1] is CommandParameterAst)

{

i += 1;

continue;

}

// not a switch parameter so the next element is definitely the argument to this parameter

if (paramAst.Argument == null && !switchParams.Contains(param))

{

// skips the next element

i += 1;

}

i += 1;

continue;

}

}

else if (ceAst is ExpressionAst)

{

exprAst = ceAst as ExpressionAst;

}

if (exprAst != null)

{

exportedFunctions.UnionWith(Helper.Instance.GetStringsFromExpressionAst(exprAst));

}

i += 1;

}

}

return exportedFunctions;

{

return filePath != null && File.Exists(filePath) && Path.GetFileName(filePath).StartsWith("about_", StringComparison.OrdinalIgnoreCase)

&& Path.GetFileName(filePath).EndsWith(".help.txt", StringComparison.OrdinalIgnoreCase);

{

if (null == ast)

{

return false;

}

#if !(PSV3||PSV4)

List<string> dscResourceFunctionNames = new List<string>(new string[] { "Test", "Get", "Set" });

IEnumerable<Ast> dscClasses = ast.FindAll(item =>

item is TypeDefinitionAst

&& ((item as TypeDefinitionAst).IsClass)

&& (item as TypeDefinitionAst).Attributes.Any(attr => String.Equals("DSCResource", attr.TypeName.FullName, StringComparison.OrdinalIgnoreCase)), true);

// Found one or more classes marked with DscResource attribute

// So this might be a DscResource. Further validation will be performed by the individual rules

if (null != dscClasses && 0 < dscClasses.Count())

{

return true;

}

#endif

return false;

{

if (String.IsNullOrWhiteSpace(name) || scopes == null)

{

return name;

}

// checks whether function name starts with scope

foreach (string scope in scopes)

{

// trim the scope part

if (name.IndexOf(scope, StringComparison.OrdinalIgnoreCase) == 0)

{

return name.Substring(scope.Length);

}

}

// no scope

return name;

{

if (variablePath == null || variablePath.UserPath == null)

{

return null;

}

// strip out the drive if there is one

if (!string.IsNullOrWhiteSpace(variablePath.DriveName)

// checks that variable starts with drivename:

&& variablePath.UserPath.IndexOf(string.Concat(variablePath.DriveName, ":")) == 0)

{

return variablePath.UserPath.Substring(variablePath.DriveName.Length + 1);

}

return NameWithoutScope(variablePath.UserPath, variableScopes);

{

return cmdAst != null

&& cmdAst.CommandElements != null

&& cmdAst.CommandElements.Any(cmdElem =>

{

var varExprAst = cmdElem as VariableExpressionAst;

return varExprAst != null && varExprAst.Splatted;

});

{

if (cmdAst == null)

{

return false;

}

var commandInfo = GetCommandInfo(cmdAst.GetCommandName());

if (commandInfo == null)

{

return false;

}

return commandInfo.CommandType == CommandTypes.Cmdlet ||

commandInfo.CommandType == CommandTypes.Alias ||

commandInfo.CommandType == CommandTypes.ExternalScript;

{

if (HasSplattedVariable(cmdAst))

{

return false;

}

// Because of the way we count, we will also count the cmdlet as an argument so we have to -1

int argumentsWithoutProcedingParameters = 0;

var commandElementCollection = cmdAst.CommandElements;

for (int i = 1; i < commandElementCollection.Count(); i++) {

if (!(commandElementCollection[i] is CommandParameterAst) && !(commandElementCollection[i-1] is CommandParameterAst))

{

argumentsWithoutProcedingParameters++;

}

}

// if not the first element in a pipeline, increase the number of arguments by 1

PipelineAst parent = cmdAst.Parent as PipelineAst;

if (parent != null && parent.PipelineElements.Count > 1 && parent.PipelineElements[0] != cmdAst)

{

argumentsWithoutProcedingParameters++;

}

return moreThanTwoPositional ? argumentsWithoutProcedingParameters > 2 : argumentsWithoutProcedingParameters > 0;

{

List<string> resourceFunctionNames = new List<string>(new string[] { "Set-TargetResource", "Get-TargetResource", "Test-TargetResource" });

return ast.FindAll(item => item is FunctionDefinitionAst

&& resourceFunctionNames.Contains((item as FunctionDefinitionAst).Name, StringComparer.OrdinalIgnoreCase), true);

{

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

if (alAst != null && alAst.Elements != null)

{

foreach (ExpressionAst eAst in alAst.Elements)

{

if (eAst is StringConstantExpressionAst)

{

result.Add((eAst as StringConstantExpressionAst).Value);

}

}

}

return result;

{

if (namedBlockAst == null)

{

return false;

}

FindClosingParenthesis(keyword);

List<Tuple<int, int>> listTuples = KeywordBlockDictionary[keyword];

if (listTuples == null || listTuples.Count == 0)

{

return false;

}

int index = listTuples.BinarySearch(Tuple.Create(namedBlockAst.Extent.StartOffset, namedBlockAst.Extent.EndOffset), tupleComparer);

if (index < 0 || index >= Tokens.Length)

{

return false;

}

Tuple<int, int> braces = listTuples[index];

if (braces.Item2 == namedBlockAst.Extent.EndOffset)

{

return true;

}

return false;

{

if (null == functionDefinitionAst)

{

return null;

}

var funcNameTokens = Tokens.Where(

token =>

ContainsExtent(functionDefinitionAst.Extent, token.Extent)

&& token.Text.Equals(functionDefinitionAst.Name));

var funcNameToken = funcNameTokens.FirstOrDefault();

return funcNameToken == null ? null : funcNameToken.Extent;

{

if (set == null || subset == null)

{

return false;

}

return set.StartOffset <= subset.StartOffset

&& set.EndOffset >= subset.EndOffset;

{

if (Tokens == null || Tokens.Length == 0)

{

return;

}

// Only do this one time per script. The keywordblockdictionary is cleared everytime we run a new script

if (KeywordBlockDictionary.ContainsKey(keyword))

{

return;

}

KeywordBlockDictionary[keyword] = new List<Tuple<int, int>>();

int[] tokenIndices = Tokens

.Select((token, index) =>

String.Equals(token.Text, keyword, StringComparison.OrdinalIgnoreCase) && (token.TokenFlags == TokenFlags.Keyword || token.TokenFlags == TokenFlags.CommandName)

? index : -1)

.Where(index => index != -1).ToArray();

foreach (int tokenIndex in tokenIndices)

{

int openCurly = -1;

for (int i = tokenIndex; i < Tokens.Length; i += 1)

{

if (Tokens[i] != null && Tokens[i].Kind == TokenKind.LCurly)

{

openCurly = i;

break;

}

}

if (openCurly == -1)

{

continue;

}

int closeCurly = -1;

int count = 1;

for (int i = openCurly + 1; i < Tokens.Length; i += 1)

{

if (Tokens[i] != null)

{

if (Tokens[i].Kind == TokenKind.LCurly)

{

count += 1;

}

else if (Tokens[i].Kind == TokenKind.RCurly)

{

count -= 1;

}

}

if (count == 0)

{

closeCurly = i;

break;

}

}

if (closeCurly == -1)

{

continue;

}

KeywordBlockDictionary[keyword].Add(Tuple.Create(Tokens[openCurly].Extent.StartOffset,

Tokens[closeCurly].Extent.EndOffset));

}

{

if (!VariableAnalysisDictionary.ContainsKey(ast) || VariableAnalysisDictionary[ast] == null)

{

return false;

}

return VariableAnalysisDictionary[ast].IsUninitialized(varAst);

{

if (!VariableAnalysisDictionary.ContainsKey(ast) || VariableAnalysisDictionary[ast] == null)

{

return false;

}

return VariableAnalysisDictionary[ast].IsGlobalOrEnvironment(varAst);

{

//We ignore the use of built-in variable as global variable

if (varAst.VariablePath.IsGlobal)

{

string varName = varAst.VariablePath.UserPath.Remove(varAst.VariablePath.UserPath.IndexOf("global:", StringComparison.OrdinalIgnoreCase), "global:".Length);

return !SpecialVars.InitializedVariables.Contains(varName, StringComparer.OrdinalIgnoreCase);

}

return false;

{

if (!VariableAnalysisDictionary.ContainsKey(ast))

{

return true;

}

var analysis = VariableAnalysisDictionary[ast];

return analysis.Exit._predecessors.All(block => block._returns || block._unreachable || block._throws);

{

var VarAnalysis = new VariableAnalysis(new FlowGraph());

VarAnalysis.AnalyzeImpl(ast, outerAnalysis);