public static bool TryParseModifier(
IEnumerable <string> values,
string optionName,
[NotNullWhen(true)] out EnumerableModifier <string>?modifier)
{
modifier = null;
if (!values.Any())
{
return(false);
}
string value = values.First();
if (!TryParseAsEnumFlags(
values.Skip(1),
optionName,
out ModifierOptions options,
ModifierOptions.None,
OptionValueProviders.ModifierOptionsProvider))
{
return(false);
}
if ((options & ModifierOptions.FromFile) != 0 &&
!FileSystemHelpers.TryReadAllText(value, out value !, ex => WriteError(ex)))
{
return(false);
}
if ((options & ModifierOptions.FromDll) != 0)
{
return(DelegateFactory.TryCreateFromAssembly(
value,
typeof(IEnumerable <string>),
typeof(IEnumerable <string>),
out modifier));
}
else if ((options & ModifierOptions.FromFile) != 0)
{
return(DelegateFactory.TryCreateFromSourceText(
value,
typeof(IEnumerable <string>),
typeof(IEnumerable <string>),
out modifier));
}
else
{
return(DelegateFactory.TryCreateFromExpression(
value,
"ModifierClass",
"ModifierMethod",
"IEnumerable<string>",
typeof(IEnumerable <string>),
"IEnumerable<string>",
typeof(IEnumerable <string>),
"items",
out modifier));
}
}
public ModifyOptions(
ModifyFunctions functions = ModifyFunctions.None,
bool aggregate = false,
bool ignoreCase = false,
bool cultureInvariant = false,
ValueSortProperty sortProperty = ValueSortProperty.None,
EnumerableModifier <string>?modifier = null)
{
Functions = functions;
Aggregate = aggregate;
IgnoreCase = ignoreCase;
CultureInvariant = cultureInvariant;
SortProperty = sortProperty;
Modifier = modifier;
}
public static bool TryParseModifyOptions(
IEnumerable <string> values,
string optionName,
EnumerableModifier <string>?modifier,
[NotNullWhen(true)] out ModifyOptions?modifyOptions,
out bool aggregateOnly)
{
modifyOptions = null;
aggregateOnly = false;
var sortProperty = ValueSortProperty.None;
List <string>?options = null;
foreach (string value in values)
{
int index = value.IndexOf('=');
if (index >= 0)
{
string key = value.Substring(0, index);
string value2 = value.Substring(index + 1);
if (OptionValues.SortBy.IsKeyOrShortKey(key))
{
if (!TryParseAsEnum(
value2,
optionName,
out sortProperty,
provider: OptionValueProviders.ValueSortPropertyProvider))
{
return(false);
}
}
else
{
WriteOptionError(value, optionName, OptionValueProviders.ModifyFlagsProvider);
return(false);
}
}
else
{
string value2 = value;
if (value2 == "ao")
{
LogHelpers.WriteObsoleteWarning(
$"Value '{value2}' is obsolete. Use value '{OptionValues.ModifyFlags_AggregateOnly.HelpValue}' instead.");
value2 = OptionValues.ModifyFlags_AggregateOnly.ShortValue;
}
(options ??= new List <string>()).Add(value2);
}
}
var modifyFlags = ModifyFlags.None;
if (options != null &&
!TryParseAsEnumFlags(
options,
optionName,
out modifyFlags,
provider: OptionValueProviders.ModifyFlagsProvider))
{
return(false);
}
ModifyFlags except_Intersect_Group = modifyFlags & ModifyFlags.Except_Intersect_Group;
if (except_Intersect_Group != ModifyFlags.None &&
except_Intersect_Group != ModifyFlags.Except &&
except_Intersect_Group != ModifyFlags.Intersect &&
except_Intersect_Group != ModifyFlags.Group)
{
WriteError($"Values '{OptionValues.ModifyFlags_Except.HelpValue}', "
+ $"'{OptionValues.ModifyFlags_Intersect.HelpValue}' and "
+ $"'{OptionValues.ModifyFlags_Group.HelpValue}' cannot be used at the same time.");
return(false);
}
var functions = ModifyFunctions.None;
if ((modifyFlags & ModifyFlags.Distinct) != 0)
{
functions |= ModifyFunctions.Distinct;
}
if ((modifyFlags & ModifyFlags.Ascending) != 0)
{
functions |= ModifyFunctions.Sort;
}
if ((modifyFlags & ModifyFlags.Descending) != 0)
{
functions |= ModifyFunctions.SortDescending;
}
if ((modifyFlags & ModifyFlags.Except) != 0)
{
functions |= ModifyFunctions.Except;
}
if ((modifyFlags & ModifyFlags.Intersect) != 0)
{
functions |= ModifyFunctions.Intersect;
}
if ((modifyFlags & ModifyFlags.Group) != 0)
{
functions |= ModifyFunctions.Group;
}
if ((modifyFlags & ModifyFlags.RemoveEmpty) != 0)
{
functions |= ModifyFunctions.RemoveEmpty;
}
if ((modifyFlags & ModifyFlags.RemoveWhiteSpace) != 0)
{
functions |= ModifyFunctions.RemoveWhiteSpace;
}
if ((modifyFlags & ModifyFlags.TrimStart) != 0)
{
functions |= ModifyFunctions.TrimStart;
}
if ((modifyFlags & ModifyFlags.TrimEnd) != 0)
{
functions |= ModifyFunctions.TrimEnd;
}
if ((modifyFlags & ModifyFlags.ToLower) != 0)
{
functions |= ModifyFunctions.ToLower;
}
if ((modifyFlags & ModifyFlags.ToUpper) != 0)
{
functions |= ModifyFunctions.ToUpper;
}
if (sortProperty != ValueSortProperty.None &&
(functions & ModifyFunctions.Sort) == 0 &&
(functions & ModifyFunctions.SortDescending) == 0)
{
functions |= ModifyFunctions.Sort;
}
aggregateOnly = (modifyFlags & ModifyFlags.AggregateOnly) != 0;
if (modifyFlags != ModifyFlags.None ||
functions != ModifyFunctions.None ||
modifier != null)
{
modifyOptions = new ModifyOptions(
functions: functions,
aggregate: (modifyFlags & ModifyFlags.Aggregate) != 0 || aggregateOnly,
ignoreCase: (modifyFlags & ModifyFlags.IgnoreCase) != 0,
cultureInvariant: (modifyFlags & ModifyFlags.CultureInvariant) != 0,
sortProperty: sortProperty,
modifier: modifier);
}
else
{
modifyOptions = ModifyOptions.Default;
}
return(true);
}
public bool TryParse(FindCommandOptions options)
{
if (!TryParseAsEnum(
Pipe,
OptionNames.Pipe,
out PipeMode pipeMode,
PipeMode.None,
OptionValueProviders.PipeMode))
{
return(false);
}
if (pipeMode == PipeMode.None)
{
if (Console.IsInputRedirected)
{
PipeMode = PipeMode.Text;
}
}
else
{
if (!Console.IsInputRedirected)
{
WriteError("Redirected/piped input is required "
+ $"when option '{OptionNames.GetHelpText(OptionNames.Pipe)}' is specified.");
return(false);
}
PipeMode = pipeMode;
}
var baseOptions = (CommonFindCommandOptions)options;
if (!TryParse(baseOptions))
{
return(false);
}
options = (FindCommandOptions)baseOptions;
if (!TryParseProperties(Ask, Name, options))
{
return(false);
}
string?input = null;
if (pipeMode != PipeMode.Paths &&
Console.IsInputRedirected)
{
if (options.ContentFilter == null)
{
WriteError($"Option '{OptionNames.GetHelpText(OptionNames.Content)}' is required "
+ "when redirected/piped input is used as a text to be searched.");
return(false);
}
input = ConsoleHelpers.ReadRedirectedInput();
}
EnumerableModifier <string>?modifier = null;
#if DEBUG // --modifier
if (Modifier.Any() &&
!TryParseModifier(Modifier, OptionNames.Modifier, out modifier))
{
return(false);
}
#endif
if (!TryParseModifyOptions(
Modify,
OptionNames.Modify,
modifier,
out ModifyOptions? modifyOptions,
out bool aggregateOnly))
{
return(false);
}
OutputDisplayFormat format = options.Format;
ContentDisplayStyle contentDisplayStyle = format.ContentDisplayStyle;
PathDisplayStyle pathDisplayStyle = format.PathDisplayStyle;
if (modifyOptions.HasAnyFunction &&
contentDisplayStyle == ContentDisplayStyle.ValueDetail)
{
contentDisplayStyle = ContentDisplayStyle.Value;
}
options.Input = input;
options.ModifyOptions = modifyOptions;
options.AggregateOnly = aggregateOnly;
options.Split = Split;
options.Format = new OutputDisplayFormat(
contentDisplayStyle: contentDisplayStyle,
pathDisplayStyle: pathDisplayStyle,
lineOptions: format.LineOptions,
lineContext: format.LineContext,
displayParts: format.DisplayParts,
fileProperties: format.FileProperties,
indent: format.Indent,
separator: format.Separator,
alignColumns: format.AlignColumns,
includeBaseDirectory: format.IncludeBaseDirectory);
return(true);
}
public bool TryParse(RegexCommandOptions options)
{
var baseOptions = (CommonRegexCommandOptions)options;
if (!TryParse(baseOptions))
{
return(false);
}
options = (RegexCommandOptions)baseOptions;
string input = Input.FirstOrDefault();
if (!string.IsNullOrEmpty(Path))
{
if (input != null)
{
WriteError($"Option '{OptionNames.GetHelpText(OptionNames.Input)}' and "
+ $"argument '{ArgumentMetaNames.Path}' cannot be set both at the same time.");
return(false);
}
try
{
input = File.ReadAllText(Path);
}
catch (Exception ex) when(ex is ArgumentException ||
ex is IOException ||
ex is UnauthorizedAccessException)
{
WriteError(ex);
return(false);
}
}
else if (string.IsNullOrEmpty(input))
{
string?redirectedInput = ConsoleHelpers.ReadRedirectedInput();
if (redirectedInput == null)
{
WriteError("Input is missing.");
return(false);
}
input = redirectedInput;
}
else if (!TryParseInput(Input, out input))
{
return(false);
}
if (!TryParseDisplay(
values: Display,
optionName: OptionNames.Display,
contentDisplayStyle: out ContentDisplayStyle? contentDisplayStyle,
pathDisplayStyle: out PathDisplayStyle? _,
lineDisplayOptions: out LineDisplayOptions lineDisplayOptions,
lineContext: out LineContext _,
displayParts: out DisplayParts displayParts,
fileProperties: out ImmutableArray <FileProperty> fileProperties,
indent: out string?indent,
separator: out string?separator,
noAlign: out bool _,
contentDisplayStyleProvider: OptionValueProviders.ContentDisplayStyleProvider_WithoutLineAndUnmatchedLines,
pathDisplayStyleProvider: OptionValueProviders.PathDisplayStyleProvider))
{
return(false);
}
EnumerableModifier <string>?modifier = null;
#if DEBUG // --modifier
if (Modifier.Any() &&
!TryParseModifier(Modifier, OptionNames.Modifier, out modifier))
{
return(false);
}
#endif
if (!TryParseModifyOptions(
Modify,
OptionNames.Modify,
modifier,
out ModifyOptions? modifyOptions,
out bool aggregateOnly))
{
return(false);
}
if (modifyOptions.HasAnyFunction &&
contentDisplayStyle == ContentDisplayStyle.ValueDetail)
{
contentDisplayStyle = ContentDisplayStyle.Value;
}
if (aggregateOnly)
{
ConsoleOut.Verbosity = Orang.Verbosity.Minimal;
}
options.Format = new OutputDisplayFormat(
contentDisplayStyle: contentDisplayStyle ?? ContentDisplayStyle.Value,
pathDisplayStyle: PathDisplayStyle.Full,
lineOptions: lineDisplayOptions,
displayParts: displayParts,
fileProperties: fileProperties,
indent: indent,
separator: separator ?? Environment.NewLine);
options.ModifyOptions = modifyOptions;
options.Input = input;
return(true);
}
