public int Compare(object x, object y)
{
CommandParameterInfo info = x as CommandParameterInfo;
CommandParameterInfo info2 = y as CommandParameterInfo;
return(info.Position - info2.Position);
}
void getType(CommandParameterInfo param)
{
String underlyingType = param.ParameterType.ToString();
String genericType = String.Empty;
String[] tokens;
if (underlyingType.Contains("["))
{
AcceptsArray = true;
}
if (underlyingType.Contains("[") && !underlyingType.Contains("[]"))
{
tokens = underlyingType.Split('[');
underlyingType = tokens[0];
genericType = tokens[1].Replace("]", null);
tokens = genericType.Split('.');
genericType = tokens[tokens.Length - 1];
}
tokens = underlyingType.Split('.');
Type = tokens[tokens.Length - 1];
if (!String.IsNullOrEmpty(genericType))
{
Type += "[" + genericType + "]";
}
}
public void CanParseLists(string parameterName, Type underLyingType, List <string> stringValues, object typedValue)
{
ListParser listParser = new ListParser(underLyingType, new SingleValueParser(underLyingType));
ParameterInfo parameterInfo = typeof(ParameterClass).GetMethod("List").GetParameters()
.Single(x => x.Name == parameterName);
AppSettings appSettings = new AppSettings();
CommandParameterInfo commandParamterInfo = new CommandParameterInfo(parameterInfo, appSettings);
commandParamterInfo.SetValue(new CommandArgument()
{
Name = parameterName,
Description = "description",
MultipleValues = true,
Values = stringValues
});
IList parsedValues = listParser.Parse(commandParamterInfo);
parsedValues.Should().HaveCount(stringValues.Count);
parsedValues.Should().AllBeOfType(underLyingType);
for (int i = 0; i < stringValues.Count; i++)
{
parsedValues[i].Should().Be(((IList)typedValue)[i]);
}
}
/// <summary>
/// Constructs an instance of a ParameterInfo object
/// </summary>
/// <param name="parameterInfo">Parameter info of the parameter</param>
public ParameterInfo(CommandParameterInfo parameterInfo)
{
this.Name = "-" + parameterInfo.Name;
this.ParameterType = parameterInfo.ParameterType.FullName;
this.Position = parameterInfo.Position;
this.IsMandatory = parameterInfo.IsMandatory;
this.HelpMessage = parameterInfo.HelpMessage;
}
public static CommandParameter Create(CommandParameterInfo parameter)
{
return(new CommandParameter
{
Name = parameter.Name,
IsMandatory = parameter.IsMandatory,
Type = parameter.ParameterType.Name
});
}
/// <summary>
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public int Compare(object x, object y)
{
CommandParameterInfo a = x as CommandParameterInfo;
CommandParameterInfo b = y as CommandParameterInfo;
Debug.Assert(a != null && b != null);
return(a.Position - b.Position);
}
private void AddParameter(MemberInfo info, Type parameterType, ParameterAttribute paramAttribute)
{
var paramInfo = new CommandParameterInfo(info, parameterType, paramAttribute);
if (!NamedParameters.ContainsKey(paramInfo.Name))
{
NamedParameters[paramInfo.Name] = paramInfo;
}
AllParameters.Add(paramInfo);
}
public void VerboseCommonParameterAvailableFromGetCommandCmdlet()
{
CmdletInfo info = ReferenceHost.RawExecute("Get-Command")
.Select(psObject => psObject.BaseObject as CmdletInfo)
.FirstOrDefault(cmdletInfo => (cmdletInfo != null) && (cmdletInfo.Name == "Get-Command"));
CommandParameterSetInfo parameterSetInfo = info.ParameterSets[0];
CommandParameterInfo verboseParameter = parameterSetInfo.Parameters.FirstOrDefault(parameter => parameter.Name == "Verbose");
Assert.IsNotNull(verboseParameter);
Assert.IsTrue(verboseParameter.Aliases.Contains("vb"));
}
private ICommandParameterInfo GetParameter(ParameterInfo param)
{
var name = param.Name;
var description = GetDescription(param);
bool isOptional = false;
var convertFunc = GetConvertFunc(param.ParameterType);
var info = new CommandParameterInfo(name, description, isOptional, convertFunc);
return(info);
}
private static void SetValueForParameter(CommandParameterInfo parameter, CommandLineApplication command)
{
parameter.SetValue(command.Argument(
parameter.Name,
parameter.AnnotatedDescription,
_ => {},
parameter.TypeDisplayName,
parameter.DefaultValue,
parameter.IsMultipleType,
parameter.AllowedValues));
}
/// <summary>
/// Initializes a new instance of the <see cref="ShowCommandParameterInfo"/> class
/// with the specified <see cref="CommandParameterInfo"/>.
/// </summary>
/// <param name="other">
/// The object to wrap.
/// </param>
public ShowCommandParameterInfo(CommandParameterInfo other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
this.Name = other.Name;
this.IsMandatory = other.IsMandatory;
this.ValueFromPipeline = other.ValueFromPipeline;
this.ParameterType = new ShowCommandParameterType(other.ParameterType);
this.Position = other.Position;
var validateSetAttribute = other.Attributes.Where(static x => typeof(ValidateSetAttribute).IsAssignableFrom(x.GetType())).Cast <ValidateSetAttribute>().LastOrDefault();
static Option <CommandArgument> TryGetArgument(CommandParameterInfo p, object o)
{
var v = p.Accessor.GetValue(o);
if (v != null)
{
var option = v as IOption;
var actualValue = option != null ? (option.IsSome ? option.Value : null) : v;
if (actualValue != null)
{
return(new CommandArgument(p.ParameterName, actualValue));
}
}
return(null);
}
public void ReflectionParameters()
{
var numCommon = CommonCmdletParameters.ParameterDiscovery.AllParameters.Count;
CommandParameterSetInfo allSet = info.GetParameterSetByName(ParameterAttribute.AllParameterSets);
CommandParameterSetInfo fileSet = info.GetParameterSetByName("File");
CommandParameterSetInfo variableSet = info.GetParameterSetByName("Variable");
Assert.AreEqual(3 + numCommon, allSet.Parameters.Count);
Assert.AreEqual(4 + numCommon, fileSet.Parameters.Count);
Assert.AreEqual(5 + numCommon, variableSet.Parameters.Count);
Assert.IsNotNull(allSet);
Assert.IsNotNull(fileSet);
Assert.IsNotNull(variableSet);
Assert.IsNull(info.GetParameterSetByName("TheseShouldBeSkipped"));
CheckForAllSetsParameters(allSet);
CheckForAllSetsParameters(fileSet);
CheckForAllSetsParameters(variableSet);
CommandParameterInfo filePathParam = fileSet.GetParameterByName("FilePath");
Assert.IsNotNull(filePathParam);
Assert.AreEqual("FilePath", filePathParam.Name);
Assert.AreEqual(3, filePathParam.Position);
Assert.AreEqual(true, filePathParam.IsMandatory);
CommandParameterInfo variableParam = variableSet.GetParameterByName("Variable");
Assert.IsNotNull(variableParam);
Assert.AreEqual("Variable", variableParam.Name);
Assert.AreEqual(0, variableParam.Position);
Assert.AreEqual(true, variableParam.IsMandatory);
CommandParameterInfo constVarParam = variableSet.GetParameterByName("ConstVar");
Assert.IsNotNull(constVarParam);
Assert.AreEqual("ConstVar", constVarParam.Name);
Assert.AreEqual(-1, constVarParam.Position);
Assert.AreEqual(false, constVarParam.IsMandatory);
CommandParameterInfo ageParam = fileSet.GetParameterByName("Age");
Assert.IsNull(ageParam);
}
void m_initialize(CommandParameterInfo param)
{
status = ItemStatus.New;
Name = param.Name;
// get type
getType(param);
// get parameter parameters
Mandatory = param.IsMandatory;
Dynamic = param.IsDynamic;
RemainingArgs = param.ValueFromRemainingArguments;
Pipeline = param.ValueFromPipeline;
PipelinePropertyName = param.ValueFromPipelineByPropertyName;
// process position
if (param.Position >= 0)
{
Position = Convert.ToString(param.Position);
Positional = true;
}
else
{
Position = "named";
Positional = false;
}
// process attributes
Attributes = new List <String>();
if (param.Attributes.Count > 0)
{
foreach (Attribute item in param.Attributes)
{
Attributes.Add(item.ToString());
}
}
// process parameter aliases
Aliases = new List <String>();
if (param.Aliases.Count > 0)
{
foreach (String alias in param.Aliases)
{
Aliases.Add(alias);
}
}
}
public void CanParseNullableInt()
{
NullableValueParser parser = new NullableValueParser(typeof(int), new SingleValueParser(typeof(int)));
CommandParameterInfo parameterInfo = new CommandParameterInfo(typeof(IntPropertyModel).GetProperty("Id"), new AppSettings());
parameterInfo.SetValue(new CommandArgument()
{
Values = new List <string>()
{
"3"
},
MultipleValues = false,
Name = "Id",
Description = "Id of employee",
ShowInHelpText = true
});
object value = parser.Parse(parameterInfo);
value.Should().BeOfType <int>().And.Be(3);
}
/// <summary>
/// Creates an instance of the ShowCommandParameterInfo class based on a CommandParameterInfo object
/// </summary>
///
/// <param name="other">
/// The object to wrap.
/// </param>
public ShowCommandParameterInfo(CommandParameterInfo other)
{
if (null == other)
{
throw new ArgumentNullException("other");
}
this.Name = other.Name;
this.IsMandatory = other.IsMandatory;
this.ValueFromPipeline = other.ValueFromPipeline;
this.ParameterType = new ShowCommandParameterType(other.ParameterType);
this.Position = other.Position;
var validateSetAttribute = other.Attributes.Where(x => typeof(ValidateSetAttribute).IsAssignableFrom(x.GetType())).Cast <ValidateSetAttribute>().LastOrDefault();
if (validateSetAttribute != null)
{
this.HasParameterSet = true;
this.ValidParamSetValues = validateSetAttribute.ValidValues;
}
}
private static void DisplayHelpPanel(CommandConsoleWindow window)
{
ParametricCommandExecution exec = window.CurrentExecution;
GUILayout.BeginVertical(GUILayout.MinWidth(70),
GUILayout.MaxWidth(200), GUILayout.ExpandHeight(true));
GUILayout.BeginVertical(MonkeyStyle.Instance.VariableHelpGroupStyle);
GUILayout.Label(exec.CurrentParameterInfo.
Name.NicifyVariableName().Bold()
, MonkeyStyle.Instance.VariableTypeTextStyle);
GUILayout.Label("", MonkeyStyle.Instance.ParametricTabUnderline1Style);
GUILayout.Label("", MonkeyStyle.Instance.ParametricTabUnderline2Style);
CommandParameterInfo info = exec.CurrentParameterInfo;
string parameterTypeName = info.HasTypeNameOverride ?
info.ParameterTypeNameOverride :
MonkeyStyle.PrettifyTypeName(exec.CurrentParameterInfo.ParameterType);
GUILayout.Label(MonKeyLocManager.CurrentLoc.Type + parameterTypeName
, MonkeyStyle.Instance.VariableTypeTextStyle);
GUILayout.Label("", MonkeyStyle.Instance.ParametricTabUnderline1Style);
GUILayout.Label("", MonkeyStyle.Instance.ParametricTabUnderline2Style);
if (!info.Help.IsNullOrEmpty())
{
GUILayout.Label(info.Help, MonkeyStyle.Instance.VariableHelpTextStyle);
}
GUILayout.EndVertical();
DisplayArrayIds(window, exec);
GUILayout.FlexibleSpace();
GUILayout.EndVertical();
}
private void CheckForAllSetsParameters(CommandParameterSetInfo set)
{
CommandParameterInfo inputObjectParam = set.GetParameterByName("InputObject");
Assert.IsNotNull(inputObjectParam);
Assert.AreEqual("InputObject", inputObjectParam.Name);
Assert.AreEqual(-1, inputObjectParam.Position);
Assert.AreEqual(false, inputObjectParam.IsMandatory);
CommandParameterInfo nameParam = set.GetParameterByName("Name");
Assert.IsNotNull(nameParam);
Assert.AreEqual("Name", nameParam.Name);
Assert.AreEqual(1, nameParam.Position);
Assert.AreEqual(false, nameParam.IsMandatory);
CommandParameterInfo recurseParam = set.GetParameterByName("Recurse");
Assert.IsNotNull(recurseParam);
Assert.AreEqual("Recurse", recurseParam.Name);
Assert.AreEqual(-1, recurseParam.Position);
Assert.AreEqual(false, recurseParam.IsMandatory);
}
public void ReflectionParameters()
{
CommandParameterSetInfo allSet = info.GetParameterSetByName(ParameterAttribute.AllParameterSets);
CommandParameterSetInfo fileSet = info.GetParameterSetByName("File");
CommandParameterSetInfo variableSet = info.GetParameterSetByName("Variable");
Assert.AreEqual(3, allSet.Parameters.Count);
Assert.AreEqual(4, fileSet.Parameters.Count);
Assert.AreEqual(4, variableSet.Parameters.Count);
Assert.IsNotNull(allSet);
Assert.IsNotNull(fileSet);
Assert.IsNotNull(variableSet);
Assert.IsNull(info.GetParameterSetByName("TheseShouldBeSkipped"));
CheckForAllSetsParameters(allSet);
CheckForAllSetsParameters(fileSet);
CheckForAllSetsParameters(variableSet);
CommandParameterInfo filePathParam = fileSet.GetParameterByName("FilePath");
Assert.IsNotNull(filePathParam);
Assert.AreEqual("FilePath", filePathParam.Name);
Assert.AreEqual(0, filePathParam.Position);
Assert.AreEqual(true, filePathParam.IsMandatory);
CommandParameterInfo variableParam = variableSet.GetParameterByName("Variable");
Assert.IsNotNull(variableParam);
Assert.AreEqual("Variable", variableParam.Name);
Assert.AreEqual(-1, variableParam.Position);
Assert.AreEqual(true, variableParam.IsMandatory);
CommandParameterInfo ageParam = fileSet.GetParameterByName("Age");
Assert.IsNull(ageParam);
}
public ParameterDescription(CommandParameterInfo param)
{
m_initialize(param);
}
public ClassifiedArgument(ArgumentType argumentType, CommandParameterInfo parameterInfo, string value)
{
this.ArgumentType = argumentType;
this.ParameterInfo = parameterInfo;
this.Value = value;
}
void getSyntax(PSObject cmdlet)
{
Syntax = new List <String>();
foreach (CommandParameterSetInfo paraset in ParameterSets)
{
String syntaxItem = Convert.ToString(cmdlet.Members["name"].Value);
foreach (CommandParameterInfo item in paraset.Parameters)
{
if (_excludedParams.Contains(item.Name.ToLower()))
{
continue;
}
Boolean named = item.Position < 0;
// fetch param type
String paramType = String.Empty;
CommandParameterInfo item1 = item;
foreach (ParameterDescription param in Parameters.Where(param => item1.Name == param.Name))
{
paramType = param.Type;
}
// fetch VelidateSet attribute
String validateSet = String.Empty;
foreach (Attribute attribute in item.Attributes)
{
Boolean found = false;
validateSet = String.Empty;
switch (attribute.TypeId.ToString())
{
case "System.Management.Automation.ValidateSetAttribute":
validateSet += " {";
validateSet += String.Join(" | ", ((ValidateSetAttribute)attribute).ValidValues);
validateSet += "} ";
found = true;
break;
}
if (found)
{
break;
}
}
if (item.IsMandatory && named)
{
syntaxItem += " -" + item.Name + " <" + paramType + ">" + validateSet;
}
else if (item.IsMandatory)
{
syntaxItem += " [-" + item.Name + "] <" + paramType + ">" + validateSet;
}
else if (!named)
{
syntaxItem += " [[-" + item.Name + "] <" + paramType + ">" + validateSet + "]";
}
else if (!String.IsNullOrEmpty(paramType) && paramType != "SwitchParameter")
{
syntaxItem += " [-" + item.Name + " <" + paramType + ">" + validateSet + "]";
}
else
{
syntaxItem += " [-" + item.Name + validateSet + "]";
}
}
Syntax.Add(syntaxItem);
}
}
