public void formatting_help_command_with_console_formatter(IHelpFormatter formatter, ICommandHelp commandHelp, string result) { "Given I have a console formatter" ._(() => formatter = ServiceLocator.Resolve <ConsoleHelpFormatter>()); "And I have a help command" ._(() => commandHelp = new CommandHelp("init", "Crane.Core.Commands.Init", "Initializes a new project with foo and bar.", new[] { new CommandExample { Value = "Example 1" } })); "When I format the command" ._(() => result = formatter.Format(commandHelp)); "It should display the usage statement on the first line" ._(() => result.Line(0).Should().Be("usage: crane init <project name>")); "It should display the description statement on the 3rd line" ._(() => result.Line(2).Should().Be("Initializes a new project with foo and bar.")); "It should display the example" ._(() => result.Line(4).Should().Be("Example 1")); "It should display for information url" ._(() => result.Line(6).Should().Contain("For more information, visit")); }
public GenDocCommandHandler(IFileManager fileManager, IPublicCommandResolver commandResolver, IHelpProvider helpProvider, MarkdownHelpFormatter helpFormatter) { _fileManager = fileManager; _helpProvider = helpProvider; _helpFormatter = helpFormatter; _commands = commandResolver.Resolve().OrderBy(command => command.Name()); }
/// <summary> /// Prints help for all possible commands in the specified types /// </summary> /// <param name="types">List of types in which to get all assemblies, or nothing to scan all assembly</param> /// <param name="helpFormatter">Help formatting engine, or nothing to format the messages to console</param> /// <param name="configurationBuilder">Configuration builder action, or nothing to use defaults</param> public static void PrintHelp(Type[] types, IHelpFormatter helpFormatter = null, Action <Parser.Configuration> configurationBuilder = null) { // Extract available commands based on information gathered & print help var configuration = Parse(types, configurationBuilder); PrintHelpInternal(configuration, null, helpFormatter, new Operation.Items(new Operation.OperationResult()), false); }
/// <summary> /// Executes the command /// </summary> /// <param name="args">List of arguments</param> /// <param name="operationResult">Operation result to write in</param> /// <param name="helpFormatter">Formatter object in case we need to write help</param> /// <returns>Results from execution</returns> public OperationExecutionResult Execute(string[] args, IHelpFormatter helpFormatter = null) { var operationResult = new Operation.OperationExecutionResult(); ExecuteInternal(args, operationResult); return(operationResult); }
public void formatting_help_command_with_console_formatter(IHelpFormatter formatter, ICommandHelp commandHelp, string result) { "Given I have a markdown formatter" ._(() => formatter = ServiceLocator.Resolve <MarkdownHelpFormatter>()); "And I have a help command" ._(() => commandHelp = new CommandHelp("init", "Crane.Core.Commands.Init", "Initializes a new project with foo and bar.", new[] { new CommandExample { Value = "Example 1\n<code>usage</code>\n<code>\nvar x = 1;\nvar y=2;\n</code>" } })); "When I format the command" ._(() => result = formatter.Format(commandHelp)); "Then it should display the usage statement on the first line" ._(() => result.Line(0).Should().Be("`usage: crane init <project name>`")); "And it should display the description statement on the 3rd line" ._(() => result.Line(2).Should().Be("Initializes a new project with foo and bar.")); "And it should display the first line of an example as a title" ._(() => result.Lines().First(item => item.Contains("Example")) .Should().StartWith("**") .And.EndWith("** ")); "And it should display any code element values that start and begin on the same line as markdown code blocks using single back ticks" ._(() => result.Should().Contain("`usage`")); "And it should display any multiline code blocks as markdown code blocks" ._( () => result.Should().Contain(string.Format("```{0}var x = 1;{0}var y=2;{0}```", Environment.NewLine))); }
/// <summary> /// A helper method for getting the formatted help text into a string /// </summary> /// <param name="source">The implemented help formatter</param> /// <param name="modelHelp">The data structure that contains the help information</param> /// <returns></returns> public static string GetHelp(this IHelpFormatter source, ModelHelp modelHelp) { if (source == null) { throw new ArgumentNullException("source"); } var builder = new StringBuilder(); using (var writer = new StringWriter(builder)) { source.WriteHelp(modelHelp, writer); } return(builder.ToString()); }
internal static void PrintHelpInternal(Parser.Configuration configuration, Parser.Command command, IHelpFormatter helpFormatter, Operation.Items operationMessages, bool error = true) { var f = (helpFormatter ?? new Formatters.Console()); var exit = (f as Formatters.FormatterBase)?.ExitOnError ?? true; // Print help using the help formatter, or create a default console messenger for this f.PrintHelp(configuration, command, operationMessages); PrintDebug(operationMessages); if (error && exit) { Environment.Exit(Int32.MinValue); } }
/// <summary> /// Prints help for all possible commands in the specified types /// </summary> /// <param name="type">Types in which to get all assemblies, or nothing to scan all assembly</param> /// <param name="helpFormatter">Help formatting engine, or nothing to format the messages to console</param> /// <param name="configurationBuilder">Configuration builder action, or nothing to use defaults</param> public static void PrintHelp(Type type, IHelpFormatter helpFormatter = null, Action <Parser.Configuration> configurationBuilder = null) { PrintHelp(new[] { type }, helpFormatter, configurationBuilder); }
public static void PrintHelp(this IHelpFormatter formatter, Options options, TextWriter writer) { PrintHelp(formatter, options, writer, false); }
public static void PrintHelpToConsole(this IHelpFormatter formatter, Options options, bool autoUsage) { formatter.PrintHelp(options, Console.Out, autoUsage); }
public static void PrintHelpToConsole(this IHelpFormatter formatter, Options options) { PrintHelpToConsole(formatter, options, false); }
public static void PrintHelp(this IHelpFormatter formatter, Options options, TextWriter writer, bool autoUsage) { formatter.PrintHelp(options, new HelpSettings(), writer, autoUsage); }
/// <summary> /// Executes the command passed in the arguments /// </summary> /// <param name="args">List of retrieved arguments, or null to extract the arguments from the Environment</param> /// <param name="types">List of types in which to get all assemblies, or nothing to scan all assembly</param> /// <param name="helpFormatter">Help formatting engine, or nothing to format the messages to console</param> /// <param name="configurationBuilder">Configuration builder action, or nothing to use defaults</param> /// <returns>Results from the operation</returns> public static Operation.OperationExecutionResult Execute(string[] args, Type[] types, IHelpFormatter helpFormatter = null, Action <Parser.Configuration> configurationBuilder = null) { // Get safe args collection args = GetSafeArgs(args); // Extract available commands based on information gathered var configuration = CommandParser.Parse(types, configurationBuilder); // Start logging operation var operationResult = new Operation.OperationExecutionResult(); // Get command from arguments operationResult.Messages.Add(new Operation.Messages.Progress(Resources.GetFromArguments)); var command = configuration.GetCommand(args); var requestedHelp = configuration.GetArgumentHelp(args); operationResult.Messages.Add(new Operation.Messages.Information(String.Format(Resources.CommandInformation, (command == null ? "Unknown" : command.Name), requestedHelp))); // User requested help if (requestedHelp) { CommandParser.PrintHelpInternal(configuration, command, helpFormatter, operationResult.Messages, false); return(operationResult); } // We could not get a command, but there is only one that exists, so we can try to execute it if (command == null && configuration.Commands.Count() == 1) { command = configuration.Commands.First(); operationResult.Messages.Add(new Operation.Messages.Information(String.Format(Resources.UnknownCommandSingle, command.Name))); command.ExecuteInternal(args, operationResult, helpFormatter); return(operationResult); } // Otherwise, execute from arguments if (command != null) { operationResult.Messages.Add(new Operation.Messages.Information(String.Format(Resources.ExecutingCommandFromArguments, command.Name))); command.ExecuteInternal(args, operationResult, helpFormatter); return(operationResult); } else { operationResult.Messages.Add(new Operation.Messages.Error(Resources.UnknownCommand)); CommandParser.PrintHelpInternal(configuration, null, helpFormatter, operationResult.Messages); return(operationResult); } }
/// <summary> /// Executes the command passed in the arguments /// </summary> /// <param name="args">List of retrieved arguments, or null to extract the arguments from the Environment</param> /// <param name="type">Type in which to get all assemblies, or nothing to scan all assembly</param> /// <param name="helpFormatter">Help formatting engine, or nothing to format the messages to console</param> /// <param name="configurationBuilder">Configuration builder action, or nothing to use defaults</param> /// <returns>Results from the operation</returns> public static Operation.OperationExecutionResult Execute(string[] args, Type type, IHelpFormatter helpFormatter = null, Action <Parser.Configuration> configurationBuilder = null) { return(Execute(args, new[] { type }, helpFormatter, configurationBuilder)); }
public HelpCommandHandler(IOutput output, IHelpProvider helpProvider, IHelpFormatter helpFormatter) { _output = output; _helpProvider = helpProvider; _helpFormatter = helpFormatter; }
/// <summary> /// Executes the command /// </summary> /// <param name="args">List of arguments</param> /// <param name="operationResult">Operation result to write in</param> /// <param name="helpFormatter">Formatter object in case we need to write help</param> internal void ExecuteInternal(string[] args, OperationExecutionResult operationResult, IHelpFormatter helpFormatter = null) { var parsedArguments = ValidateInternal(args, operationResult); if (!operationResult.Valid) { CommandParser.PrintHelpInternal(Configuration, this, helpFormatter, operationResult.Messages); return; } try { operationResult.Messages.Add(new Operation.Messages.Progress(String.Format(Resources.ExecutingCommand, Name))); // Create instance of reflected type var target = (object)null; if (!MethodInfo.IsStatic) { // No check, if it crashes it crashes operationResult.Messages.Add(new Operation.Messages.Warning(String.Format(Resources.CreatingDefaultInstance, MethodInfo.DeclaringType))); target = Activator.CreateInstance(MethodInfo.DeclaringType, true); } // Get values var allParameters = SystemParameters.Concat(Parameters).OrderBy(i => i.ParameterInfo.Position); var values = allParameters.Select(i => { if (typeof(InputArguments).GetTypeInfo().IsAssignableFrom(i.ParameterInfo.ParameterType)) { return(parsedArguments); } else if (typeof(OperationResult).GetTypeInfo().IsAssignableFrom(i.ParameterInfo.ParameterType)) { return(operationResult); } else if (typeof(Array).GetTypeInfo().IsAssignableFrom(i.ParameterInfo.ParameterType)) { var finalType = i.ParameterInfo.ParameterType.GetElementType(); var objectArray = parsedArguments.GetValue(i) .Select(j => Convert.ChangeType(j, finalType)) .ToArray(); var arr = Array.CreateInstance(finalType, objectArray.Length); Array.Copy(objectArray, arr, objectArray.Length); return(arr); } else { return(Convert.ChangeType(parsedArguments.GetValue(i)[0], i.ParameterInfo.ParameterType)); } }) .ToArray(); operationResult.Output = MethodInfo.Invoke(target, values); } catch (Exception e) { throw new CommandLineEngineException(Resources.ErrorExecutingCommand, operationResult, e); } finally { CommandParser.PrintDebug(operationResult.Messages); } }