public virtual IUiEltCollection this[string infoString]
{
get
{
if (string.IsNullOrEmpty(infoString)) return null;
try {
if (null == this || 0 == this.Count) return null;
const WildcardOptions options = WildcardOptions.IgnoreCase |
WildcardOptions.Compiled;
var wildcardInfoString =
new WildcardPattern(infoString, options);
var queryByStringData = from collectionItem
in this._collectionHolder //.ToArray()
where wildcardInfoString.IsMatch(collectionItem.GetCurrent().Name) ||
wildcardInfoString.IsMatch(collectionItem.GetCurrent().AutomationId) ||
wildcardInfoString.IsMatch(collectionItem.GetCurrent().ClassName)
select collectionItem;
return AutomationFactory.GetUiEltCollection(queryByStringData);
}
catch {
return null;
// return new IUiElement[] {};
}
}
}
protected override void ProcessRecord()
{
if (String.IsNullOrEmpty(Property))
{
if (Object == null)
{
WriteObject(_existingProperties, true);
}
else
{
WriteObject(Object.Properties, true);
}
return;
}
var wildcard = new WildcardPattern(Property + "*", WildcardOptions.IgnoreCase);
if (Object == null)
{
WriteObject(from pair in _existingProperties
where wildcard.IsMatch(pair.Key)
select pair.Value, true);
}
else
{
WriteObject(from prop in Object.Properties
where wildcard.IsMatch(prop.LocalName)
select prop, true);
}
}
protected override void ProcessRecord()
{
string[] templateFiles = XamlHelper.GetDataTemplates();
foreach (string path in Filter)
{
var pat = new WildcardPattern(path);
foreach (var file in templateFiles)
{
if (pat.IsMatch(file) || pat.IsMatch( Path.GetDirectoryName(file) ))
{
WriteObject(new FileInfo(file));
}
}
}
}
private IEnumerable<PSModuleInfo> GetLoadedModulesByWildcard(string wildcardStr)
{
var wildcard = new WildcardPattern(wildcardStr, WildcardOptions.IgnoreCase);
var modules = from modPair in ExecutionContext.SessionState.LoadedModules.GetAll()
where wildcard.IsMatch(modPair.Value.Name) select modPair.Value;
return modules;
}
IEnumerable<DynamicMemberDescriptor> AddWildcardDynamicMembers(DynamicMemberSpecification spec, WildcardPattern pattern, PSObject ps, string proxyPropertyName)
{
var props = ps.Properties;
var scriptFormat = "$this.'{0}'";
if (null != proxyPropertyName)
{
props = ps.Properties[proxyPropertyName].ToPSObject().Properties;
scriptFormat = "$this.'{1}'.'{0}'";
}
var matchingPropertyNames = from prop in props
where pattern.IsMatch(prop.Name)
select prop.Name;
var members = matchingPropertyNames.ToList().ConvertAll(
s => new
{
PropertyName = s,
Member = new PSScriptProperty(
(proxyPropertyName ?? "" ) + "_" + s,
System.Management.Automation.ScriptBlock.Create(String.Format(scriptFormat, s,
proxyPropertyName))
)
});
return (from m in members
let s = (from sd in spec.ScaleDescriptors
where sd.Key.IsMatch(m.PropertyName)
select sd.Value).FirstOrDefault()
select new DynamicMemberDescriptor(m.Member, s)).ToList();
}
internal override PSObject[] GetParameter(string pattern)
{
if (((this.FullHelp == null) || (this.FullHelp.Properties["parameters"] == null)) || (this.FullHelp.Properties["parameters"].Value == null))
{
return base.GetParameter(pattern);
}
PSObject obj2 = PSObject.AsPSObject(this.FullHelp.Properties["parameters"].Value);
if (obj2.Properties["parameter"] == null)
{
return base.GetParameter(pattern);
}
PSObject[] objArray = (PSObject[]) LanguagePrimitives.ConvertTo(obj2.Properties["parameter"].Value, typeof(PSObject[]), CultureInfo.InvariantCulture);
if (string.IsNullOrEmpty(pattern))
{
return objArray;
}
List<PSObject> list = new List<PSObject>();
WildcardPattern pattern2 = new WildcardPattern(pattern, WildcardOptions.IgnoreCase);
foreach (PSObject obj3 in objArray)
{
if ((obj3.Properties["name"] != null) && (obj3.Properties["name"].Value != null))
{
string input = obj3.Properties["name"].Value.ToString();
if (pattern2.IsMatch(input))
{
list.Add(obj3);
}
}
}
return list.ToArray();
}
// Returns a RoleNamesCollection based on instances in the roleInstanceList
// whose RoleInstance.RoleName matches the roleName passed in. Wildcards
// are handled for the roleName passed in.
// This function also verifies that the RoleInstance exists before adding the
// RoleName to the RoleNamesCollection.
public static RoleNamesCollection GetRoleNames(RoleInstanceList roleInstanceList, string roleName)
{
var roleNamesCollection = new RoleNamesCollection();
if (!string.IsNullOrEmpty(roleName))
{
if (WildcardPattern.ContainsWildcardCharacters(roleName))
{
WildcardOptions wildcardOptions = WildcardOptions.IgnoreCase | WildcardOptions.Compiled;
WildcardPattern wildcardPattern = new WildcardPattern(roleName, wildcardOptions);
foreach (RoleInstance role in roleInstanceList)
if (!string.IsNullOrEmpty(role.RoleName) && wildcardPattern.IsMatch(role.RoleName))
{
roleNamesCollection.Add(role.RoleName);
}
}
else
{
var roleInstance = roleInstanceList.Where(r => r.RoleName != null).
FirstOrDefault(r => r.RoleName.Equals(roleName, StringComparison.InvariantCultureIgnoreCase));
if (roleInstance != null)
{
roleNamesCollection.Add(roleName);
}
}
}
return roleNamesCollection;
}
protected override string[] ExpandPath(string path)
{
var wildcard = new WildcardPattern(path, WildcardOptions.IgnoreCase);
return (from i in _defaultDrive.Items.Keys
where wildcard.IsMatch(i)
select i).ToArray();
}
internal override bool MatchPatternInContent(WildcardPattern pattern)
{
string synopsis = this.Synopsis;
string answers = this.Answers;
if (synopsis == null)
{
synopsis = string.Empty;
}
if (this.Answers == null)
{
answers = string.Empty;
}
if (!pattern.IsMatch(synopsis))
{
return pattern.IsMatch(answers);
}
return true;
}
internal override bool MatchPatternInContent(WildcardPattern pattern)
{
string synopsis = this.Synopsis;
string detailedDescription = this.DetailedDescription;
if (synopsis == null)
{
synopsis = string.Empty;
}
if (detailedDescription == null)
{
detailedDescription = string.Empty;
}
if (!pattern.IsMatch(synopsis))
{
return pattern.IsMatch(detailedDescription);
}
return true;
}
internal Collection<PSTraceSource> GetMatchingTraceSource(string[] patternsToMatch, bool writeErrorIfMatchNotFound, out Collection<string> notMatched)
{
notMatched = new Collection<string>();
Collection<PSTraceSource> collection = new Collection<PSTraceSource>();
foreach (string str in patternsToMatch)
{
bool flag = false;
if (string.IsNullOrEmpty(str))
{
notMatched.Add(str);
}
else
{
WildcardPattern pattern = new WildcardPattern(str, WildcardOptions.IgnoreCase);
foreach (PSTraceSource source in PSTraceSource.TraceCatalog.Values)
{
if (pattern.IsMatch(source.FullName))
{
flag = true;
collection.Add(source);
}
else if (pattern.IsMatch(source.Name))
{
flag = true;
collection.Add(source);
}
}
if (!flag)
{
notMatched.Add(str);
if (writeErrorIfMatchNotFound && !WildcardPattern.ContainsWildcardCharacters(str))
{
ItemNotFoundException replaceParentContainsErrorRecordException = new ItemNotFoundException(str, "TraceSourceNotFound", SessionStateStrings.TraceSourceNotFound);
ErrorRecord errorRecord = new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException);
base.WriteError(errorRecord);
}
}
}
}
return collection;
}
internal Collection<PSSnapInInfo> GetPSSnapIns(WildcardPattern wildcard)
{
Collection<PSSnapInInfo> matches = new Collection<PSSnapInInfo>();
foreach (var pair in _snapins)
{
if (wildcard.IsMatch(pair.Key))
{
matches.Add(pair.Value);
}
}
return matches;
}
private static bool Match(string target, string pattern)
{
if (string.IsNullOrEmpty(pattern))
{
return true;
}
if (string.IsNullOrEmpty(target))
{
target = "";
}
WildcardPattern pattern2 = new WildcardPattern(pattern, WildcardOptions.IgnoreCase);
return pattern2.IsMatch(target);
}
internal void Extract(string entryPath)
{
if (WildcardPattern.ContainsWildcardCharacters(entryPath))
{
Command.WriteVerbose("Using wildcard extraction.");
var pattern = new WildcardPattern(entryPath, WildcardOptions.IgnoreCase);
Extract(entry => pattern.IsMatch(entry.Path));
}
else
{
// todo: fix ignorecase
Extract(entry => entry.Path.Equals(entryPath,
StringComparison.OrdinalIgnoreCase));
}
}
protected override void ProcessRecord()
{
if (Id.HasValue)
{
WriteObject(_controller.GetDevice(Id.Value));
}
else
{
var wildCard = new WildcardPattern(Name, WildcardOptions.IgnoreCase);
WriteObject(
_controller.GetDevices()
.FirstOrDefault(x => wildCard.IsMatch(x.Name)));
}
}
public static IEnumerable <IPackage> FilterOnName(IEnumerable <IPackage> pkgs, string searchTerm, bool useWildCard)
{
if (useWildCard)
{
// Applying the wildcard pattern matching
const SMA.WildcardOptions wildcardOptions = SMA.WildcardOptions.CultureInvariant | SMA.WildcardOptions.IgnoreCase;
var wildcardPattern = new SMA.WildcardPattern(searchTerm, wildcardOptions);
return(pkgs.Where(p => wildcardPattern.IsMatch(p.Id)));
}
else
{
return(pkgs.Where(each => each.Id.IndexOf(searchTerm, StringComparison.OrdinalIgnoreCase) > -1));
}
}
// 20140215
// public static IEnumerable GetElementsByWildcard(this IUiEltCollection collection, string name, string automationId, string className, string txtValue, bool caseSensitive = false)
public static IEnumerable GetElementsByWildcard(this IUiEltCollection collection, string name, string automationId, string className, string txtValue, bool caseSensitive)
{
WildcardOptions options;
if (caseSensitive) {
options =
WildcardOptions.Compiled;
} else {
options =
WildcardOptions.IgnoreCase |
WildcardOptions.Compiled;
}
List<IUiElement> list = collection.Cast<IUiElement>().ToList();
var wildcardName =
new WildcardPattern((string.IsNullOrEmpty(name) ? "*" : name), options);
var wildcardAutomationId =
new WildcardPattern((string.IsNullOrEmpty(automationId) ? "*" : automationId), options);
var wildcardClassName =
new WildcardPattern((string.IsNullOrEmpty(className) ? "*" : className), options);
var wildcardValue =
new WildcardPattern((string.IsNullOrEmpty(txtValue) ? "*" : txtValue), options);
var queryByBigFour = from collectionItem
in list
// 20140312
// where wildcardName.IsMatch(collectionItem.Current.Name) &&
// wildcardAutomationId.IsMatch(collectionItem.Current.AutomationId) &&
// wildcardClassName.IsMatch(collectionItem.Current.ClassName) &&
where wildcardName.IsMatch(collectionItem.GetCurrent().Name) &&
wildcardAutomationId.IsMatch(collectionItem.GetCurrent().AutomationId) &&
wildcardClassName.IsMatch(collectionItem.GetCurrent().ClassName) &&
// 20131209
// (collectionItem.GetSupportedPatterns().Contains(classic.ValuePattern.Pattern) ?
(collectionItem.GetSupportedPatterns().AsQueryable<IBasePattern>().Any<IBasePattern>(p => p is IValuePattern) ?
// 20131208
// wildcardValue.IsMatch((collectionItem.GetCurrentPattern(classic.ValuePattern.Pattern) as IValuePattern).Current.Value) :
// wildcardValue.IsMatch((collectionItem.GetCurrentPattern<IValuePattern, ValuePattern>(classic.ValuePattern.Pattern) as IValuePattern).Current.Value) :
wildcardValue.IsMatch(collectionItem.GetCurrentPattern<IValuePattern>(classic.ValuePattern.Pattern).Current.Value) :
// check whether the -Value parameter has or hasn't value
("*" == txtValue ? true : false))
select collectionItem;
// disposal
list = null;
return queryByBigFour;
}
/// <summary>
/// Returns help information for a parameter(s) identified by pattern
/// </summary>
/// <param name="pattern">pattern to search for parameters</param>
/// <returns>A collection of parameters that match pattern</returns>
internal override PSObject[] GetParameter(string pattern)
{
// this object knows Maml format...
// So retrieve parameter information as per the format..
if ((this.FullHelp == null) ||
(this.FullHelp.Properties["parameters"] == null) ||
(this.FullHelp.Properties["parameters"].Value == null))
{
// return the default..
return(base.GetParameter(pattern));
}
PSObject prmts = PSObject.AsPSObject(this.FullHelp.Properties["parameters"].Value);
if (prmts.Properties["parameter"] == null)
{
return(base.GetParameter(pattern));
}
PSObject[] prmtArray = (PSObject[])LanguagePrimitives.ConvertTo(
prmts.Properties["parameter"].Value,
typeof(PSObject[]),
CultureInfo.InvariantCulture);
if (string.IsNullOrEmpty(pattern))
{
return(prmtArray);
}
List <PSObject> returnList = new List <PSObject>();
WildcardPattern matcher = WildcardPattern.Get(pattern, WildcardOptions.IgnoreCase);
foreach (PSObject prmtr in prmtArray)
{
if ((prmtr.Properties["name"] == null) || (prmtr.Properties["name"].Value == null))
{
continue;
}
string prmName = prmtr.Properties["name"].Value.ToString();
if (matcher.IsMatch(prmName))
{
returnList.Add(prmtr);
}
}
return(returnList.ToArray());
}
protected override void ProcessRecord()
{
var config = GetConfiguration();
var devices = config.Devices;
if (!String.IsNullOrEmpty(Name))
{
var pattern = new WildcardPattern(Name, WildcardOptions.IgnoreCase);
devices = devices.Where(d => pattern.IsMatch(d.Name));
}
foreach (var device in devices)
{
WriteObject(device);
}
}
private static bool Match(string target, string pattern)
{
if (string.IsNullOrEmpty(pattern))
{
return(true);
}
if (string.IsNullOrEmpty(target))
{
target = string.Empty;
}
WildcardPattern matcher = WildcardPattern.Get(pattern, WildcardOptions.IgnoreCase);
return(matcher.IsMatch(target));
}
private bool FindTypeByModulePath(WildcardPattern classNameMatcher)
{
bool matchFound = false;
var moduleList = ModuleUtils.GetDefaultAvailableModuleFiles(isForAutoDiscovery: false, _context);
foreach (var modulePath in moduleList)
{
string expandedModulePath = IO.Path.GetFullPath(modulePath);
var cachedClasses = AnalysisCache.GetExportedClasses(expandedModulePath, _context);
if (cachedClasses != null)
{
//Exact match
if (!_useWildCards)
{
if (cachedClasses.ContainsKey(_className))
{
var classInfo = CachedItemToPSClassInfo(classNameMatcher, modulePath);
if (classInfo != null)
{
_matchingClassList.Add(classInfo);
matchFound = true;
}
}
}
else
{
foreach (var className in cachedClasses.Keys)
{
if (classNameMatcher.IsMatch(className))
{
var classInfo = CachedItemToPSClassInfo(classNameMatcher, modulePath);
if (classInfo != null)
{
_matchingClassList.Add(classInfo);
matchFound = true;
}
}
}
}
}
}
return(matchFound);
}
private CommandInfo GetNextFunction()
{
CommandInfo current = null;
if ((this.commandResolutionOptions & SearchResolutionOptions.ResolveFunctionPatterns) != SearchResolutionOptions.None)
{
if (this.matchingFunctionEnumerator == null)
{
Collection <CommandInfo> collection = new Collection <CommandInfo>();
WildcardPattern pattern = new WildcardPattern(this.commandName, WildcardOptions.IgnoreCase);
foreach (DictionaryEntry entry in this._context.EngineSessionState.GetFunctionTable())
{
if (pattern.IsMatch((string)entry.Key))
{
collection.Add((CommandInfo)entry.Value);
}
}
CommandInfo functionFromModules = this.GetFunctionFromModules(this.commandName);
if (functionFromModules != null)
{
collection.Add(functionFromModules);
}
this.matchingFunctionEnumerator = collection.GetEnumerator();
}
if (!this.matchingFunctionEnumerator.MoveNext())
{
this.currentState = SearchState.SearchingCmdlets;
this.matchingFunctionEnumerator = null;
}
else
{
current = this.matchingFunctionEnumerator.Current;
}
}
else
{
this.currentState = SearchState.SearchingCmdlets;
current = this.GetFunction(this.commandName);
}
if ((current != null) && ((((PSLanguageMode)current.DefiningLanguageMode) == PSLanguageMode.ConstrainedLanguage) && (this._context.LanguageMode == PSLanguageMode.FullLanguage)))
{
current = null;
}
return(current);
}
private bool CheckTypeNames(JobSourceAdapter sourceAdapter, string[] jobSourceAdapterTypes)
{
if ((jobSourceAdapterTypes == null) || (jobSourceAdapterTypes.Length == 0))
{
return(true);
}
string adapterName = this.GetAdapterName(sourceAdapter);
foreach (string str2 in jobSourceAdapterTypes)
{
WildcardPattern pattern = new WildcardPattern(str2, WildcardOptions.IgnoreCase);
if (pattern.IsMatch(adapterName))
{
return(true);
}
}
return(false);
}
private CmdletInfo GetNextCmdlet()
{
CmdletInfo result = null;
if (this.matchingCmdlet == null)
{
if ((this.commandResolutionOptions & SearchResolutionOptions.CommandNameIsPattern) != SearchResolutionOptions.None)
{
Collection <CmdletInfo> collection = new Collection <CmdletInfo>();
PSSnapinQualifiedName instance = PSSnapinQualifiedName.GetInstance(this.commandName);
if (instance == null)
{
return(result);
}
WildcardPattern pattern = new WildcardPattern(instance.ShortName, WildcardOptions.IgnoreCase);
foreach (List <CmdletInfo> list in this._context.EngineSessionState.GetCmdletTable().Values)
{
foreach (CmdletInfo info2 in list)
{
if (pattern.IsMatch(info2.Name) && (string.IsNullOrEmpty(instance.PSSnapInName) || instance.PSSnapInName.Equals(info2.ModuleName, StringComparison.OrdinalIgnoreCase)))
{
collection.Add(info2);
}
}
}
this.matchingCmdlet = collection.GetEnumerator();
}
else
{
this.matchingCmdlet = this._context.CommandDiscovery.GetCmdletInfo(this.commandName, (this.commandResolutionOptions & SearchResolutionOptions.SearchAllScopes) != SearchResolutionOptions.None);
}
}
if (!this.matchingCmdlet.MoveNext())
{
this.currentState = SearchState.SearchingBuiltinScripts;
this.matchingCmdlet = null;
}
else
{
result = this.matchingCmdlet.Current;
}
return(traceResult(result));
}
protected override void EndProcessing()
{
if (All)
{
WriteObject(Plastic.GetWorkspaces(), true);
}
else
{
var currentDir = SessionState.Path.CurrentFileSystemLocation.ProviderPath;
foreach (var wi in Plastic.GetWorkspaces())
{
var pattern = new WildcardPattern(wi.Path + "*", WildcardOptions.IgnoreCase);
if (pattern.IsMatch(currentDir))
{
WriteObject(wi);
}
}
}
}
private static IEnumerable <CimModule> GetCimModules(CimSession cimSession, Uri resourceUri, string cimNamespace, string moduleNamePattern, bool onlyManifests, Cmdlet cmdlet, CancellationToken cancellationToken)
{
Func <CimModule, CimModule> selector = null;
WildcardPattern wildcardPattern = new WildcardPattern(moduleNamePattern, WildcardOptions.CultureInvariant | WildcardOptions.IgnoreCase);
string optionValue = WildcardPatternToDosWildcardParser.Parse(wildcardPattern);
CimOperationOptions options = new CimOperationOptions {
CancellationToken = new CancellationToken?(cancellationToken)
};
options.SetCustomOption("PS_ModuleNamePattern", optionValue, false);
if (resourceUri != null)
{
options.ResourceUri = resourceUri;
}
if (string.IsNullOrEmpty(cimNamespace) && (resourceUri == null))
{
cimNamespace = "root/Microsoft/Windows/Powershellv3";
}
IEnumerable <CimModule> source = from cimInstance in cimSession.EnumerateInstances(cimNamespace, "PS_Module", options)
select new CimModule(cimInstance) into cimModule
where wildcardPattern.IsMatch(cimModule.ModuleName)
select cimModule;
if (!onlyManifests)
{
if (selector == null)
{
selector = delegate(CimModule cimModule) {
cimModule.FetchAllModuleFiles(cimSession, cimNamespace, options);
return(cimModule);
};
}
source = source.Select <CimModule, CimModule>(selector);
}
return(EnumerateWithCatch <CimModule>(source, delegate(Exception exception) {
ErrorRecord errorRecord = GetErrorRecordForRemoteDiscoveryProvider(exception);
if (!cmdlet.MyInvocation.ExpectingInput && (((-1 != errorRecord.FullyQualifiedErrorId.IndexOf("DiscoveryProviderNotFound", StringComparison.OrdinalIgnoreCase)) || cancellationToken.IsCancellationRequested) || ((exception is OperationCanceledException) || !cimSession.TestConnection())))
{
cmdlet.ThrowTerminatingError(errorRecord);
}
cmdlet.WriteError(errorRecord);
}));
}
protected internal override void BeginProcessingCore()
{
base.BeginProcessingCore();
IEnumerable<PackageSource> sources;
if (Scope == null)
{
sources = SourceService.AllSources;
}
else
{
IPackageSourceStore store = SourceService.GetSource(Scope.Value);
sources = store.Sources;
}
if (!String.IsNullOrEmpty(Name))
{
WildcardPattern pattern = new WildcardPattern(Name);
sources = sources.Where(s => pattern.IsMatch(s.Name));
}
WriteObject(sources, enumerateCollection: true);
}
protected override void ProcessRecord()
{
var repos = ConnectionFactory.GetRepositories(ConnectionParameters);
if (Name == null || Name.Length == 0)
{
Name = new [] { "" };
}
foreach (var curName in Name)
{
var pattern = "*";
if (!String.IsNullOrEmpty(curName))
{
pattern = Exact.IsPresent ? curName : curName + "*";
}
var options = Exact.IsPresent ? WildcardOptions.None : WildcardOptions.IgnoreCase;
WildcardPattern wildcard = new WildcardPattern(pattern, options);
WriteObject(from rep in repos where wildcard.IsMatch(rep.Name) select rep, true);
}
}
private ScriptInfo GetNextBuiltinScript()
{
ScriptInfo scriptInfo = null;
if ((this.commandResolutionOptions & SearchResolutionOptions.CommandNameIsPattern) != SearchResolutionOptions.None)
{
if (this.matchingScript == null)
{
Collection <string> collection = new Collection <string>();
WildcardPattern pattern = new WildcardPattern(this.commandName, WildcardOptions.IgnoreCase);
WildcardPattern pattern2 = new WildcardPattern(this.commandName + ".ps1", WildcardOptions.IgnoreCase);
foreach (string str in this._context.CommandDiscovery.ScriptCache.Keys)
{
if (pattern.IsMatch(str) || pattern2.IsMatch(str))
{
collection.Add(str);
}
}
this.matchingScript = collection.GetEnumerator();
}
if (!this.matchingScript.MoveNext())
{
this.currentState = SearchState.StartSearchingForExternalCommands;
this.matchingScript = null;
}
else
{
scriptInfo = this._context.CommandDiscovery.GetScriptInfo(this.matchingScript.Current);
}
}
else
{
this.currentState = SearchState.StartSearchingForExternalCommands;
scriptInfo = this._context.CommandDiscovery.GetScriptInfo(this.commandName) ?? this._context.CommandDiscovery.GetScriptInfo(this.commandName + ".ps1");
}
if (scriptInfo != null)
{
CommandDiscovery.discoveryTracer.WriteLine("Script found: {0}", new object[] { scriptInfo.Name });
}
return(scriptInfo);
}
private ScriptInfo GetNextBuiltinScript()
{
ScriptInfo scriptInfo = (ScriptInfo)null;
if ((this.commandResolutionOptions & SearchResolutionOptions.CommandNameIsPattern) != SearchResolutionOptions.None)
{
if (this.matchingScript == null)
{
Collection <string> collection = new Collection <string>();
WildcardPattern wildcardPattern1 = new WildcardPattern(this.commandName, WildcardOptions.IgnoreCase);
WildcardPattern wildcardPattern2 = new WildcardPattern(this.commandName + ".ps1", WildcardOptions.IgnoreCase);
foreach (string key in this._context.CommandDiscovery.ScriptCache.Keys)
{
if (wildcardPattern1.IsMatch(key) || wildcardPattern2.IsMatch(key))
{
collection.Add(key);
}
}
this.matchingScript = collection.GetEnumerator();
}
if (!this.matchingScript.MoveNext())
{
this.currentState = CommandSearcher.SearchState.BuiltinScriptResolution;
this.matchingScript = (IEnumerator <string>)null;
}
else
{
scriptInfo = this._context.CommandDiscovery.GetScriptInfo(this.matchingScript.Current);
}
}
else
{
this.currentState = CommandSearcher.SearchState.BuiltinScriptResolution;
scriptInfo = this._context.CommandDiscovery.GetScriptInfo(this.commandName) ?? this._context.CommandDiscovery.GetScriptInfo(this.commandName + ".ps1");
}
if (scriptInfo != null)
{
CommandDiscovery.discoveryTracer.WriteLine("Script found: {0}", (object)scriptInfo.Name);
}
return(scriptInfo);
}
private static void SetSnapInLoggingInformation(PSSnapInInfo psSnapInInfo, ModuleCmdletBase.ModuleLoggingGroupPolicyStatus status, IEnumerable <string> moduleOrSnapinNames)
{
if (((status & ModuleCmdletBase.ModuleLoggingGroupPolicyStatus.Enabled) != ModuleCmdletBase.ModuleLoggingGroupPolicyStatus.Undefined) && (moduleOrSnapinNames != null))
{
foreach (string str in moduleOrSnapinNames)
{
if (string.Equals(psSnapInInfo.Name, str, StringComparison.OrdinalIgnoreCase))
{
psSnapInInfo.LogPipelineExecutionDetails = true;
}
else if (WildcardPattern.ContainsWildcardCharacters(str))
{
WildcardPattern pattern = new WildcardPattern(str, WildcardOptions.IgnoreCase);
if (pattern.IsMatch(psSnapInInfo.Name))
{
psSnapInInfo.LogPipelineExecutionDetails = true;
}
}
}
}
}
/// <summary>
/// Convert the cacheItem to a PSClassInfo object.
/// For this, we call Get-Module -List with module name.
/// </summary>
/// <param name="classNameMatcher">Wildcard pattern matcher for comparing class name.</param>
/// <param name="modulePath">Path to the module where the class is defined.</param>
/// <returns>Converted PSClassInfo object.</returns>
private PSClassInfo CachedItemToPSClassInfo(WildcardPattern classNameMatcher, string modulePath)
{
foreach (var module in GetPSModuleInfo(modulePath))
{
var exportedTypes = module.GetExportedTypeDefinitions();
ScriptBlockAst ast = null;
TypeDefinitionAst typeAst = null;
if (!_useWildCards)
{
if (exportedTypes.TryGetValue(_className, out typeAst))
{
ast = typeAst.Parent.Parent as ScriptBlockAst;
if (ast != null)
{
return(ConvertToClassInfo(module, ast, typeAst));
}
}
}
else
{
foreach (var exportedType in exportedTypes)
{
if (exportedType.Value != null &&
classNameMatcher.IsMatch(exportedType.Value.Name) &&
exportedType.Value.IsClass)
{
ast = exportedType.Value.Parent.Parent as ScriptBlockAst;
if (ast != null)
{
return(ConvertToClassInfo(module, ast, exportedType.Value));
}
}
}
}
}
return(null);
}
private Dictionary<Guid, PSSession> GetMatchingRunspacesByComputerName(bool writeobject, bool writeErrorOnNoMatch)
{
if ((this.computerNames == null) || (this.computerNames.Length == 0))
{
return this.GetAllRunspaces(writeobject, writeErrorOnNoMatch);
}
Dictionary<Guid, PSSession> dictionary = new Dictionary<Guid, PSSession>();
List<PSSession> runspaces = base.RunspaceRepository.Runspaces;
foreach (string str in this.computerNames)
{
WildcardPattern pattern = new WildcardPattern(str, WildcardOptions.IgnoreCase);
bool flag = false;
foreach (PSSession session in runspaces)
{
if (pattern.IsMatch(session.ComputerName))
{
flag = true;
if (writeobject)
{
base.WriteObject(session);
}
else
{
try
{
dictionary.Add(session.InstanceId, session);
}
catch (ArgumentException)
{
}
}
}
}
if (!flag && writeErrorOnNoMatch)
{
this.WriteInvalidArgumentError(PSRemotingErrorId.RemoteRunspaceNotAvailableForSpecifiedComputer, RemotingErrorIdStrings.RemoteRunspaceNotAvailableForSpecifiedComputer, str);
}
}
return dictionary;
}
private CommandInfo GetNextAlias()
{
CommandInfo commandInfo = (CommandInfo)null;
if ((this.commandResolutionOptions & SearchResolutionOptions.ResolveAliasPatterns) != SearchResolutionOptions.None)
{
if (this.matchingAlias == null)
{
Collection <AliasInfo> collection = new Collection <AliasInfo>();
WildcardPattern wildcardPattern = new WildcardPattern(this.commandName, WildcardOptions.IgnoreCase);
foreach (KeyValuePair <string, AliasInfo> keyValuePair in (IEnumerable <KeyValuePair <string, AliasInfo> >) this._context.EngineSessionState.GetAliasTable())
{
if (wildcardPattern.IsMatch(keyValuePair.Key))
{
collection.Add(keyValuePair.Value);
}
}
this.matchingAlias = collection.GetEnumerator();
}
if (!this.matchingAlias.MoveNext())
{
this.currentState = CommandSearcher.SearchState.AliasResolution;
this.matchingAlias = (IEnumerator <AliasInfo>)null;
}
else
{
commandInfo = (CommandInfo)this.matchingAlias.Current;
}
}
else
{
this.currentState = CommandSearcher.SearchState.AliasResolution;
commandInfo = (CommandInfo)this._context.EngineSessionState.GetAlias(this.commandName);
}
if (commandInfo != null)
{
CommandDiscovery.discoveryTracer.WriteLine("Alias found: {0} {1}", (object)commandInfo.Name, (object)commandInfo.Definition);
}
return(commandInfo);
}
/// <summary>
/// Search help for a target.
/// </summary>
/// <param name="helpRequest">Help request object.</param>
/// <param name="searchOnlyContent">
/// If true, searches for pattern in the help content. Individual
/// provider can decide which content to search in.
///
/// If false, searches for pattern in the command names.
/// </param>
/// <returns>A collection of help info objects.</returns>
internal override IEnumerable <HelpInfo> SearchHelp(HelpRequest helpRequest, bool searchOnlyContent)
{
string target = helpRequest.Target;
string wildcardpattern = GetWildCardPattern(target);
HelpRequest searchHelpRequest = helpRequest.Clone();
searchHelpRequest.Target = wildcardpattern;
if (!this.CacheFullyLoaded)
{
IEnumerable <HelpInfo> result = DoSearchHelp(searchHelpRequest);
if (result != null)
{
foreach (HelpInfo helpInfoToReturn in result)
{
yield return(helpInfoToReturn);
}
}
}
else
{
int countOfHelpInfoObjectsFound = 0;
WildcardPattern helpMatcher = WildcardPattern.Get(wildcardpattern, WildcardOptions.IgnoreCase);
foreach (string key in _helpCache.Keys)
{
if ((!searchOnlyContent && helpMatcher.IsMatch(key)) ||
(searchOnlyContent && ((HelpInfo)_helpCache[key]).MatchPatternInContent(helpMatcher)))
{
countOfHelpInfoObjectsFound++;
yield return((HelpInfo)_helpCache[key]);
if (helpRequest.MaxResults > 0 && countOfHelpInfoObjectsFound >= helpRequest.MaxResults)
{
yield break;
}
}
}
}
}
internal List <Job2> GetJobToStart(string definitionName, string definitionPath, string definitionType, Cmdlet cmdlet, bool writeErrorOnException)
{
List <Job2> list = new List <Job2>();
WildcardPattern pattern = (definitionType != null) ? new WildcardPattern(definitionType, WildcardOptions.IgnoreCase) : null;
lock (this._syncObject)
{
foreach (JobSourceAdapter adapter in this._sourceAdapters.Values)
{
try
{
if (pattern != null)
{
string adapterName = this.GetAdapterName(adapter);
if (!pattern.IsMatch(adapterName))
{
continue;
}
}
Job2 item = adapter.NewJob(definitionName, definitionPath);
if (item != null)
{
list.Add(item);
}
if (pattern != null)
{
return(list);
}
}
catch (Exception exception)
{
this.Tracer.TraceException(exception);
CommandProcessorBase.CheckForSevereException(exception);
WriteErrorOrWarning(writeErrorOnException, cmdlet, exception, "JobSourceAdapterGetJobByInstanceIdError", adapter);
}
}
return(list);
}
return(list);
}
internal override IEnumerable <HelpInfo> SearchHelp(HelpRequest helpRequest, bool searchOnlyContent)
{
string target = helpRequest.Target;
string wildCardPattern = this.GetWildCardPattern(target);
HelpRequest iteratorVariable2 = helpRequest.Clone();
iteratorVariable2.Target = wildCardPattern;
if (!this.CacheFullyLoaded)
{
IEnumerable <HelpInfo> iteratorVariable3 = this.DoSearchHelp(iteratorVariable2);
if (iteratorVariable3 != null)
{
foreach (HelpInfo iteratorVariable4 in iteratorVariable3)
{
yield return(iteratorVariable4);
}
}
}
else
{
int iteratorVariable5 = 0;
WildcardPattern pattern = new WildcardPattern(wildCardPattern, WildcardOptions.IgnoreCase);
IEnumerator enumerator = this._helpCache.Keys.GetEnumerator();
while (enumerator.MoveNext())
{
string current = (string)enumerator.Current;
if ((!searchOnlyContent && pattern.IsMatch(current)) || (searchOnlyContent && ((HelpInfo)this._helpCache[current]).MatchPatternInContent(pattern)))
{
iteratorVariable5++;
yield return((HelpInfo)this._helpCache[current]);
if ((helpRequest.MaxResults > 0) && (iteratorVariable5 >= helpRequest.MaxResults))
{
break;
}
}
}
}
}
internal bool IsMatch(WildcardPattern namePattern, PSSnapinQualifiedName psSnapinQualifiedName)
{
bool flag = false;
if (psSnapinQualifiedName == null)
{
return(true);
}
if (namePattern == null)
{
if (string.Equals(this.Name, psSnapinQualifiedName.ShortName, StringComparison.OrdinalIgnoreCase) && this.IsPSSnapinNameMatch(psSnapinQualifiedName))
{
flag = true;
}
return(flag);
}
if (namePattern.IsMatch(this.Name) && this.IsPSSnapinNameMatch(psSnapinQualifiedName))
{
flag = true;
}
return(flag);
}
/// <summary>
/// Get a list of Provider operations in the case that the Actionstring input contains a wildcard
/// </summary>
private List<PSResourceProviderOperation> ProcessProviderOperationsWithWildCard(string actionString, Dictionary<string, string> resourceProvidersWithOperationsApi)
{
Dictionary<string, string> resourceProvidersToQuery = GetAzureProviderOperationCommand.FilterResourceProvidersToQueryForOperations(actionString, resourceProvidersWithOperationsApi);
// Filter the list of all operation names to what matches the wildcard
WildcardPattern wildcard = new WildcardPattern(actionString, WildcardOptions.IgnoreCase | WildcardOptions.Compiled);
IList<ResourceIdentity> resourceidentities = new List<ResourceIdentity>();
foreach (KeyValuePair<string, string> kvp in resourceProvidersToQuery)
{
ResourceIdentity identity = new ResourceIdentity()
{
ResourceName = string.Empty,
ResourceType = "operations",
ResourceProviderNamespace = kvp.Key,
ResourceProviderApiVersion = kvp.Value
};
resourceidentities.Add(identity);
}
return this.ResourcesClient.ListPSProviderOperations(resourceidentities).Where(operation => wildcard.IsMatch(operation.OperationName)).ToList();
}
private CommandInfo GetNextFunction()
{
CommandInfo commandInfo = (CommandInfo)null;
if ((this.commandResolutionOptions & SearchResolutionOptions.ResolveFunctionPatterns) != SearchResolutionOptions.None)
{
if (this.matchingFunctionEnumerator == null)
{
Collection <CommandInfo> collection = new Collection <CommandInfo>();
WildcardPattern wildcardPattern = new WildcardPattern(this.commandName, WildcardOptions.IgnoreCase);
foreach (DictionaryEntry dictionaryEntry in this._context.EngineSessionState.GetFunctionTable())
{
if (wildcardPattern.IsMatch((string)dictionaryEntry.Key))
{
collection.Add((CommandInfo)dictionaryEntry.Value);
}
}
this.matchingFunctionEnumerator = collection.GetEnumerator();
}
if (!this.matchingFunctionEnumerator.MoveNext())
{
this.currentState = CommandSearcher.SearchState.FunctionResolution;
this.matchingFunctionEnumerator = (IEnumerator <CommandInfo>)null;
}
else
{
commandInfo = this.matchingFunctionEnumerator.Current;
}
}
else
{
this.currentState = CommandSearcher.SearchState.FunctionResolution;
commandInfo = this.GetFunction(this.commandName);
}
return(commandInfo);
}
protected override void ProcessRecord()
{
if (this._name == null)
this.WriteObject((object)VPMJob.GetAll(), true);
else
{
foreach (string pattern in this._name)
{
if (pattern == null)
this.WriteObject((object)VPMJob.GetAll(), true);
else
{
WildcardPattern wildcard = new WildcardPattern(pattern, WildcardOptions.Compiled | WildcardOptions.IgnoreCase);
foreach (VPMJob Job in (VPMJob.GetAll()))
{
if (wildcard.IsMatch(Job.Name))
WriteObject((object)Job, true);
}
}
}
}
}
protected bool TryGetHostEntries(HostsFile hostsFile, string name, int line, out ICollection<HostEntry> hostEntries)
{
hostEntries = hostsFile.Entries.ToList();
if (line != -1 && MyInvocation.BoundParameters.Keys.Contains("Line"))
{
hostEntries = hostEntries.Where(e => e.Line == line).ToList();
return hostEntries.Count == 1;
}
if (String.IsNullOrEmpty(name))
{
hostEntries = hostsFile.Entries.ToList();
return true;
}
if (WildcardPattern.ContainsWildcardCharacters(name))
{
var pattern = new WildcardPattern(name, WildcardOptions.CultureInvariant | WildcardOptions.IgnoreCase);
hostEntries = hostsFile.Entries.Where(e => pattern.IsMatch(e.Name)).ToList();
return true;
}
else
{
hostEntries = hostsFile.Entries.Where(e => String.Equals(e.Name, name, StringComparison.InvariantCultureIgnoreCase)).ToList();
if (hostEntries.Count == 0)
{
WriteError(new ErrorRecord(new ItemNotFoundException(String.Format("Host entry '{0}' not found", name)),
"ItemNotFound", ErrorCategory.ObjectNotFound, name));
return false;
}
return true;
}
}
public static bool IsValidByName(PackageEntryInfo packageEntry, NuGetSearchContext searchContext)
{
NuGetSearchTerm originalPsTerm = searchContext.SearchTerms == null ?
null : searchContext.SearchTerms.Where(st => st.Term == NuGetSearchTerm.NuGetSearchTermType.OriginalPSPattern).FirstOrDefault();
bool valid = true;
if (originalPsTerm != null)
{
if (!String.IsNullOrWhiteSpace(originalPsTerm.Text) && SMA.WildcardPattern.ContainsWildcardCharacters(originalPsTerm.Text))
{
// Applying the wildcard pattern matching
const SMA.WildcardOptions wildcardOptions = SMA.WildcardOptions.CultureInvariant | SMA.WildcardOptions.IgnoreCase;
var wildcardPattern = new SMA.WildcardPattern(originalPsTerm.Text, wildcardOptions);
valid = wildcardPattern.IsMatch(packageEntry.Id);
}
else if (!String.IsNullOrWhiteSpace(originalPsTerm.Text))
{
valid = packageEntry.Id.IndexOf(originalPsTerm.Text, StringComparison.OrdinalIgnoreCase) > -1;
}
}
return(valid);
}
private CmdletInfo GetNextCmdlet()
{
CmdletInfo result = (CmdletInfo)null;
if (this.matchingCmdlet == null)
{
Collection <CmdletInfo> matchingCmdlets;
if ((this.commandResolutionOptions & SearchResolutionOptions.CommandNameIsPattern) != SearchResolutionOptions.None)
{
matchingCmdlets = new Collection <CmdletInfo>();
PSSnapinQualifiedName instance = PSSnapinQualifiedName.GetInstance(this.commandName);
if (instance == null)
{
return(result);
}
WildcardPattern wildcardPattern = new WildcardPattern(instance.ShortName, WildcardOptions.IgnoreCase);
Dictionary <string, List <CmdletInfo> > cmdletCache = this._context.EngineSessionState.CmdletCache;
while (true)
{
lock (cmdletCache)
{
foreach (List <CmdletInfo> cmdletInfoList in cmdletCache.Values)
{
foreach (CmdletInfo cmdletInfo in cmdletInfoList)
{
if (wildcardPattern.IsMatch(cmdletInfo.Name) && (string.IsNullOrEmpty(instance.PSSnapInName) || instance.PSSnapInName.Equals(cmdletInfo.ModuleName, StringComparison.OrdinalIgnoreCase)))
{
matchingCmdlets.Add(cmdletInfo);
}
}
}
}
if (cmdletCache != this._context.TopLevelSessionState.CmdletCache)
{
cmdletCache = this._context.TopLevelSessionState.CmdletCache;
}
else
{
break;
}
}
}
else
{
matchingCmdlets = this._context.CommandDiscovery.GetCmdletInfo(this.commandName);
if (matchingCmdlets.Count > 1)
{
if ((this.commandResolutionOptions & SearchResolutionOptions.ReturnFirstDuplicateCmdletName) != SearchResolutionOptions.None)
{
this.matchingCmdlet = matchingCmdlets.GetEnumerator();
while (this.matchingCmdlet.MoveNext())
{
if (result == null)
{
result = this.matchingCmdlet.Current;
}
}
return(this.traceResult(result));
}
if ((this.commandResolutionOptions & SearchResolutionOptions.AllowDuplicateCmdletNames) == SearchResolutionOptions.None)
{
throw this.NewAmbiguousCmdletName(this.commandName, matchingCmdlets);
}
}
}
this.matchingCmdlet = matchingCmdlets.GetEnumerator();
}
if (!this.matchingCmdlet.MoveNext())
{
this.currentState = CommandSearcher.SearchState.CmdletResolution;
this.matchingCmdlet = (IEnumerator <CmdletInfo>)null;
}
else
{
result = this.matchingCmdlet.Current;
}
return(this.traceResult(result));
}
/// <summary>
/// Search an alias help target.
/// </summary>
/// <remarks>
/// This will,
/// a. use _sessionState object to get a list of alias that match the target.
/// b. for each alias, retrieve help info as in ExactMatchHelp.
/// </remarks>
/// <param name="helpRequest">Help request object.</param>
/// <param name="searchOnlyContent">
/// If true, searches for pattern in the help content. Individual
/// provider can decide which content to search in.
///
/// If false, searches for pattern in the command names.
/// </param>
/// <returns>A IEnumerable of helpinfo object.</returns>
internal override IEnumerable <HelpInfo> SearchHelp(HelpRequest helpRequest, bool searchOnlyContent)
{
// aliases do not have help content...so doing nothing in that case
if (!searchOnlyContent)
{
string target = helpRequest.Target;
string pattern = target;
Hashtable hashtable = new Hashtable(StringComparer.OrdinalIgnoreCase);
if (!WildcardPattern.ContainsWildcardCharacters(target))
{
pattern += "*";
}
WildcardPattern matcher = WildcardPattern.Get(pattern, WildcardOptions.IgnoreCase);
IDictionary <string, AliasInfo> aliasTable = _sessionState.Internal.GetAliasTable();
foreach (string name in aliasTable.Keys)
{
if (matcher.IsMatch(name))
{
HelpRequest exactMatchHelpRequest = helpRequest.Clone();
exactMatchHelpRequest.Target = name;
// Duplicates??
foreach (HelpInfo helpInfo in ExactMatchHelp(exactMatchHelpRequest))
{
// Component/Role/Functionality match is done only for SearchHelp
// as "get-help * -category alias" should not forwad help to
// CommandHelpProvider..(ExactMatchHelp does forward help to
// CommandHelpProvider)
if (!Match(helpInfo, helpRequest))
{
continue;
}
if (hashtable.ContainsKey(name))
{
continue;
}
hashtable.Add(name, null);
yield return(helpInfo);
}
}
}
CommandSearcher searcher =
new CommandSearcher(
pattern,
SearchResolutionOptions.ResolveAliasPatterns, CommandTypes.Alias,
_context);
while (searcher.MoveNext())
{
CommandInfo current = ((IEnumerator <CommandInfo>)searcher).Current;
if (_context.CurrentPipelineStopping)
{
yield break;
}
AliasInfo alias = current as AliasInfo;
if (alias != null)
{
string name = alias.Name;
HelpRequest exactMatchHelpRequest = helpRequest.Clone();
exactMatchHelpRequest.Target = name;
// Duplicates??
foreach (HelpInfo helpInfo in ExactMatchHelp(exactMatchHelpRequest))
{
// Component/Role/Functionality match is done only for SearchHelp
// as "get-help * -category alias" should not forwad help to
// CommandHelpProvider..(ExactMatchHelp does forward help to
// CommandHelpProvider)
if (!Match(helpInfo, helpRequest))
{
continue;
}
if (hashtable.ContainsKey(name))
{
continue;
}
hashtable.Add(name, null);
yield return(helpInfo);
}
}
}
foreach (CommandInfo current in ModuleUtils.GetMatchingCommands(pattern, _context, helpRequest.CommandOrigin))
{
if (_context.CurrentPipelineStopping)
{
yield break;
}
AliasInfo alias = current as AliasInfo;
if (alias != null)
{
string name = alias.Name;
HelpInfo helpInfo = AliasHelpInfo.GetHelpInfo(alias);
if (hashtable.ContainsKey(name))
{
continue;
}
hashtable.Add(name, null);
yield return(helpInfo);
}
}
}
}
internal Collection<PSSnapInInfo> GetPSSnapIn(string pattern, bool searchRegistry)
{
bool flag = WildcardPattern.ContainsWildcardCharacters(pattern);
if (!flag)
{
PSSnapInInfo.VerifyPSSnapInFormatThrowIfError(pattern);
}
Collection<PSSnapInInfo> collection = searchRegistry ? PSSnapInReader.ReadAll() : this.PSSnapIns;
Collection<PSSnapInInfo> collection2 = new Collection<PSSnapInInfo>();
if (collection != null)
{
if (!flag)
{
foreach (PSSnapInInfo info in collection)
{
if (string.Equals(info.Name, pattern, StringComparison.OrdinalIgnoreCase))
{
collection2.Add(info);
}
}
return collection2;
}
WildcardPattern pattern2 = new WildcardPattern(pattern, WildcardOptions.IgnoreCase);
foreach (PSSnapInInfo info2 in collection)
{
if (pattern2.IsMatch(info2.Name))
{
collection2.Add(info2);
}
}
}
return collection2;
}
internal bool IsMatchingType(PSTypeName psTypeName)
{
Type fromType = psTypeName.Type;
if (fromType != null)
{
bool flag = LanguagePrimitives.FigureConversion(typeof(object), this.ParameterType).Rank >= ConversionRank.AssignableS2A;
if (fromType.Equals(typeof(object)))
{
return flag;
}
if (flag)
{
return ((psTypeName.Type != null) && psTypeName.Type.Equals(typeof(object)));
}
LanguagePrimitives.ConversionData data = LanguagePrimitives.FigureConversion(fromType, this.ParameterType);
return ((data != null) && (data.Rank >= ConversionRank.NumericImplicitS2A));
}
WildcardPattern pattern = new WildcardPattern("*" + (psTypeName.Name ?? ""), WildcardOptions.CultureInvariant | WildcardOptions.IgnoreCase);
if (pattern.IsMatch(this.ParameterType.FullName))
{
return true;
}
if (this.ParameterType.IsArray && pattern.IsMatch(this.ParameterType.GetElementType().FullName))
{
return true;
}
if (this.Attributes != null)
{
PSTypeNameAttribute attribute = this.Attributes.OfType<PSTypeNameAttribute>().FirstOrDefault<PSTypeNameAttribute>();
if ((attribute != null) && pattern.IsMatch(attribute.PSTypeName))
{
return true;
}
}
return false;
}
private static void GetCommandletsFromAssembly(Assembly assembly, WildcardPattern wildcard)
{
foreach (Type type in assembly.GetTypes())
{
if (type.GetCustomAttributes(typeof(CmdletAttribute), true).Length > 0 &&
wildcard.IsMatch(type.FullName))
{
var attribute = (CmdletAttribute)(type.GetCustomAttributes(typeof(CmdletAttribute), true)[0]);
Commandlets.Add(new CmdletConfigurationEntry(attribute.VerbName + "-" + attribute.NounName, type, "..\\Console\\Assets\\Cognifide.PowerShell-Help.xml"));
}
}
}
internal List<Process> FindProcessesByNames()
{
List<Process> foundProcesses = new List<Process>();
if (_processNames == null)
{
return new List<Process>(AllProcesses);
}
else
{
foreach (string name in _processNames)
{
WildcardPattern pattern = new WildcardPattern(name, WildcardOptions.IgnoreCase);
bool bFound = false;
foreach (Process process in AllProcesses)
{
if (pattern.IsMatch(GetProcessName(process)))
{
bFound = true;
foundProcesses.Add(process);
}
}
if (!bFound && !WildcardPattern.ContainsWildcardCharacters(name))
{
WriteError(new ErrorRecord(new Exception("Can't find process for name: " + name), "", ErrorCategory.ObjectNotFound, name));
}
}
}
return foundProcesses;
}
private void RetrieveMatchingProcessesByProcessName()
{
if (this.processNames != null)
{
string[] strArrays = this.processNames;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
WildcardPattern wildcardPattern = new WildcardPattern(str, WildcardOptions.IgnoreCase);
bool flag = false;
Process[] allProcesses = this.AllProcesses;
for (int j = 0; j < (int)allProcesses.Length; j++)
{
Process process = allProcesses[j];
if (wildcardPattern.IsMatch(ProcessBaseCommand.SafeGetProcessName(process)))
{
flag = true;
this.AddIdempotent(process);
}
}
if (!flag && !WildcardPattern.ContainsWildcardCharacters(str))
{
this.WriteNonTerminatingError(str, 0, str, null, ProcessResources.NoProcessFoundForGivenName, "NoProcessFoundForGivenName", ErrorCategory.ObjectNotFound);
}
}
return;
}
else
{
this._matchingProcesses = new List<Process>(this.AllProcesses);
return;
}
}
/// <summary>
/// Resets the current working drive and directory to the first
/// entry on the working directory stack and removes that entry
/// from the stack.
/// </summary>
/// <param name="stackName">
/// The ID of the stack to pop the location from. If it is null or
/// empty the default stack is used.
/// </param>
/// <returns>
/// A PathInfo object representing the location that was popped
/// from the location stack and set as the new location.
/// </returns>
/// <exception cref="ArgumentException">
/// If the path on the stack does not exist, is not a container, or
/// resolved to multiple containers.
/// or
/// If <paramref name="stackName"/> contains wildcard characters and resolves
/// to multiple location stacks.
/// or
/// A stack was not found with the specified name.
/// </exception>
/// <exception cref="ProviderNotFoundException">
/// If the path on the stack refers to a provider that does not exist.
/// </exception>
/// <exception cref="DriveNotFoundException">
/// If the path on the stack refers to a drive that does not exist.
/// </exception>
/// <exception cref="ProviderInvocationException">
/// If the provider associated with the path on the stack threw an
/// exception.
/// </exception>
internal PathInfo PopLocation(string stackName)
{
if (String.IsNullOrEmpty(stackName))
{
stackName = _defaultStackName;
}
if (WildcardPattern.ContainsWildcardCharacters(stackName))
{
// Need to glob the stack name, but it can only glob to a single.
bool haveMatch = false;
WildcardPattern stackNamePattern =
WildcardPattern.Get(stackName, WildcardOptions.IgnoreCase);
foreach (string key in _workingLocationStack.Keys)
{
if (stackNamePattern.IsMatch(key))
{
if (haveMatch)
{
throw
PSTraceSource.NewArgumentException(
"stackName",
SessionStateStrings.StackNameResolvedToMultiple,
stackName);
}
haveMatch = true;
stackName = key;
}
}
}
PathInfo result = CurrentLocation;
try
{
Stack <PathInfo> locationStack = null;
if (!_workingLocationStack.TryGetValue(stackName, out locationStack))
{
if (!string.Equals(stackName, startingDefaultStackName, StringComparison.OrdinalIgnoreCase))
{
throw
PSTraceSource.NewArgumentException(
"stackName",
SessionStateStrings.StackNotFound,
stackName);
}
return(null);
}
PathInfo poppedWorkingDirectory = locationStack.Pop();
Dbg.Diagnostics.Assert(
poppedWorkingDirectory != null,
"All items in the workingLocationStack should be " +
"of type PathInfo");
string newPath =
LocationGlobber.GetMshQualifiedPath(
WildcardPattern.Escape(poppedWorkingDirectory.Path),
poppedWorkingDirectory.GetDrive());
result = SetLocation(newPath);
if (locationStack.Count == 0 &&
!String.Equals(stackName, startingDefaultStackName, StringComparison.OrdinalIgnoreCase))
{
// Remove the stack from the stack list if it
// no longer contains any paths.
_workingLocationStack.Remove(stackName);
}
}
catch (InvalidOperationException)
{
// This is a no-op. We stay with the current working
// directory.
}
return(result);
}
private PSSession GetSessionByName(string name)
{
WildcardPattern pattern = new WildcardPattern(name, WildcardOptions.IgnoreCase);
foreach (PSSession session in base.RunspaceRepository.Runspaces)
{
if (pattern.IsMatch(session.Name))
{
return session;
}
}
return null;
}
/// <summary>
/// Invoke command Get-DscResource with resource name to find the resource.
/// When found add them to the enumerator. If we have already got it, return the next resource.
/// </summary>
/// <returns>Next DscResource Info object or null if none are found.</returns>
private DscResourceInfo GetNextDscResource()
{
var ps = PowerShell.Create(RunspaceMode.CurrentRunspace).AddCommand("Get-DscResource");
WildcardPattern resourceMatcher = WildcardPattern.Get(_resourceName, WildcardOptions.IgnoreCase);
if (_matchingResourceList == null)
{
Collection <PSObject> psObjs = ps.Invoke();
_matchingResourceList = new Collection <DscResourceInfo>();
bool matchFound = false;
foreach (dynamic resource in psObjs)
{
if (resource.Name != null)
{
string resourceName = resource.Name;
if (resourceMatcher.IsMatch(resourceName))
{
DscResourceInfo resourceInfo = new DscResourceInfo(resourceName,
resource.ResourceType,
resource.Path,
resource.ParentPath,
_context
);
resourceInfo.FriendlyName = resource.FriendlyName;
resourceInfo.CompanyName = resource.CompanyName;
PSModuleInfo psMod = resource.Module as PSModuleInfo;
if (psMod != null)
{
resourceInfo.Module = psMod;
}
if (resource.ImplementedAs != null)
{
ImplementedAsType impType;
if (Enum.TryParse <ImplementedAsType>(resource.ImplementedAs.ToString(), out impType))
{
resourceInfo.ImplementedAs = impType;
}
}
var properties = resource.Properties as IList;
if (properties != null)
{
List <DscResourcePropertyInfo> propertyList = new List <DscResourcePropertyInfo>();
foreach (dynamic prop in properties)
{
DscResourcePropertyInfo propInfo = new DscResourcePropertyInfo();
propInfo.Name = prop.Name;
propInfo.PropertyType = prop.PropertyType;
propInfo.UpdateValues(prop.Values);
propertyList.Add(propInfo);
}
resourceInfo.UpdateProperties(propertyList);
}
_matchingResourceList.Add(resourceInfo);
matchFound = true;
}
}
}
if (matchFound)
{
_matchingResource = _matchingResourceList.GetEnumerator();
}
else
{
return(null);
}
}
if (!_matchingResource.MoveNext())
{
_matchingResource = null;
}
else
{
return(_matchingResource.Current);
}
return(null);
}
internal override IEnumerable <HelpInfo> SearchHelp(HelpRequest helpRequest, bool searchOnlyContent)
{
if (!searchOnlyContent)
{
string target = helpRequest.Target;
string pattern = target;
Hashtable iteratorVariable2 = new Hashtable(StringComparer.OrdinalIgnoreCase);
if (!WildcardPattern.ContainsWildcardCharacters(target))
{
pattern = pattern + "*";
}
WildcardPattern iteratorVariable3 = new WildcardPattern(pattern, WildcardOptions.IgnoreCase);
IDictionary <string, AliasInfo> aliasTable = this._sessionState.Internal.GetAliasTable();
foreach (string iteratorVariable5 in aliasTable.Keys)
{
if (iteratorVariable3.IsMatch(iteratorVariable5))
{
HelpRequest iteratorVariable6 = helpRequest.Clone();
iteratorVariable6.Target = iteratorVariable5;
foreach (HelpInfo iteratorVariable7 in this.ExactMatchHelp(iteratorVariable6))
{
if (!Match(iteratorVariable7, helpRequest) || iteratorVariable2.ContainsKey(iteratorVariable5))
{
continue;
}
iteratorVariable2.Add(iteratorVariable5, null);
yield return(iteratorVariable7);
}
}
}
CommandSearcher iteratorVariable8 = new CommandSearcher(pattern, SearchResolutionOptions.ResolveAliasPatterns, CommandTypes.Alias, this._context);
while (iteratorVariable8.MoveNext())
{
CommandInfo current = iteratorVariable8.Current;
if (this._context.CurrentPipelineStopping)
{
goto Label_0423;
}
AliasInfo iteratorVariable10 = current as AliasInfo;
if (iteratorVariable10 != null)
{
string name = iteratorVariable10.Name;
HelpRequest iteratorVariable12 = helpRequest.Clone();
iteratorVariable12.Target = name;
foreach (HelpInfo iteratorVariable13 in this.ExactMatchHelp(iteratorVariable12))
{
if (!Match(iteratorVariable13, helpRequest) || iteratorVariable2.ContainsKey(name))
{
continue;
}
iteratorVariable2.Add(name, null);
yield return(iteratorVariable13);
}
}
}
foreach (CommandInfo iteratorVariable14 in ModuleUtils.GetMatchingCommands(pattern, this._context, helpRequest.CommandOrigin, false))
{
if (this._context.CurrentPipelineStopping)
{
break;
}
AliasInfo aliasInfo = iteratorVariable14 as AliasInfo;
if (aliasInfo != null)
{
string key = aliasInfo.Name;
HelpInfo helpInfo = AliasHelpInfo.GetHelpInfo(aliasInfo);
if (!iteratorVariable2.ContainsKey(key))
{
iteratorVariable2.Add(key, null);
yield return(helpInfo);
}
}
}
}
Label_0423:
yield break;
}