public static int Run(ParseResult result)
{
result.HandleDebugSwitch();
Console.WriteLine(result.Diagram());
if (result.UnparsedTokens.Any())
{
Console.WriteLine("Unparsed Tokens: ");
Console.WriteLine(string.Join(" ", result.UnparsedTokens));
}
var optionValuesToBeForwarded = result.OptionValuesToBeForwarded(ParseCommandParser.GetCommand());
if (optionValuesToBeForwarded.Any())
{
Console.WriteLine("Option values to be forwarded: ");
Console.WriteLine(string.Join(" ", optionValuesToBeForwarded));
}
if (result.Errors.Any())
{
Console.WriteLine();
Console.WriteLine("ERRORS");
Console.WriteLine();
foreach (var error in result.Errors)
{
Console.WriteLine(error?.Message);
}
}
return(0);
}
public void Views_can_be_registered_for_specific_types()
{
ParseResult parseResult = null;
var command = new RootCommand
{
Handler = CommandHandler.Create <ParseResult, IConsole>(
(r, c) =>
{
parseResult = r;
c.Append(new ParseResultView(r));
}
)
};
var parser = new CommandLineBuilder(command)
.UseMiddleware(
c =>
{
c.BindingContext.AddService(
s => new ParseResultView(s.GetService <ParseResult>())
);
}
)
.Build();
var terminal = new TestTerminal {
IsAnsiTerminal = false
};
parser.Invoke("", terminal);
terminal.Out.ToString().Should().Contain(parseResult.Diagram());
}
public void An_inner_command_with_the_same_name_does_not_capture()
{
var command = new Command("one")
{
new Command("two")
{
new Command("three")
},
new Command("three")
};
ParseResult result = command.Parse("one three");
result.Diagram().Should().Be("[ one [ three ] ]");
}
public void Unmatched_options_are_not_split_into_smaller_tokens()
{
var outer = new Command("outer");
outer.AddOption(
new Option("-p"));
outer.AddCommand(
new Command("inner",
argument: new Argument
{
Arity = ArgumentArity.OneOrMore
}));
ParseResult result = outer.Parse("outer inner -p:RandomThing=random");
_output.WriteLine(result.Diagram());
result.CommandResult
.Arguments
.Should()
.BeEquivalentTo("-p:RandomThing=random");
}
public void A_root_command_can_match_a_full_path_to_an_executable()
{
var command = new RootCommand
{
new Command("inner")
{
new Option(
"-x",
"",
new Argument
{
Arity = ArgumentArity.ExactlyOne
})
}
};
ParseResult result1 = command.Parse("inner -x hello");
ParseResult result2 = command.Parse($"{RootCommand.ExePath} inner -x hello");
result1.Diagram().Should().Be(result2.Diagram());
}
public void Subsequent_occurrences_of_tokens_matching_command_names_are_parsed_as_arguments()
{
var command = new Command("the-command");
var complete = new Command("complete", argument: new Argument <string>());
command.AddCommand(complete);
var position = new Option("--position",
argument: new Argument <int>());
complete.AddOption(position);
ParseResult result = command.Parse("the-command",
"complete",
"--position",
"7",
"the-command");
CommandResult completeResult = result.CommandResult;
_output.WriteLine(result.Diagram());
completeResult.Arguments.Should().BeEquivalentTo("the-command");
}
public void Nested_commands_with_colliding_names_cannot_both_be_applied()
{
var command = new Command(
"outer", "",
argument: new Argument <string>())
{
new Command(
"non-unique",
argument: new Argument <string>()),
new Command(
"inner", "",
argument: new Argument <string>())
{
new Command(
"non-unique",
argument: new Argument <string>())
}
};
ParseResult result = command.Parse("outer arg1 inner arg2 non-unique arg3 ");
result.Diagram().Should().Be($"[ outer [ inner [ non-unique <arg3> ] <arg2> ] <arg1> ]");
}
private static int ProcessArgs(ParseResult result)
{
result.ShowHelpOrErrorIfAppropriate();
var command = result.AppliedCommand();
var verbosityValue = result["dotnet-migrate-2017"].ValueOrDefault <string>("verbosity")?.Trim().ToLowerInvariant() ?? "normal";
switch (verbosityValue)
{
case "q":
case "quiet":
verbosity.MinimumLevel = LogEventLevel.Fatal + 1;
break;
case "m":
case "minimal":
verbosity.MinimumLevel = LogEventLevel.Warning;
break;
case "n":
case "normal":
verbosity.MinimumLevel = LogEventLevel.Information;
break;
case "d":
case "detailed":
verbosity.MinimumLevel = LogEventLevel.Debug;
break;
// ReSharper disable once StringLiteralTypo
case "diag":
case "diagnostic":
verbosity.MinimumLevel = LogEventLevel.Verbose;
break;
default:
throw new CommandParsingException($"Unknown verbosity level '{verbosityValue}'.", result.Command().HelpView().TrimEnd());
}
Log.Verbose(result.Diagram());
var items = command.Value <string[]>();
var conversionOptions = new ConversionOptions
{
ProjectCache = new DefaultProjectCache()
};
var frameworks = command.ValueOrDefault <string[]>("target-frameworks");
if (frameworks != null)
{
conversionOptions.TargetFrameworks = frameworks;
}
var logic = new CommandLogic();
switch (command.Name)
{
case "evaluate":
logic.ExecuteEvaluate(items, conversionOptions);
break;
case "migrate":
conversionOptions.AppendTargetFrameworkToOutputPath =
!command.ValueOrDefault <bool>("old-output-path");
conversionOptions.KeepAssemblyInfo = command.ValueOrDefault <bool>("keep-assembly-info");
logic.ExecuteMigrate(items, command.ValueOrDefault <bool>("no-backup"), conversionOptions);
break;
case "analyze":
logic.ExecuteAnalyze(items, conversionOptions);
break;
}
return(result.Execute().Code);
}
private static int ProcessArgs(ParseResult result)
{
result.ShowHelpOrErrorIfAppropriate();
var command = result.AppliedCommand();
var globalOptions = result["dotnet-migrate-2017"];
ProgramBase.ApplyVerbosity(result, globalOptions);
Log.Verbose(result.Diagram());
var items = command.Value <string[]>();
var conversionOptions = new ConversionOptions
{
ProjectCache = new DefaultProjectCache(),
ForceOnUnsupportedProjects = command.ValueOrDefault <bool>("force"),
KeepAssemblyInfo = command.ValueOrDefault <bool>("keep-assembly-info")
};
switch (command.Name)
{
case "evaluate":
case "migrate":
var frameworks = command.ValueOrDefault <string[]>("target-frameworks");
if (frameworks != null)
{
conversionOptions.TargetFrameworks = frameworks;
}
break;
}
var logic = new CommandLogic();
switch (command.Name)
{
case "wizard":
var diagnostics = new DiagnosticSet(Vs15DiagnosticSet.All);
diagnostics.ExceptWith(DiagnosticSet.All);
var sets = new WizardTransformationSets
{
MigrateSet = new ChainTransformationSet(
new BasicSimplifyTransformationSet(Vs15TransformationSet.TargetVisualStudioVersion),
Vs15TransformationSet.TrueInstance),
ModernCleanUpSet = new BasicSimplifyTransformationSet(
Vs15TransformationSet.TargetVisualStudioVersion),
ModernizeSet = new ChainTransformationSet(
new BasicSimplifyTransformationSet(Vs15TransformationSet.TargetVisualStudioVersion),
Vs15ModernizationTransformationSet.TrueInstance),
Diagnostics = diagnostics
};
logic.ExecuteWizard(items, conversionOptions, sets);
break;
case "evaluate":
logic.ExecuteEvaluate(items, conversionOptions, Vs15TransformationSet.Instance, new AnalysisOptions(Vs15DiagnosticSet.All));
break;
case "analyze":
logic.ExecuteAnalyze(items, conversionOptions, new AnalysisOptions(Vs15DiagnosticSet.All));
break;
case "migrate":
conversionOptions.AppendTargetFrameworkToOutputPath = !command.ValueOrDefault <bool>("old-output-path");
var forceTransformations = command.ValueOrDefault <string[]>("force-transformations");
if (forceTransformations != null)
{
conversionOptions.ForceDefaultTransforms = forceTransformations;
}
logic.ExecuteMigrate(items, command.ValueOrDefault <bool>("no-backup"), conversionOptions, Vs15TransformationSet.Instance);
break;
}
return(result.Execute().Code);
}
