private static string GetHelpText(string commandName = null, bool manual = false, bool includeValues = false)
{
if (commandName != null)
{
Command command = CommandLoader.LoadCommand(typeof(HelpCommand).Assembly, commandName);
if (command == null)
{
throw new ArgumentException($"Command '{commandName}' does not exist.", nameof(commandName));
}
return(HelpProvider.GetHelpText(command, includeValues));
}
else if (manual)
{
return(HelpProvider.GetManual(includeValues: includeValues));
}
else
{
return(HelpProvider.GetHelpText(includeValues: includeValues));
}
}
public static bool TryParseFileProperties(
IEnumerable <string> values,
string optionName,
out FilterPredicate <DateTime>?creationTimePredicate,
out FilterPredicate <DateTime>?modifiedTimePredicate,
out FilterPredicate <long>?sizePredicate)
{
creationTimePredicate = null;
modifiedTimePredicate = null;
sizePredicate = null;
foreach (string value in values)
{
Expression? expression = null;
OptionValue?optionValue = null;
try
{
expression = Expression.Parse(value);
if (OptionValues.FileProperty_CreationTime.IsKeyOrShortKey(expression.Identifier))
{
optionValue = OptionValues.FileProperty_CreationTime;
creationTimePredicate = new FilterPredicate <DateTime>(
expression,
PredicateHelpers.GetDateTimePredicate(expression));
}
else if (OptionValues.FileProperty_ModifiedTime.IsKeyOrShortKey(expression.Identifier))
{
optionValue = OptionValues.FileProperty_ModifiedTime;
modifiedTimePredicate = new FilterPredicate <DateTime>(
expression,
PredicateHelpers.GetDateTimePredicate(expression));
}
else if (OptionValues.FileProperty_Size.IsKeyOrShortKey(expression.Identifier))
{
optionValue = OptionValues.FileProperty_Size;
if (expression.Kind == ExpressionKind.DecrementExpression)
{
WriteOptionError(value, optionName, HelpProvider.GetExpressionsText(" ", includeDate: false));
return(false);
}
sizePredicate = new FilterPredicate <long>(expression, PredicateHelpers.GetLongPredicate(expression));
}
else
{
WriteOptionError(value, optionName, OptionValueProviders.FilePropertiesProvider);
return(false);
}
}
catch (ArgumentException)
{
if (expression != null &&
optionValue != null)
{
WriteOptionValueError(
expression.Value,
optionValue,
HelpProvider.GetExpressionsText(
" ",
includeDate: optionValue != OptionValues.FileProperty_Size));
}
else
{
WriteOptionError(value, optionName, HelpProvider.GetExpressionsText(" "));
}
return(false);
}
}
return(true);
}
private static void WriteManual(bool includeValues = false, Filter?filter = null)
{
IEnumerable <Command> commands = LoadCommands();
var writer = new ConsoleHelpWriter(new HelpWriterOptions(filter: filter));
IEnumerable <CommandHelp> commandHelps = commands.Select(f => CommandHelp.Create(f, filter: filter))
.Where(f => f.Arguments.Any() || f.Options.Any())
.ToImmutableArray();
ImmutableArray <CommandItem> commandItems = HelpProvider.GetCommandItems(commandHelps.Select(f => f.Command));
ImmutableArray <OptionValueList> values = ImmutableArray <OptionValueList> .Empty;
if (commandItems.Any())
{
values = HelpProvider.GetOptionValues(
commandHelps.SelectMany(f => f.Command.Options),
OptionValueProviders.Providers,
filter);
var commandsHelp = new CommandsHelp(commandItems, values);
writer.WriteCommands(commandsHelp);
foreach (CommandHelp commandHelp in commandHelps)
{
WriteSeparator();
WriteLine();
WriteLine($"Command: {commandHelp.Name}");
WriteLine();
string description = commandHelp.Description;
if (!string.IsNullOrEmpty(description))
{
WriteLine(description);
WriteLine();
}
writer.WriteCommand(commandHelp);
}
if (includeValues)
{
WriteSeparator();
}
}
else
{
WriteLine();
WriteLine("No command found");
if (includeValues)
{
values = HelpProvider.GetOptionValues(
commands.Select(f => CommandHelp.Create(f)).SelectMany(f => f.Command.Options),
OptionValueProviders.Providers,
filter);
}
}
if (includeValues)
{
writer.WriteValues(values);
}
public static bool TryParse(
IEnumerable <string> values,
string optionName,
OptionValueProvider provider,
out Filter?filter,
out FileNamePart namePart,
bool allowNull = false,
OptionValueProvider?namePartProvider = null,
FileNamePart defaultNamePart = FileNamePart.Name,
PatternOptions includedPatternOptions = PatternOptions.None)
{
filter = null;
namePart = defaultNamePart;
string?pattern = values.FirstOrDefault();
if (pattern == null)
{
if (allowNull)
{
return(true);
}
else
{
throw new InvalidOperationException($"Option '{OptionNames.GetHelpText(optionName)}' is required.");
}
}
TimeSpan matchTimeout = Regex.InfiniteMatchTimeout;
string? groupName = null;
string? separator = null;
Func <string, bool>?predicate = null;
List <string>?options = null;
foreach (string option in values.Skip(1))
{
int index = option.IndexOfAny(_equalsOrLessThanOrGreaterThanChars);
if (index != -1)
{
string key = option.Substring(0, index);
if (!provider.ContainsKeyOrShortKey(key))
{
WriteOptionError(option, optionName, provider);
return(false);
}
string value = option.Substring(index + 1);
if (OptionValues.Group.IsKeyOrShortKey(key))
{
groupName = value;
continue;
}
else if (OptionValues.ListSeparator.IsKeyOrShortKey(key))
{
separator = value;
continue;
}
else if (OptionValues.Part.IsKeyOrShortKey(key))
{
if (!TryParseAsEnum(
value,
out namePart,
provider: namePartProvider ?? OptionValueProviders.NamePartKindProvider))
{
WriteOptionValueError(
value,
OptionValues.Part,
namePartProvider ?? OptionValueProviders.NamePartKindProvider);
return(false);
}
continue;
}
else if (OptionValues.Timeout.IsKeyOrShortKey(key))
{
if (!TryParseMatchTimeout(value, out matchTimeout))
{
WriteOptionValueError(value, OptionValues.Timeout);
return(false);
}
continue;
}
}
if (Expression.TryParse(option, out Expression? expression))
{
if (OptionValues.Length.IsKeyOrShortKey(expression.Identifier) &&
provider.ContainsKeyOrShortKey(expression.Identifier))
{
try
{
predicate = PredicateHelpers.GetLengthPredicate(expression);
continue;
}
catch (ArgumentException)
{
WriteOptionValueError(
expression.Value,
OptionValues.Length,
HelpProvider.GetExpressionsText(" ", includeDate: false));
return(false);
}
}
else
{
WriteOptionError(option, optionName, provider);
return(false);
}
}
(options ??= new List <string>()).Add(option);
}
if (!TryParseRegexOptions(
options,
optionName,
out RegexOptions regexOptions,
out PatternOptions patternOptions,
includedPatternOptions,
provider))
{
return(false);
}
switch (patternOptions & (PatternOptions.WholeWord | PatternOptions.WholeLine))
{
case PatternOptions.None:
case PatternOptions.WholeWord:
case PatternOptions.WholeLine:
{
break;
}
default:
{
string helpValue = OptionValueProviders.PatternOptionsProvider
.GetValue(nameof(PatternOptions.WholeWord)).HelpValue;
string helpValue2 = OptionValueProviders.PatternOptionsProvider
.GetValue(nameof(PatternOptions.WholeLine)).HelpValue;
WriteError($"Values '{helpValue}' and '{helpValue2}' cannot be combined.");
return(false);
}
}
if ((patternOptions & PatternOptions.FromFile) != 0 &&
!FileSystemHelpers.TryReadAllText(pattern, out pattern, ex => WriteError(ex)))
{
return(false);
}
pattern = BuildPattern(pattern, patternOptions, separator);
if (pattern.Length == 0)
{
throw new InvalidOperationException(
$"Option '{OptionNames.GetHelpText(optionName)}' is invalid: pattern cannot be empty.");
}
Regex?regex = null;
try
{
regex = new Regex(pattern, regexOptions, matchTimeout);
}
catch (ArgumentException ex)
{
WriteError(ex, $"Could not parse regular expression: {ex.Message}");
return(false);
}
int groupIndex = -1;
if (groupName != null)
{
groupIndex = regex.GroupNumberFromName(groupName);
if (groupIndex == -1)
{
string message = $"Group '{groupName}' does not exist.";
string[] groupNames = regex.GetGroupNames();
if (groupNames.Length > 1)
{
message += " Existing group names: "
+ $"{TextHelpers.Join(", ", " and ", groupNames.Where(f => f != "0"))}.";
}
WriteError(message);
return(false);
}
}
filter = new Filter(
regex,
isNegative: (patternOptions & PatternOptions.Negative) != 0,
groupNumber: groupIndex,
predicate: predicate);
return(true);
}
private static int Main(string[] args)
{
//WriteLine($"Orang Command Line Tool version {typeof(Program).GetTypeInfo().Assembly.GetName().Version}");
//WriteLine("Copyright (c) Josef Pihrt. All rights reserved.");
//WriteLine();
if (args != null)
{
if (args.Length == 1)
{
if (IsHelpOption(args[0]))
{
Console.Write(HelpProvider.GetHelpText());
return(0);
}
}
else if (args.Length == 2)
{
if (args?.Length == 2 &&
IsHelpOption(args[1]))
{
Command command = CommandLoader.LoadCommand(typeof(HelpCommand).Assembly, args[0]);
if (command != null)
{
Console.Write(HelpProvider.GetHelpText(command));
return(0);
}
}
}
}
try
{
ParserSettings defaultSettings = Parser.Default.Settings;
var parser = new Parser(settings =>
{
settings.AutoHelp = false;
settings.AutoVersion = defaultSettings.AutoVersion;
settings.CaseInsensitiveEnumValues = defaultSettings.CaseInsensitiveEnumValues;
settings.CaseSensitive = defaultSettings.CaseSensitive;
settings.EnableDashDash = true;
settings.HelpWriter = null;
settings.IgnoreUnknownArguments = defaultSettings.IgnoreUnknownArguments;
settings.MaximumDisplayWidth = defaultSettings.MaximumDisplayWidth;
settings.ParsingCulture = defaultSettings.ParsingCulture;
});
ParserResult <object> parserResult = parser.ParseArguments <
CopyCommandLineOptions,
DeleteCommandLineOptions,
EscapeCommandLineOptions,
FindCommandLineOptions,
HelpCommandLineOptions,
ListSyntaxCommandLineOptions,
MatchCommandLineOptions,
MoveCommandLineOptions,
RenameCommandLineOptions,
ReplaceCommandLineOptions,
SplitCommandLineOptions
>(args);
bool help = false;
bool success = true;
parserResult.WithNotParsed(_ =>
{
var helpText = new HelpText(SentenceBuilder.Create(), HelpProvider.GetHeadingText());
helpText = HelpText.DefaultParsingErrorsHandler(parserResult, helpText);
VerbAttribute verbAttribute = parserResult.TypeInfo.Current.GetCustomAttribute <VerbAttribute>();
if (verbAttribute != null)
{
helpText.AddPreOptionsText(Environment.NewLine + HelpProvider.GetFooterText(verbAttribute.Name));
}
Console.Error.WriteLine(helpText);
success = false;
});
parserResult.WithParsed <AbstractCommandLineOptions>(options =>
{
if (options.Help)
{
string commandName = options.GetType().GetCustomAttribute <VerbAttribute>().Name;
Console.WriteLine(HelpProvider.GetHelpText(commandName));
help = true;
return;
}
success = false;
var defaultVerbosity = Verbosity.Normal;
if (options.Verbosity == null ||
TryParseVerbosity(options.Verbosity, out defaultVerbosity))
{
ConsoleOut.Verbosity = defaultVerbosity;
if (TryParseOutputOptions(options.Output, OptionNames.Output, out string filePath, out Verbosity fileVerbosity, out Encoding encoding, out bool append))
{
if (filePath != null)
{
FileMode fileMode = (append)
? FileMode.Append
: FileMode.Create;
var stream = new FileStream(filePath, fileMode, FileAccess.Write, FileShare.Read);
var writer = new StreamWriter(stream, encoding, bufferSize: 4096, leaveOpen: false);
Out = new TextWriterWithVerbosity(writer)
{
Verbosity = fileVerbosity
};
}
success = true;
}
else
{
success = false;
}
}
});
if (help)
{
return(0);
}
if (!success)
{
return(2);
}
return(parserResult.MapResult(
(CopyCommandLineOptions options) => Copy(options),
(MoveCommandLineOptions options) => Move(options),
(DeleteCommandLineOptions options) => Delete(options),
(EscapeCommandLineOptions options) => Escape(options),
(FindCommandLineOptions options) => Find(options),
(HelpCommandLineOptions options) => Help(options),
(ListSyntaxCommandLineOptions options) => ListSyntax(options),
(MatchCommandLineOptions options) => Match(options),
(RenameCommandLineOptions options) => Rename(options),
(ReplaceCommandLineOptions options) => Replace(options),
(SplitCommandLineOptions options) => Split(options),
_ => 2));
}
