private static Collection <string> GetMatchingPathsInDirectory( string pattern, string directory) { Collection <string> collection = new Collection <string>(); try { CommandDiscovery.discoveryTracer.WriteLine("Looking for {0} in {1}", (object)pattern, (object)directory); collection = SessionStateUtilities.ConvertArrayToCollection <string>(Directory.GetFiles(directory, pattern)); } catch (ArgumentException ex) { CommandPathSearch.tracer.TraceException((Exception)ex); CommandDiscovery.discoveryTracer.TraceException((Exception)ex); } catch (IOException ex) { CommandPathSearch.tracer.TraceException((Exception)ex); CommandDiscovery.discoveryTracer.TraceException((Exception)ex); } catch (UnauthorizedAccessException ex) { CommandPathSearch.tracer.TraceException((Exception)ex); CommandDiscovery.discoveryTracer.TraceException((Exception)ex); } catch (NotSupportedException ex) { CommandPathSearch.tracer.TraceException((Exception)ex); CommandDiscovery.discoveryTracer.TraceException((Exception)ex); } return(collection); }
internal List <PSModuleInfo> GetModules(string[] patterns, bool all) { if (patterns == null) { patterns = new string[1] { "*" } } ; List <WildcardPattern> wildcardPatternList = new List <WildcardPattern>(); foreach (string pattern in patterns) { wildcardPatternList.Add(new WildcardPattern(pattern, WildcardOptions.IgnoreCase)); } List <PSModuleInfo> psModuleInfoList = new List <PSModuleInfo>(); if (all) { foreach (string key in this.ModuleTable.Keys) { PSModuleInfo psModuleInfo = this.ModuleTable[key]; if (SessionStateUtilities.MatchesAnyWildcardPattern(psModuleInfo.Name, (IEnumerable <WildcardPattern>)wildcardPatternList, false)) { psModuleInfoList.Add(psModuleInfo); } } } else { Dictionary <string, bool> dictionary = new Dictionary <string, bool>((IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase); foreach (string key in this._context.EngineSessionState.ModuleTable.Keys) { PSModuleInfo psModuleInfo = this._context.EngineSessionState.ModuleTable[key]; if (SessionStateUtilities.MatchesAnyWildcardPattern(psModuleInfo.Name, (IEnumerable <WildcardPattern>)wildcardPatternList, false)) { psModuleInfoList.Add(psModuleInfo); dictionary[key] = true; } } if (this._context.EngineSessionState != this._context.TopLevelSessionState) { foreach (string key in this._context.TopLevelSessionState.ModuleTable.Keys) { if (!dictionary.ContainsKey(key)) { PSModuleInfo psModuleInfo = this.ModuleTable[key]; if (SessionStateUtilities.MatchesAnyWildcardPattern(psModuleInfo.Name, (IEnumerable <WildcardPattern>)wildcardPatternList, false)) { psModuleInfoList.Add(psModuleInfo); } } } } } return(psModuleInfoList); }
private static Collection <string> GetMatchingPathsInDirectory(string pattern, string directory, bool allowAnyExtension, HashSet <string> allowedExtensions) { Collection <string> collection = new Collection <string>(); try { CommandDiscovery.discoveryTracer.WriteLine("Looking for {0} in {1}", new object[] { pattern, directory }); if (!Directory.Exists(directory)) { return(collection); } string[] files = null; if (!".".Equals(pattern, StringComparison.OrdinalIgnoreCase)) { files = Directory.GetFiles(directory, pattern); } List <string> list = null; if (files != null) { list = new List <string>(); if (allowAnyExtension) { list.AddRange(files); } else { foreach (string str in files) { string extension = Path.GetExtension(str); if (!string.IsNullOrEmpty(extension) && allowedExtensions.Contains(extension)) { list.Add(str); } } } } collection = SessionStateUtilities.ConvertListToCollection <string>(list); } catch (ArgumentException) { } catch (IOException) { } catch (UnauthorizedAccessException) { } catch (NotSupportedException) { } return(collection); }
internal ScriptAnalysis(string path) { ModuleIntrinsics.Tracer.WriteLine("Analyzing path: " + path, new object[0]); string input = File.ReadAllText(path); Token[] tokens = null; ParseError[] errors = null; Ast ast = Parser.ParseInput(input, out tokens, out errors); ExportVisitor astVisitor = new ExportVisitor(); ast.Visit(astVisitor); this.DiscoveredExports = astVisitor.DiscoveredExports; this.DiscoveredAliases = new Dictionary <string, string>(); this.DiscoveredModules = astVisitor.DiscoveredModules; this.DiscoveredCommandFilters = astVisitor.DiscoveredCommandFilters; if (this.DiscoveredCommandFilters.Count == 0) { this.DiscoveredCommandFilters.Add("*"); } else { List <WildcardPattern> patterns = new List <WildcardPattern>(); foreach (string str2 in this.DiscoveredCommandFilters) { patterns.Add(new WildcardPattern(str2)); } foreach (string str3 in astVisitor.DiscoveredAliases.Keys) { if (SessionStateUtilities.MatchesAnyWildcardPattern(str3, patterns, false)) { this.DiscoveredAliases[str3] = astVisitor.DiscoveredAliases[str3]; } } } this.AddsSelfToPath = astVisitor.AddsSelfToPath; }
internal static ScriptAnalysis Analyze(string path, ExecutionContext context) { ModuleIntrinsics.Tracer.WriteLine("Analyzing path: {0}", path); try { if (Utils.PathIsUnc(path) && (context.CurrentCommandProcessor.CommandRuntime != null)) { ProgressRecord analysisProgress = new ProgressRecord(0, Modules.ScriptAnalysisPreparing, string.Format(CultureInfo.InvariantCulture, Modules.ScriptAnalysisModule, path)); analysisProgress.RecordType = ProgressRecordType.Processing; // Write the progress using a static source ID so that all // analysis messages get single-threaded in the progress pane (rather than nesting). context.CurrentCommandProcessor.CommandRuntime.WriteProgress(typeof(ScriptAnalysis).FullName.GetHashCode(), analysisProgress); } } catch (InvalidOperationException) { // This may be called when we are not allowed to write progress, // So eat the invalid operation } string scriptContent = ReadScript(path); ParseError[] errors; var moduleAst = (new Parser()).Parse(path, scriptContent, null, out errors, ParseMode.ModuleAnalysis); // Don't bother analyzing if there are syntax errors (we don't do semantic analysis which would // detect other errors that we also might choose to ignore, but it's slower.) if (errors.Length > 0) { return(null); } ExportVisitor exportVisitor = new ExportVisitor(forCompletion: false); moduleAst.Visit(exportVisitor); var result = new ScriptAnalysis { DiscoveredClasses = exportVisitor.DiscoveredClasses, DiscoveredExports = exportVisitor.DiscoveredExports, DiscoveredAliases = new Dictionary <string, string>(), DiscoveredModules = exportVisitor.DiscoveredModules, DiscoveredCommandFilters = exportVisitor.DiscoveredCommandFilters, AddsSelfToPath = exportVisitor.AddsSelfToPath }; if (result.DiscoveredCommandFilters.Count == 0) { result.DiscoveredCommandFilters.Add("*"); } else { // Post-process aliases, as they are not exported by default List <WildcardPattern> patterns = new List <WildcardPattern>(); foreach (string discoveredCommandFilter in result.DiscoveredCommandFilters) { patterns.Add(WildcardPattern.Get(discoveredCommandFilter, WildcardOptions.IgnoreCase)); } foreach (var pair in exportVisitor.DiscoveredAliases) { string discoveredAlias = pair.Key; if (SessionStateUtilities.MatchesAnyWildcardPattern(discoveredAlias, patterns, defaultValue: false)) { result.DiscoveredAliases[discoveredAlias] = pair.Value; } } } return(result); }
private static ConcurrentDictionary <string, CommandTypes> AnalyzeScriptModule(string modulePath, ExecutionContext context, DateTime lastWriteTime) { var scriptAnalysis = ScriptAnalysis.Analyze(modulePath, context); if (scriptAnalysis == null) { return(null); } List <WildcardPattern> scriptAnalysisPatterns = new List <WildcardPattern>(); foreach (string discoveredCommandFilter in scriptAnalysis.DiscoveredCommandFilters) { scriptAnalysisPatterns.Add(new WildcardPattern(discoveredCommandFilter)); } var result = new ConcurrentDictionary <string, CommandTypes>(3, scriptAnalysis.DiscoveredExports.Count + scriptAnalysis.DiscoveredAliases.Count, StringComparer.OrdinalIgnoreCase); // Add any directly discovered exports foreach (var command in scriptAnalysis.DiscoveredExports) { if (SessionStateUtilities.MatchesAnyWildcardPattern(command, scriptAnalysisPatterns, true)) { if (command.IndexOfAny(InvalidCommandNameCharacters) < 0) { result[command] = CommandTypes.Function; } } } // Add the discovered aliases foreach (var pair in scriptAnalysis.DiscoveredAliases) { var commandName = pair.Key; // These are already filtered if (commandName.IndexOfAny(InvalidCommandNameCharacters) < 0) { result.AddOrUpdate(commandName, CommandTypes.Alias, (_, existingCommandType) => existingCommandType | CommandTypes.Alias); } } // Add any files in PsScriptRoot if it added itself to the path if (scriptAnalysis.AddsSelfToPath) { string baseDirectory = Path.GetDirectoryName(modulePath); try { foreach (string item in Directory.GetFiles(baseDirectory, "*.ps1")) { var command = Path.GetFileNameWithoutExtension(item); result.AddOrUpdate(command, CommandTypes.ExternalScript, (_, existingCommandType) => existingCommandType | CommandTypes.ExternalScript); } } catch (UnauthorizedAccessException) { // Consume this exception here } } var exportedClasses = new ConcurrentDictionary <string, TypeAttributes>( /*concurrency*/ 1, scriptAnalysis.DiscoveredClasses.Count, StringComparer.OrdinalIgnoreCase); foreach (var exportedClass in scriptAnalysis.DiscoveredClasses) { exportedClasses[exportedClass.Name] = exportedClass.TypeAttributes; } var moduleCacheEntry = new ModuleCacheEntry { ModulePath = modulePath, LastWriteTime = lastWriteTime, Commands = result, TypesAnalyzed = true, Types = exportedClasses }; s_cacheData.Entries[modulePath] = moduleCacheEntry; return(result); }
private bool MatchKeyPattern(IEnumerable <WildcardPattern> patternList, string key) { return(SessionStateUtilities.MatchesAnyWildcardPattern(key, patternList, true)); }
private IEnumerable <WildcardPattern> CreateKeyPatternList(string pattern) { WildcardOptions options = WildcardOptions.CultureInvariant | WildcardOptions.IgnoreCase; return(SessionStateUtilities.CreateWildcardsFromStrings(new string[] { pattern }, options)); }
internal static void ExportModuleMembers( PSCmdlet cmdlet, SessionStateInternal sessionState, List <WildcardPattern> functionPatterns, List <WildcardPattern> cmdletPatterns, List <WildcardPattern> aliasPatterns, List <WildcardPattern> variablePatterns) { sessionState.UseExportList = true; if (functionPatterns != null) { foreach (KeyValuePair <string, FunctionInfo> keyValuePair in (IEnumerable <KeyValuePair <string, FunctionInfo> >)sessionState.ModuleScope.FunctionTable) { if (SessionStateUtilities.MatchesAnyWildcardPattern(keyValuePair.Key, (IEnumerable <WildcardPattern>)functionPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingFunction", (object)keyValuePair.Key); cmdlet.WriteVerbose(text); sessionState.ExportedFunctions.Add(keyValuePair.Value); } } ModuleIntrinsics.SortAndRemoveDuplicates <FunctionInfo>(sessionState.ExportedFunctions, (Converter <FunctionInfo, string>)(ci => ci.Name)); } if (cmdletPatterns != null) { IDictionary <string, List <CmdletInfo> > cmdletCache = (IDictionary <string, List <CmdletInfo> >)sessionState.CmdletCache; if (sessionState.Module.CompiledExports.Count > 0) { CmdletInfo[] array = sessionState.Module.CompiledExports.ToArray(); sessionState.Module.CompiledExports.Clear(); foreach (CmdletInfo cmdletInfo1 in array) { if (SessionStateUtilities.MatchesAnyWildcardPattern(cmdletInfo1.Name, (IEnumerable <WildcardPattern>)cmdletPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingCmdlet", (object)cmdletInfo1.Name); cmdlet.WriteVerbose(text); CmdletInfo cmdletInfo2 = new CmdletInfo(cmdletInfo1.Name, cmdletInfo1.ImplementingType, cmdletInfo1.HelpFile, (PSSnapInInfo)null, cmdletInfo1.Context); cmdletInfo2.SetModule(sessionState.Module); sessionState.Module.CompiledExports.Add(cmdletInfo2); } } } foreach (KeyValuePair <string, List <CmdletInfo> > keyValuePair in (IEnumerable <KeyValuePair <string, List <CmdletInfo> > >)cmdletCache) { if (SessionStateUtilities.MatchesAnyWildcardPattern(keyValuePair.Key, (IEnumerable <WildcardPattern>)cmdletPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingCmdlet", (object)keyValuePair.Key); cmdlet.WriteVerbose(text); CmdletInfo cmdletInfo1 = keyValuePair.Value[0]; CmdletInfo cmdletInfo2 = new CmdletInfo(cmdletInfo1.Name, cmdletInfo1.ImplementingType, cmdletInfo1.HelpFile, (PSSnapInInfo)null, cmdletInfo1.Context); cmdletInfo2.SetModule(sessionState.Module); sessionState.Module.CompiledExports.Add(cmdletInfo2); } } ModuleIntrinsics.SortAndRemoveDuplicates <CmdletInfo>(sessionState.Module.CompiledExports, (Converter <CmdletInfo, string>)(ci => ci.Name)); } if (variablePatterns != null) { foreach (KeyValuePair <string, PSVariable> variable in (IEnumerable <KeyValuePair <string, PSVariable> >)sessionState.ModuleScope.Variables) { if (!variable.Value.IsAllScope && Array.IndexOf <string>(PSModuleInfo.builtinVariables, variable.Key) == -1 && SessionStateUtilities.MatchesAnyWildcardPattern(variable.Key, (IEnumerable <WildcardPattern>)variablePatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingVariable", (object)variable.Key); cmdlet.WriteVerbose(text); sessionState.ExportedVariables.Add(variable.Value); } } ModuleIntrinsics.SortAndRemoveDuplicates <PSVariable>(sessionState.ExportedVariables, (Converter <PSVariable, string>)(v => v.Name)); } if (aliasPatterns == null) { return; } foreach (AliasInfo aliasInfo in sessionState.ModuleScope.AliasTable) { if ((aliasInfo.Options & ScopedItemOptions.AllScope) == ScopedItemOptions.None && SessionStateUtilities.MatchesAnyWildcardPattern(aliasInfo.Name, (IEnumerable <WildcardPattern>)aliasPatterns, false)) { string text = ResourceManagerCache.FormatResourceString("Modules", "ExportingAlias", (object)aliasInfo.Name); cmdlet.WriteVerbose(text); sessionState.ExportedAliases.Add(aliasInfo); } } ModuleIntrinsics.SortAndRemoveDuplicates <AliasInfo>(sessionState.ExportedAliases, (Converter <AliasInfo, string>)(ci => ci.Name)); }
internal static Collection <WildcardPattern> CreateWildcardsFromStrings( string[] globPatterns, WildcardOptions options) { return(SessionStateUtilities.CreateWildcardsFromStrings(SessionStateUtilities.ConvertArrayToCollection <string>(globPatterns), options)); }
private List <PSModuleInfo> GetModuleCore(string[] patterns, bool all, bool exactMatch) { string str = null; List <WildcardPattern> list = new List <WildcardPattern>(); if (exactMatch) { str = patterns[0]; } else { if (patterns == null) { patterns = new string[] { "*" }; } foreach (string str2 in patterns) { list.Add(new WildcardPattern(str2, WildcardOptions.IgnoreCase)); } } List <PSModuleInfo> list2 = new List <PSModuleInfo>(); if (all) { foreach (string str3 in this.ModuleTable.Keys) { PSModuleInfo item = this.ModuleTable[str3]; if ((exactMatch && item.Name.Equals(str, StringComparison.OrdinalIgnoreCase)) || (!exactMatch && SessionStateUtilities.MatchesAnyWildcardPattern(item.Name, list, false))) { list2.Add(item); } } } else { Dictionary <string, bool> dictionary = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase); foreach (string str4 in this._context.EngineSessionState.ModuleTable.Keys) { PSModuleInfo info2 = this._context.EngineSessionState.ModuleTable[str4]; if ((exactMatch && info2.Name.Equals(str, StringComparison.OrdinalIgnoreCase)) || (!exactMatch && SessionStateUtilities.MatchesAnyWildcardPattern(info2.Name, list, false))) { list2.Add(info2); dictionary[str4] = true; } } if (this._context.EngineSessionState != this._context.TopLevelSessionState) { foreach (string str5 in this._context.TopLevelSessionState.ModuleTable.Keys) { if (!dictionary.ContainsKey(str5)) { PSModuleInfo info3 = this.ModuleTable[str5]; if ((exactMatch && info3.Name.Equals(str, StringComparison.OrdinalIgnoreCase)) || (!exactMatch && SessionStateUtilities.MatchesAnyWildcardPattern(info3.Name, list, false))) { list2.Add(info3); } } } } } return((from m in list2 orderby m.Name select m).ToList <PSModuleInfo>()); }
internal static void ExportModuleMembers(PSCmdlet cmdlet, SessionStateInternal sessionState, List <WildcardPattern> functionPatterns, List <WildcardPattern> cmdletPatterns, List <WildcardPattern> aliasPatterns, List <WildcardPattern> variablePatterns, List <string> doNotExportCmdlets) { sessionState.UseExportList = true; if (functionPatterns != null) { foreach (KeyValuePair <string, FunctionInfo> pair in sessionState.ModuleScope.FunctionTable) { if (((pair.Value.Options & ScopedItemOptions.AllScope) == ScopedItemOptions.None) && SessionStateUtilities.MatchesAnyWildcardPattern(pair.Key, functionPatterns, false)) { string str; if (pair.Value.CommandType == CommandTypes.Workflow) { str = StringUtil.Format(Modules.ExportingWorkflow, pair.Key); sessionState.ExportedWorkflows.Add((WorkflowInfo)pair.Value); } else { str = StringUtil.Format(Modules.ExportingFunction, pair.Key); sessionState.ExportedFunctions.Add(pair.Value); } cmdlet.WriteVerbose(str); } } SortAndRemoveDuplicates <FunctionInfo>(sessionState.ExportedFunctions, ci => ci.Name); SortAndRemoveDuplicates <WorkflowInfo>(sessionState.ExportedWorkflows, ci => ci.Name); } if (cmdletPatterns != null) { IDictionary <string, List <CmdletInfo> > cmdletTable = sessionState.ModuleScope.CmdletTable; if (sessionState.Module.CompiledExports.Count > 0) { CmdletInfo[] infoArray = sessionState.Module.CompiledExports.ToArray(); sessionState.Module.CompiledExports.Clear(); CmdletInfo[] infoArray2 = infoArray; for (int i = 0; i < infoArray2.Length; i++) { Predicate <string> match = null; CmdletInfo element = infoArray2[i]; if (doNotExportCmdlets != null) { if (match == null) { match = cmdletName => string.Equals(element.FullName, cmdletName, StringComparison.OrdinalIgnoreCase); } if (doNotExportCmdlets.Exists(match)) { continue; } } if (SessionStateUtilities.MatchesAnyWildcardPattern(element.Name, cmdletPatterns, false)) { string text = StringUtil.Format(Modules.ExportingCmdlet, element.Name); cmdlet.WriteVerbose(text); CmdletInfo item = new CmdletInfo(element.Name, element.ImplementingType, element.HelpFile, null, element.Context); item.SetModule(sessionState.Module); sessionState.Module.CompiledExports.Add(item); } } } foreach (KeyValuePair <string, List <CmdletInfo> > pair2 in cmdletTable) { CmdletInfo cmdletToImport = pair2.Value[0]; if (((doNotExportCmdlets == null) || !doNotExportCmdlets.Exists(cmdletName => string.Equals(cmdletToImport.FullName, cmdletName, StringComparison.OrdinalIgnoreCase))) && SessionStateUtilities.MatchesAnyWildcardPattern(pair2.Key, cmdletPatterns, false)) { string str3 = StringUtil.Format(Modules.ExportingCmdlet, pair2.Key); cmdlet.WriteVerbose(str3); CmdletInfo info2 = new CmdletInfo(cmdletToImport.Name, cmdletToImport.ImplementingType, cmdletToImport.HelpFile, null, cmdletToImport.Context); info2.SetModule(sessionState.Module); sessionState.Module.CompiledExports.Add(info2); } } SortAndRemoveDuplicates <CmdletInfo>(sessionState.Module.CompiledExports, ci => ci.Name); } if (variablePatterns != null) { foreach (KeyValuePair <string, PSVariable> pair3 in sessionState.ModuleScope.Variables) { if ((!pair3.Value.IsAllScope && (Array.IndexOf <string>(PSModuleInfo._builtinVariables, pair3.Key) == -1)) && SessionStateUtilities.MatchesAnyWildcardPattern(pair3.Key, variablePatterns, false)) { string str4 = StringUtil.Format(Modules.ExportingVariable, pair3.Key); cmdlet.WriteVerbose(str4); sessionState.ExportedVariables.Add(pair3.Value); } } SortAndRemoveDuplicates <PSVariable>(sessionState.ExportedVariables, v => v.Name); } if (aliasPatterns != null) { foreach (AliasInfo info3 in sessionState.ModuleScope.AliasTable) { if (((info3.Options & ScopedItemOptions.AllScope) == ScopedItemOptions.None) && SessionStateUtilities.MatchesAnyWildcardPattern(info3.Name, aliasPatterns, false)) { string str5 = StringUtil.Format(Modules.ExportingAlias, info3.Name); cmdlet.WriteVerbose(str5); sessionState.ExportedAliases.Add(info3); } } SortAndRemoveDuplicates <AliasInfo>(sessionState.ExportedAliases, ci => ci.Name); } }