public static void InlineGenerate(InlineGenerateOptions options, IConsoleWriter console) { var cliDefinition = new CliDefinitionList() { Lines = new List <string>() { "using CommandLine;", "using System;", "using System.Collections.Generic;" }, Definitions = new List <CliDefinition>() { new CliDefinition() { Namespace = options.Namespace ?? "CommandLineOptions", ClassName = options.Class ?? "CommandLineOptions", Definition = options.Definition } } }; try { var definition = cliDefinition.Definitions.First(); var parsedDefinition = ParsedDefinition.Parse(definition); definition.Items = parsedDefinition.ParsedItems.Select(it => it.ToDefinitionItem()).ToList(); } catch { } WriteFile(cliDefinition, "inlineCli.json"); Generate(cliDefinition, options.OutputPath, options.OverwriteFiles, options.Verbose, console); }
public void Parse() { var def = new CliDefinitionList() { Definitions = new List <CliDefinition>() { new CliDefinition() { Definition = "verb -b", Items = new List <CliDefinitionItem>() { new CliDefinitionItem() { Verb = "verb" }, new CliDefinitionItem() { Option = "b" } } } } }; var consoleWriter = new TestConsoleWriter(); var result = ParsedDefinitionList.Parse(def, consoleWriter); Assert.NotNull(result); }
static void WriteFile(CliDefinitionList cliDefinitionSet, string fileName) { var json = JsonConvert.SerializeObject(cliDefinitionSet, new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.Indented, ContractResolver = new CamelCasePropertyNamesContractResolver() }); File.WriteAllText(fileName, json); }
public static void Generate( CliDefinitionList cliDefinition, string outputPath, bool overwriteFiles, bool verbose, IConsoleWriter console) { ParsedDefinitionList parsedDefinitionSet; try { parsedDefinitionSet = ParsedDefinitionList.Parse(cliDefinition, console); } catch (Exception exc) { console.WriteError($"ERROR: Could not parse the definition."); console.WriteError(exc.Message); return; } try { var generator = new CliGenerator(); generator.Generate(parsedDefinitionSet, new GeneratorSettings() { OverwriteFiles = overwriteFiles, Verbose = verbose, OutputPath = outputPath }, console); } catch (Exception exc) { console.WriteError($"ERROR: Could not generate command line classes."); console.WriteError(exc.Message); return; } }
public static CliDefinitionList Create() { var definition = new CliDefinitionList() { Description = "Sample command line definition", Namespace = "Sample.CommandLine", Lines = new List <string>() { "using System;" }, Definitions = new List <CliDefinition>() { new CliDefinition() { Definition = "[optional_verb] <value> [<optional_value>]", Namespace = "Sample.CommandLine.Verbs", ClassName = "OptionalVerbCommandLine", Items = new List <CliDefinitionItem>() { new CliDefinitionItem() { Verb = "optional_verb", HelpText = "Optional verb." }, new CliDefinitionItem() { ValueName = "value", HelpText = "Some value that must be present" }, new CliDefinitionItem() { ValueName = "optional_value", HelpText = "Some value that may be omitted. There can be at most one optional value and it must be the last value" } } }, new CliDefinition() { Definition = "verb1|verb2 <value> [<optional_value]", Namespace = "Sample.CommandLine.Verbs", ClassName = "Verb1_CommandLine|Verb2_CommandLine", Items = new List <CliDefinitionItem>() { new CliDefinitionItem() { Verb = "verb1", HelpText = "Do some action", }, new CliDefinitionItem() { Verb = "verb2", HelpText = "Do some other action", }, new CliDefinitionItem() { ValueName = "value", HelpText = "Simple string parameter", }, new CliDefinitionItem() { ValueName = "optional_value", HelpText = "Optional string parameter", } } }, new CliDefinition() { Definition = "--a_switch|-a --b_option|-b <parameter> [--c_optional_option|-c <parameter>]", ClassName = "CommandLine", Items = new List <CliDefinitionItem>() { new CliDefinitionItem() { Option = "a_switch|a", HelpText = "Command line switch. True if present." }, new CliDefinitionItem() { Option = "b_option|b", HelpText = "Mandatory named option", PropertyName = "OptionB" }, new CliDefinitionItem() { Option = "c_optional_option|c", HelpText = "Named option that could be missing." } } } } }; return(definition); }
public static CliDefinitionList Create() { var definition = new CliDefinitionList() { Namespace = "LoxSmoke.Cli.CommandLineOptions", Description = "Command line options classes.", Lines = new List <string>() { "using CommandLine;", "using System;", "using System.Collections.Generic;", "using System.Text;" }, Definitions = new List <CliDefinition>() { new CliDefinition() { ClassName = "SampleOptions", Definition = "sample [<file_name>] [--force|-f] [--name|-n <sample_name>]", Items = new List <CliDefinitionItem>() { new CliDefinitionItem() { Verb = "sample", HelpText = "Generate the sample command line definition file." }, new CliDefinitionItem() { ValueName = "file_name", HelpText = "Optional command line definition sample file name." }, new CliDefinitionItem() { Option = "force|f", HelpText = "Overwrite the sample definition file if file with the same name already exists", PropertyName = "OverwriteSampleFile" }, new CliDefinitionItem() { Option = "name|n", HelpText = "The name of the sample. Available names: default, cli" } } }, new CliDefinition() { ClassName = "InlineGenerateOptions", Definition = "inline <definition> [<output>] [--namespace|-n <namespace>] [--class|-c <class>] [--force|-f] [--verbose|-v]", Items = new List <CliDefinitionItem>() { new CliDefinitionItem() { Verb = "inline", HelpText = "Generate command line options class without using definition file." }, new CliDefinitionItem() { ValueName = "definition", HelpText = "Command line definition string." }, new CliDefinitionItem() { ValueName = "output", PropertyName = "OutputPath", HelpText = "Output path for generated file." }, new CliDefinitionItem() { Option = "namespace|n", HelpText = "The namespace of the command line options class." }, new CliDefinitionItem() { Option = "class|c", HelpText = "The name of the command line options class." }, new CliDefinitionItem() { Option = "force|f", HelpText = "Overwrite already existing class files.", PropertyName = "OverwriteFiles" }, new CliDefinitionItem() { Option = "verbose|v", HelpText = "Show detailed info when generating code." } } }, new CliDefinition() { ClassName = "GenerateOptions", Definition = "generate <file> [<output>] [--force|-f] [--verbose|-v]", Items = new List <CliDefinitionItem>() { new CliDefinitionItem() { Verb = "generate", HelpText = "Generate command line options classes from definition file" }, new CliDefinitionItem() { ValueName = "file", HelpText = "The input file containing command line definition." }, new CliDefinitionItem() { ValueName = "output", PropertyName = "OutputPath", HelpText = "Output path for generated file(s)." }, new CliDefinitionItem() { Option = "force|f", HelpText = "Overwrite already existing class files.", PropertyName = "OverwriteFiles" }, new CliDefinitionItem() { Option = "verbose|v", HelpText = "Show detailed info when generating code." } } } } }; return(definition); }
public static ParsedDefinitionList Parse(CliDefinitionList definitionSet, IConsoleWriter console) { var parsedDefinitionSet = new ParsedDefinitionList() { Description = definitionSet.Description, Namespace = definitionSet.Namespace ?? "CommandLine.Options", ClassName = definitionSet.ClassName ?? "CliProgram", Lines = definitionSet.Lines }; var index = 0; foreach (var definition in definitionSet.Definitions) { if (definition.Items == null) { definition.Items = new List <CliDefinitionItem>(); } index++; definition.Items.ForEach(item => item.Normalize()); var parsedDefinition = ParsedDefinition.Parse(definition); parsedDefinitionSet.Definitions.Add(parsedDefinition); foreach (var item in definition.Items) { var parsedItem = parsedDefinition.ParsedItems.FirstOrDefault(i => i.SameItem(item)); if (parsedItem == null) { Warning(console, definition, index, item.NameString, "Unused item description."); continue; } parsedItem.DefinitionItem = item; } foreach (var parsedItem in parsedDefinition.ParsedItems.Where(ci => ci.DefinitionItem == null)) { Warning(console, definition, index, parsedItem.ToString(), "Missing item description"); } foreach (var parsedItemGroup in parsedDefinition.ParsedItems.GroupBy(it => it.ToString()).Where(g => g.Count() > 1)) { Warning(console, definition, index, parsedItemGroup.First().ToString(), "Item in command line is defined more than once"); } foreach (var itemGroup in definition.Items.GroupBy(it => it.NameString).Where(g => g.Count() > 1)) { Warning(console, definition, index, itemGroup.First().NameString, "Item description defined more than once"); } } if (definitionSet.Definitions.Count > 1) { // Check if more than one command line with no verbs exists. if (definitionSet.Definitions.Any(it => !it.Items.Any(x => !string.IsNullOrEmpty(x.Verb)))) { throw new ParseError("There should be either only one definition or all definitions should contain verbs."); } // Check if different definitions use unique verbs var verbs = new HashSet <string>(); foreach (var definition in definitionSet.Definitions) { foreach (var def in definition.Items.Where(it => !string.IsNullOrEmpty(it.Verb))) { if (verbs.Contains(def.Verb)) { throw new ParseError($"Verb \'{def.Verb}\' exists in more than one definition. Same verbs cannot be used for different definitions."); } } } } return(parsedDefinitionSet); }