private static void ResolveNameOfUnnamedParams(IParsedParam param, ParameterDefinition def)
{
//add name to unnamed params
if (param is ComplexParam cp)
{
for (int i = 0; i < cp.SubParams.Length && i < def.SubParams.Length; i++)
{
var subParam = cp.SubParams[i];
var subDef = def.SubParams.OrderBy(f => f.Options.Order).ToArray()[i];
if (subDef.Type.IsBuiltIn(true) || subDef.Type.IsEnumerable())
{
if (String.IsNullOrWhiteSpace(subParam.Name))
{
subParam.Name = subDef.Name;
}
}
else
{
ResolveNameOfUnnamedParams(subParam, subDef);
}
}
}
else if (param is ArrayParam ap)
{
var subDef = def.SubParams.OrderBy(f => f.Options.Order).ToArray()[0];
if (String.IsNullOrWhiteSpace(param.Name))
{
param.Name = subDef.Name;
}
}
}
public void GetHelp(Type type, IParsedParam parsedParam)
{
this.Initialize(type);
string helpParam = ((SimpleParam)parsedParam)?.Value;
var cmdDefs = DefinitionHelper.GetCommandDefinitions(type);
cmdDefs.OrderBy(cDef => cDef.Name).ToList();
if (String.IsNullOrEmpty(helpParam))
{
string indentation = new string( ' ', 2 );
Console.WriteLine();
Console.WriteLine($"{indentation}AVAILABLE COMMANDS:");
Console.WriteLine();
Console.WriteLine($"{indentation}{indentation}{"COMMAND",-20}{"DESCRIPTION"}");
Console.WriteLine();
foreach (var cmdDef in cmdDefs)
{
Console.WriteLine($"{indentation}{indentation}{cmdDef.Name.ToLower(),-20}{cmdDef.Options.HelpText}");
}
Console.WriteLine();
Console.WriteLine($"{indentation}To invoke a command, type --<command>");
Console.WriteLine($"{indentation}For more info about a specific command, type --help <command>");
//Console.WriteLine( $"{indentation}Collection parameters must be surrounded by []" );
//Console.WriteLine( $"{indentation}Non primitives types must be surrounded by ()" );
Console.WriteLine();
}
//else if( !(helpCmd.Param is SimpleParam) )
//{
// Console.WriteLine( "--help accepts only one input argument" );
// //if( this.ShowHelpOnError )
// // this.Parse<T>( $"--{HelpCommandDefinition.Name.ToLower()} {HelpCommandDefinition.Name.ToLower()}" );
// //else
// // Console.WriteLine();
//}
else
{
var cmdUsage = cmdDefs.FirstOrDefault(cmd => cmd.Name.ToLower() == helpParam.ToLower());
if (cmdUsage == null)
{
Console.WriteLine($"A command named '{helpParam}' does not exist");
//if( this.ShowHelpOnError )
// this.Parse<T>( $"--{HelpCommandDefinition.Name.ToLower()}" );
//else
// Console.WriteLine();
}
else
{
string indentation = new string( ' ', 2 );
Console.WriteLine();
Console.WriteLine($"{indentation}COMMAND '{cmdUsage.Name.ToUpper()}'");
if (!String.IsNullOrWhiteSpace(cmdUsage.Options.HelpText))
{
Console.WriteLine($"{indentation}{indentation}{cmdUsage.Options.HelpText}");
}
Console.WriteLine();
Console.WriteLine($"{indentation}USAGE:");
var parameters = cmdUsage.SubParams.Select(p => p.Options.IsRequired ? p.Name.ToLower() : $"[{p.Name.ToLower()}]");
Console.WriteLine($"{indentation}{indentation}--{cmdUsage.Name.ToLower() } {String.Join( " ", parameters )}");
if (cmdUsage.SubParams.Length > 0)
{
Console.WriteLine();
Console.WriteLine($"{indentation}PARAMETERS DETAILS:");
Console.WriteLine();
int namePadRight = Math.Max(cmdUsage.SubParams.Max(p => p.Name.Length), "NAME".Length) + 3;
int typePadRight = Math.Max(cmdUsage.SubParams.Max(p => p.Type.GetPrettifiedName().Length), "TYPE".Length) + 3;
int requiredPadRight = "REQUIRED".Length + 3;
Console.WriteLine($"{indentation}{indentation}{"NAME".PadRight( namePadRight )}{"TYPE".PadRight( typePadRight )}{"REQUIRED".PadRight( requiredPadRight )}DESCRIPTION");
foreach (var param in cmdUsage.SubParams)
{
string required = param.Options.IsRequired ? "Yes" : "No";
string description = param.Options.HelpText ?? "<No description provided>";
Console.WriteLine($"{indentation}{indentation}{param.Name.PadRight( namePadRight )}{param.Type.GetPrettifiedName().PadRight( typePadRight )}{required.PadRight( requiredPadRight )}{description}");
}
}
Console.WriteLine();
}
}
}
public IEnumerable <ParsedCommand> Parse(string commandLine)
{
if (String.IsNullOrWhiteSpace(commandLine))
{
throw new ArgumentNullException(nameof(commandLine), "Null or empty command");
}
var commands = commandLine.SplitKeepDelimiter(COMMAND_IDENTIFIER).ToArray();
if (commands.Length == 0)
{
//try implicit notation
{
var match = BalancedParenthesesRegex.Match(commandLine);
if (!match.Success)
{
throw new SyntaxErrorException();
}
var parsedParams = match.Groups["params"]
.Captures.Cast <Capture>()
.Select(c => c.Value);
}
throw new SyntaxErrorException();
}
int paramIndex = 0;
foreach (var command in commands)
{
var match = CommandRegex.Match(command);
if (!match.Success)
{
throw new SyntaxErrorException();
}
var cmdName = match.Groups["command"].Value;
var parsedParams = match.Groups["params"]
.Captures.Cast <Capture>()
.Select(c => c.Value);
var parameters = GetCommandParams(parsedParams).ToList();
IParsedParam theparam = null;
if (parameters.Count > 1)
{
theparam = new ComplexParam()
{
//Name = cmdName,
Index = paramIndex,
SubParams = parameters.ToArray()
};
}
else
{
var p = parameters.FirstOrDefault();
if (p == null)
{
theparam = null;
}
else
{
p.Index = paramIndex;
theparam = p;
}
}
yield return(new ParsedCommand()
{
Name = cmdName,
Param = theparam
});
paramIndex++;
}
}
public ArgumentNumberException(IParsedParam param)
: base(String.Format(_errorMsg, param.Name))
{
this.Param = param;
}
private IParsedParam InternalOptionalMethodParams(IParsedParam param, ParameterDefinition def)
{
if (def.MemberType != MemberTypes.METHOD)
{
return(param);
}
ResolveNameOfUnnamedParams(param, def);
var optionalParams = def.SubParams.Where(p => !p.Options.IsRequired).ToList();
if (optionalParams.Count == 0)
{
return(param);
}
var requiredParams = def.SubParams.Except(optionalParams);
if (!(param is ComplexParam))
{
var subs = new List <IParsedParam>();
if (param != null)
{
subs.Add(param);
}
for (int paramIndex = 0; paramIndex < def.SubParams.Length; paramIndex++)
{
var sub = def.SubParams[paramIndex];
if (param?.Name == sub.Name)
{
continue;
}
//if( param?.Index == sub.Options.Order )
// continue;
if (!sub.Options.IsRequired)
{
if (sub.Type.IsBuiltIn(false))
{
subs.Add(new SimpleParam()
{
Name = sub.Name, Index = sub.Options.Order, Value = sub.DefaultValue?.ToString()
});
}
else if (sub.Type.IsEnumerable())
{
subs.Add(new ArrayParam()
{
Name = sub.Name, Index = sub.Options.Order
});
}
else
{
subs.Add(new ComplexParam()
{
Name = sub.Name, Index = sub.Options.Order
});
}
}
}
return(new ComplexParam()
{
SubParams = subs.ToArray()
});
}
else if (((ComplexParam)param).SubParams.Length < def.SubParams.Length)
{
var paramsSubs = new List <IParsedParam>();
paramsSubs.AddRange(((ComplexParam)param).SubParams);
for (int paramIndex = 0; paramIndex < def.SubParams.Length; paramIndex++)
{
var defSub = def.SubParams[paramIndex];
if (paramsSubs.Any(s => s.Name == defSub.Name))
{
continue;
}
//if( paramIndex < paramsSubs.Count &&
// paramsSubs[ paramIndex ].Index == defSub.Options.Order )
// continue;
if (!defSub.Options.IsRequired)
{
if (defSub.Type.IsBuiltIn(false))
{
paramsSubs.Add(new SimpleParam()
{
Name = defSub.Name, Index = defSub.Options.Order, Value = defSub.DefaultValue?.ToString()
});
}
else if (defSub.Type.IsEnumerable())
{
paramsSubs.Add(new ArrayParam()
{
Name = defSub.Name, Index = defSub.Options.Order
});
}
else
{
paramsSubs.Add(new ComplexParam()
{
Name = defSub.Name, Index = defSub.Options.Order
});
}
}
}
return(new ComplexParam()
{
SubParams = paramsSubs.ToArray()
});
}
return(param);
}
private IParsedParam Internal(IParsedParam param, ParameterDefinition def)
{
if (param == null)
{
return(null);
}
switch (param)
{
case ArrayParam _: return(param);
case SimpleParam sp:
if (def.Type?.IsBuiltIn(true) == true)
{
return(sp);
}
return(new ComplexParam()
{
Name = def.Name,
Index = 0,
SubParams = new[] { sp }
});
case ComplexParam cp:
{
var subParamsDef = def.SubParams;
if (subParamsDef.All(s => s.Type.IsBuiltIn(true)))
{
_complexParamChecks.Checks(cp, def.Type, def.SubParams);
return(cp);
}
IEnumerable <IParsedParam> getSubparams(ComplexParam localcp)
{
for (int i = 0; i < localcp.SubParams.Length; i++)
{
var item = localcp.SubParams[i];
var defSub = def.SubParams.FirstOrDefault(k => k.Name.ToLower() == item.Name.ToLower());
if (defSub == null)
{
defSub = def.SubParams.FirstOrDefault(k => k.Options.Order == item.Index);
}
var newitem = Internal(item, defSub);
yield return(newitem);
}
};
if (def.SubParams.Length == 1)
{
//nesting just to check properly
var temp = new ComplexParam()
{
Name = "",
SubParams = new[] { cp }
};
_complexParamChecks.Checks(temp, def.Type, def.SubParams);
var subparams = getSubparams(temp).ToArray();
return(subparams.First());
}
else
{
_complexParamChecks.Checks(cp, def.Type, def.SubParams);
var subparams = getSubparams(cp).ToArray();
return(new ComplexParam()
{
Name = def.Name,
Index = 0,
SubParams = subparams
});
}
}
}
throw new NotSupportedException();
}
public MisplacedNamedParamException(IParsedParam param)
: base(_errorMsg)
{
}
