diff --git a/src/GitVersionExe.Tests/ArgumentParserTests.cs b/src/GitVersionExe.Tests/ArgumentParserTests.cs index 0169bd2f59..d1b5c92ff6 100644 --- a/src/GitVersionExe.Tests/ArgumentParserTests.cs +++ b/src/GitVersionExe.Tests/ArgumentParserTests.cs @@ -7,6 +7,12 @@ [TestFixture] public class ArgumentParserTests { + [Test, Explicit] + public void PrintHelp() + { + HelpWriter.WriteTo(Console.WriteLine); + } + [Test] public void Empty_means_use_current_directory() { @@ -26,20 +32,30 @@ public void Single_means_use_as_target_directory() } [Test] - public void No_path_and_logfile_should_use_current_directory_TargetDirectory() + [TestCase("-l logFilePath")] + [TestCase("--log=logFilePath")] + [TestCase("-l=logFilePath")] + [TestCase("/l logFilePath")] + [TestCase("/log=logFilePath")] + public void No_path_and_logfile_should_use_current_directory_TargetDirectory(string args) { - var arguments = ArgumentParser.ParseArguments("-l logFilePath"); + var arguments = ArgumentParser.ParseArguments(args); arguments.TargetPath.ShouldBe(Environment.CurrentDirectory); arguments.LogFilePath.ShouldBe("logFilePath"); arguments.IsHelp.ShouldBe(false); } [Test] - public void h_means_IsHelp() + [TestCase("-h")] + [TestCase("--help")] + [TestCase("/h")] + [TestCase("/help")] + [TestCase("/?")] + public void h_means_IsHelp(string helpArg) { - var arguments = ArgumentParser.ParseArguments("-h"); - Assert.IsNull(arguments.TargetPath); - Assert.IsNull(arguments.LogFilePath); + var arguments = ArgumentParser.ParseArguments(helpArg); + arguments.TargetPath.ShouldBe(null); + arguments.LogFilePath.ShouldBe(null); arguments.IsHelp.ShouldBe(true); } @@ -51,13 +67,17 @@ public void exec() } [Test] - public void exec_with_args() + [TestCase("-execArgs")] + [TestCase("-execargs")] + [TestCase("-EXECARGS")] + [TestCase("-ExEcArGs")] + public void exec_with_args(string caseInsensitiveExecArgs) { var arguments = ArgumentParser.ParseArguments(new List { "-exec", "rake", - "-execargs", + caseInsensitiveExecArgs, "clean build" }); arguments.Exec.ShouldBe("rake"); @@ -171,8 +191,6 @@ public void Unknown_argument_should_throw() exception.Message.ShouldBe("Could not parse command line parameter '-x'."); } - [TestCase("-updateAssemblyInfo true")] - [TestCase("-updateAssemblyInfo 1")] [TestCase("-updateAssemblyInfo")] [TestCase("-updateAssemblyInfo -proj foo.sln")] public void update_assembly_info_true(string command) @@ -181,26 +199,28 @@ public void update_assembly_info_true(string command) arguments.UpdateAssemblyInfo.ShouldBe(true); } - [TestCase("-updateAssemblyInfo false")] - [TestCase("-updateAssemblyInfo 0")] + [TestCase("-proj foo.sln")] // absent updateAssemblyInfo flag implies false + [TestCase("")] public void update_assembly_info_false(string command) { var arguments = ArgumentParser.ParseArguments(command); arguments.UpdateAssemblyInfo.ShouldBe(false); } - [Test] - public void update_assembly_info_with_filename() + [TestCase("-updateAssemblyInfo=CommonAssemblyInfo.cs")] + [TestCase("-updateAssemblyInfo:CommonAssemblyInfo.cs")] + public void update_assembly_info_with_filename(string args) { - var arguments = ArgumentParser.ParseArguments("-updateAssemblyInfo CommonAssemblyInfo.cs"); + var arguments = ArgumentParser.ParseArguments(args); arguments.UpdateAssemblyInfo.ShouldBe(true); arguments.UpdateAssemblyInfoFileName.ShouldBe("CommonAssemblyInfo.cs"); } - [Test] - public void update_assembly_info_with_relative_filename() + [TestCase("-updateAssemblyInfo=..\\..\\CommonAssemblyInfo.cs")] + [TestCase("-updateAssemblyInfo:..\\..\\CommonAssemblyInfo.cs")] + public void update_assembly_info_with_relative_filename(string args) { - var arguments = ArgumentParser.ParseArguments("-updateAssemblyInfo ..\\..\\CommonAssemblyInfo.cs"); + var arguments = ArgumentParser.ParseArguments(args); arguments.UpdateAssemblyInfo.ShouldBe(true); arguments.UpdateAssemblyInfoFileName.ShouldBe("..\\..\\CommonAssemblyInfo.cs"); } @@ -220,25 +240,111 @@ public void can_log_to_console() } [Test] - public void nofetch_true_when_defined() + [TestCase("-nofetch")] + [TestCase("-nofetch+")] + public void nofetch_true_when_defined(string args) { - var arguments = ArgumentParser.ParseArguments("-nofetch"); - arguments.NoFetch = true; + var arguments = ArgumentParser.ParseArguments(args); + arguments.NoFetch.ShouldBe(true); + } + + [Test] + [TestCase("")] + [TestCase("-nofetch-")] + public void nofetch_false_when_minus_or_notdefined_(string args) + { + var arguments = ArgumentParser.ParseArguments(args); + arguments.NoFetch.ShouldBe(false); } [Test] public void other_arguments_can_be_parsed_before_nofetch() { var arguments = ArgumentParser.ParseArguments("targetpath -nofetch "); - arguments.TargetPath = "targetpath"; - arguments.NoFetch = true; + arguments.TargetPath.ShouldBe("targetpath"); + arguments.NoFetch.ShouldBe(true); } [Test] public void other_arguments_can_be_parsed_after_nofetch() { var arguments = ArgumentParser.ParseArguments("-nofetch -proj foo.sln"); - arguments.NoFetch = true; - arguments.Proj = "foo.sln"; + arguments.NoFetch.ShouldBe(true); + arguments.Proj.ShouldBe("foo.sln"); + } + + [TestCase("-targetPath c:\\expected\\path")] + [TestCase("c:\\expected\\path -targetPath c:\\foo\\bar")] + // [TestCase("init -targetPath c:\\expected\\path")] // should we init in target path or current directory? + public void can_specify_target_path(string command) + { + var arguments = ArgumentParser.ParseArguments(command); + arguments.TargetPath.ShouldBe("c:\\expected\\path"); + } + + [TestCase("-c ce123")] + public void can_specify_commitid(string command) + { + var arguments = ArgumentParser.ParseArguments(command); + arguments.CommitId.ShouldBe("ce123"); + } + + [TestCase("-v SemVer")] + [TestCase("--showvariable SemVer")] + [TestCase("-showvariable SemVer")] + [TestCase("/showvariable SemVer")] + [TestCase("/v SemVer")] + public void can_show_variable(string command) + { + var arguments = ArgumentParser.ParseArguments(command); + arguments.ShowVariable.ShouldBe("SemVer"); } + + [TestCase("-v thisVariableDoesNotExist")] + public void show_non_existing_variable_fails(string args) + { + var exception = Should.Throw(() => ArgumentParser.ParseArguments(args)); + exception.Message.ShouldStartWith("show variable switch requires a valid version variable"); + } + + [TestCase("targetDirectoryPath -assemblyversionformat")] + [TestCase("-assemblyversionformat")] + public void assemblyversionformat_should_throw_warning(string args) + { + var exception = Should.Throw(() => ArgumentParser.ParseArguments(args)); + exception.Message.ShouldBe("assemblyversionformat switch removed, use AssemblyVersioningScheme configuration value instead"); + } + + [TestCase("-updateassemblyinfoname")] + public void updateassemblyinfoname_should_throw_warning(string args) + { + var exception = Should.Throw(() => ArgumentParser.ParseArguments(args)); + exception.Message.ShouldBe("updateassemblyinfoname deprecated, use --updateassemblyinfo=[assemblyinfo.cs] instead"); + } + + [Test] + [TestCase("-showconfig")] + [TestCase("--showConfig+")] + public void showconfig_true_when_defined(string args) + { + var arguments = ArgumentParser.ParseArguments(args); + arguments.ShowConfig.ShouldBe(true); + } + + [Test] + [TestCase("")] + [TestCase("-showconfig-")] + public void showconfig_false_when_minus_or_notdefined(string args) + { + var arguments = ArgumentParser.ParseArguments(args); + arguments.ShowConfig.ShouldBe(false); + } + + [TestCase("init")] + public void can_use_init_as_postional_arg(string args) + { + var arguments = ArgumentParser.ParseArguments(args); + arguments.Init.ShouldBe(true); + } + } \ No newline at end of file diff --git a/src/GitVersionExe.Tests/HelpWriterTests.cs b/src/GitVersionExe.Tests/HelpWriterTests.cs index eb5a5ef6bc..1128d73a5f 100644 --- a/src/GitVersionExe.Tests/HelpWriterTests.cs +++ b/src/GitVersionExe.Tests/HelpWriterTests.cs @@ -6,7 +6,7 @@ public class HelpWriterTests { - [Test] + [Test, Ignore("Since all options are documented in the option specification, I prefer not to test documentation of options.")] public void AllArgsAreInHelp() { var lookup = new Dictionary diff --git a/src/GitVersionExe/ArgumentParser.cs b/src/GitVersionExe/ArgumentParser.cs index 620f543570..39a0e666c7 100644 --- a/src/GitVersionExe/ArgumentParser.cs +++ b/src/GitVersionExe/ArgumentParser.cs @@ -2,307 +2,194 @@ namespace GitVersion { using System; using System.Collections.Generic; - using System.Collections.Specialized; using System.Linq; using System.Text.RegularExpressions; + using NDesk.Options; public class ArgumentParser { - public static Arguments ParseArguments(string commandLineArguments) + public static OptionSet GetOptionSet(Arguments arguments) { - return ParseArguments(commandLineArguments.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList()); - } - - public static Arguments ParseArguments(List commandLineArguments) - { - if (commandLineArguments.Count == 0) - { - return new Arguments - { - TargetPath = Environment.CurrentDirectory - }; - } - - var firstArgument = commandLineArguments.First(); - if (IsHelp(firstArgument)) - { - return new Arguments - { - IsHelp = true - }; - } - if (IsInit(firstArgument)) - { - return new Arguments - { - TargetPath = Environment.CurrentDirectory, - Init = true - }; - } - - if (commandLineArguments.Count == 1 && !(commandLineArguments[0].StartsWith("-") || commandLineArguments[0].StartsWith("/"))) - { - return new Arguments - { - TargetPath = firstArgument - }; - } - - List namedArguments; - var arguments = new Arguments(); - if (firstArgument.StartsWith("-") || firstArgument.StartsWith("/")) - { - arguments.TargetPath = Environment.CurrentDirectory; - namedArguments = commandLineArguments; - } - else - { - arguments.TargetPath = firstArgument; - namedArguments = commandLineArguments.Skip(1).ToList(); - } - - var args = CollectSwitchesAndValuesFromArguments(namedArguments); - - foreach (var name in args.AllKeys) - { - var values = args.GetValues(name); - - string value = null; - - if (values != null) - { - //Currently, no arguments use more than one value, so having multiple values is an input error. - //In the future, this exception can be removed to support multiple values for a switch. - if (values.Length > 1) throw new WarningException(string.Format("Could not parse command line parameter '{0}'.", values[1])); - - value = values.FirstOrDefault(); - } - - if (IsSwitch("l", name)) - { - arguments.LogFilePath = value; - continue; - } - - if (IsSwitch("targetpath", name)) - { - arguments.TargetPath = value; - continue; - } - - if (IsSwitch("dynamicRepoLocation", name)) - { - arguments.DynamicRepositoryLocation = value; - continue; - } - - if (IsSwitch("url", name)) - { - arguments.TargetUrl = value; - continue; - } - - if (IsSwitch("b", name)) - { - arguments.TargetBranch = value; - continue; - } - - if (IsSwitch("u", name)) - { - arguments.Authentication.Username = value; - continue; - } - - if (IsSwitch("p", name)) - { - arguments.Authentication.Password = value; - continue; - } - - if (IsSwitch("c", name)) - { - arguments.CommitId = value; - continue; - } - - if (IsSwitch("exec", name)) - { - arguments.Exec = value; - continue; - } - - if (IsSwitch("execargs", name)) - { - arguments.ExecArgs = value; - continue; - } - - if (IsSwitch("proj", name)) - { - arguments.Proj = value; - continue; - } - - if (IsSwitch("projargs", name)) - { - arguments.ProjArgs = value; - continue; - } - - if (IsSwitch("updateAssemblyInfo", name)) - { - if (new[] { "1", "true" }.Contains(value, StringComparer.OrdinalIgnoreCase)) + return new CaseInsensitiveOptionSet + { { - arguments.UpdateAssemblyInfo = true; - } - else if (new[] { "0", "false" }.Contains(value, StringComparer.OrdinalIgnoreCase)) + "path|targetpath=", + "The path to inspect\nDefaults to the current directory.", + v => arguments.TargetPath = v + }, { - arguments.UpdateAssemblyInfo = false; - } - else if (!IsSwitchArgument(value)) + "i|init", "Start the configuration utility for gitversion", + v => { throw new WarningException("assemblyversionformat switch removed, use AssemblyVersioningScheme configuration value instead"); } + }, { - arguments.UpdateAssemblyInfo = true; - arguments.UpdateAssemblyInfoFileName = value; - } - else + "h|?|help", "Show this message and exit", + v => arguments.IsHelp = (v != null) + }, { - arguments.UpdateAssemblyInfo = true; - } - continue; - } - - if (IsSwitch("assemblyversionformat", name)) - { - throw new WarningException("assemblyversionformat switch removed, use AssemblyVersioningScheme configuration value instead"); - } - - if (IsSwitch("v", name) || IsSwitch("showvariable", name)) - { - string versionVariable = null; - - if (!string.IsNullOrWhiteSpace(value)) + "l|log=", "Path to logfile", + v => + { + arguments.LogFilePath = v; + arguments.TargetPath = Environment.CurrentDirectory; + } + }, { - versionVariable = VersionVariables.AvailableVariables.SingleOrDefault(av => av.Equals(value.Replace("'", ""), StringComparison.CurrentCultureIgnoreCase)); - } - - if (versionVariable == null) + "exec=", "Executes target executable making GitVersion variables available as environmental variables", + v => arguments.Exec = v + }, { - var messageFormat = "{0} requires a valid version variable. Available variables are:\n{1}"; - var message = string.Format(messageFormat, name, String.Join(", ", VersionVariables.AvailableVariables.Select(x=>string.Concat("'", x, "'")))); - throw new WarningException(message); - } - - arguments.ShowVariable = versionVariable; - continue; - } - - if (IsSwitch("showConfig", name)) - { - if (new[] { "1", "true" }.Contains(value, StringComparer.OrdinalIgnoreCase)) + "execargs=", "Arguments for the executable specified by --exec", + v => arguments.ExecArgs = v + }, { - arguments.ShowConfig = true; - } - else if (new[] { "0", "false" }.Contains(value, StringComparer.OrdinalIgnoreCase)) + "proj=", "Build an msbuild file making GitVersion variables available as msbuild properties", + v => arguments.Proj = v + }, { - arguments.UpdateAssemblyInfo = false; - } - else + "projargs=", "Additional arguments to pass to msbuild", + v => arguments.ProjArgs = v + }, { - arguments.ShowConfig = true; - } - continue; - } + "u|username=", "Username in case authentication is required", + v => arguments.Authentication.Username = v + }, + { + "p|password=", "Password in case authentication is required", + v => arguments.Authentication.Password = v + }, + { + "o|output=", "Determines the output to the console\nCan be either 'json' or 'buildserver', will default to 'json'.", + v => arguments.SetOutPutType(v) + }, + { + "url=", "Url to remote git repository", + v => arguments.TargetUrl = v + }, + { + "b|remotebranch=", "Name of the branch to use on the remote repository, must be used in combination with --url", + v => arguments.TargetBranch = v + }, + { + "updateassemblyinfo:", "* Will recursively search for all 'AssemblyInfo.cs' files in the git repo and update them\n" + + "To use another filename use --updateassemblyinfo:[another-assemblyinfo-filename.cs]", + v => + { + if (v == null) + { + arguments.UpdateAssemblyInfo = true; + } + else + { + arguments.UpdateAssemblyInfo = true; + arguments.UpdateAssemblyInfoFileName = v; + } + } + }, + { + "updateassemblyinfoname", "* Deprecated: use --updateassemblyinfo:[assemblyinfofilename.cs] instead.", + v => { throw new WarningException("updateassemblyinfoname deprecated, use --updateassemblyinfo=[assemblyinfo.cs] instead"); } + }, + { + "dynamicrepolocation=", "Override locations dynamic repositories are clonden to\nDefaults to %tmp%.", + v => arguments.DynamicRepositoryLocation = v + }, + { + "c|commit=", "The commit id to inspect\nDefaults to the latest available commit on the specified branch.", + v => arguments.CommitId = v + }, + { + "v|showvariable=", "Used in conjuntion with /output json, will output just a particular variable", + v => arguments.SetShowVariable(v) + }, + { + "nofetch", "", + v => arguments.NoFetch = (v != null) + }, + { + "showconfig", "Outputs the effective GitVersion config\nOutputs the defaults and custom from GitVersion.yaml in yaml format.", + v => arguments.ShowConfig = (v != null) + }, + { + "assemblyversionformat", "Deprecated: use AssemblyVersioningScheme configuration value instead.", + v => { throw new WarningException("assemblyversionformat switch removed, use AssemblyVersioningScheme configuration value instead"); } + }, + }; + } + + public static Arguments ParseArguments(string commandLineArguments) + { + return ParseArguments(commandLineArguments.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList()); + } - if (IsSwitch("output", name)) - { - OutputType outputType; - if (!Enum.TryParse(value, true, out outputType)) + public static Arguments ParseArguments(List commandLineArguments) + { + if (commandLineArguments.Count <= 0) + { + return new Arguments() { - throw new WarningException(string.Format("Value '{0}' cannot be parsed as output type, please use 'json' or 'buildserver'", value)); - } + TargetPath = Environment.CurrentDirectory + }; + } - arguments.Output = outputType; - continue; - } + var arguments = new Arguments(); - if (IsSwitch("nofetch", name)) - { - arguments.NoFetch = true; - continue; - } + var p = GetOptionSet(arguments); + var additionalArguments = p.Parse(commandLineArguments); - throw new WarningException(string.Format("Could not parse command line parameter '{0}'.", name)); - } + ParseSpecialArguments(additionalArguments, arguments); return arguments; } - static NameValueCollection CollectSwitchesAndValuesFromArguments(List namedArguments) + static void ParseSpecialArguments(List additionalArguments, Arguments arguments) { - var args = new NameValueCollection(); + // if the first argument is "init" or filename, they get special treatment + // it is probably best to deprecate these and replace: + // "init" -> -i --init flag + // "path" -> --path --targetpath option (already exists, add aliases) + // but for now, these special cases are kept as-is for backwards compatibility - string currentKey = null; - for (var index = 0; index < namedArguments.Count; index = index + 1) + if (additionalArguments.Count <= 0) { - var arg = namedArguments[index]; - //If this is a switch, create new name/value entry for it, with a null value. - if (IsSwitchArgument(arg)) - { - currentKey = arg; - args.Add(currentKey, null); - } - //If this is a value (not a switch) - else - { - //And if the current switch does not have a value yet, set it's value to this argument. - if (String.IsNullOrEmpty(args[currentKey])) - { - args[currentKey] = arg; - } - //Otherwise add the value under the same switch. - else - { - args.Add(currentKey, arg); - } - } + return; } - return args; - } - static bool IsSwitchArgument(string value) - { - return value != null && (value.StartsWith("-") || value.StartsWith("/")) - && !Regex.Match(value, @"/\w+:").Success; //Exclude msbuild & project parameters in form /blah:, which should be parsed as values, not switch names. - } + var firstArgument = additionalArguments[0]; - static bool IsSwitch(string switchName, string value) - { - if (value.StartsWith("-")) + if (IsInit(firstArgument)) { - value = value.Remove(0, 1); + arguments.TargetPath = Environment.CurrentDirectory; + arguments.Init = true; } - - if (value.StartsWith("/")) + else if (IsSwitchArgument(firstArgument)) { - value = value.Remove(0, 1); + throw new WarningException(string.Format("Could not parse command line parameter '{0}'.", firstArgument)); + } + else + { + // TODO: should not overwrite if --targetPath is specified + arguments.TargetPath = firstArgument; } - return (string.Equals(switchName, value, StringComparison.OrdinalIgnoreCase)); + if (additionalArguments.Count > 1) + { + // fail on first unknown argument: + throw new WarningException(string.Format("Could not parse command line parameter '{0}'.", additionalArguments[1])); + } } - static bool IsInit(string singleArgument) + + static bool IsSwitchArgument(string value) { - return singleArgument.Equals("init", StringComparison.OrdinalIgnoreCase); + return value != null && (value.StartsWith("-") || value.StartsWith("/")) + && !Regex.Match(value, @"/\w+:").Success; //Exclude msbuild & project parameters in form /blah:, which should be parsed as values, not switch names. } - static bool IsHelp(string singleArgument) + static bool IsInit(string singleArgument) { - return (singleArgument == "?") || - IsSwitch("h", singleArgument) || - IsSwitch("help", singleArgument) || - IsSwitch("?", singleArgument); + return singleArgument.Equals("init", StringComparison.InvariantCultureIgnoreCase); } + } } \ No newline at end of file diff --git a/src/GitVersionExe/Arguments.cs b/src/GitVersionExe/Arguments.cs index fa3cfb9717..cead7a2719 100644 --- a/src/GitVersionExe/Arguments.cs +++ b/src/GitVersionExe/Arguments.cs @@ -1,5 +1,8 @@ namespace GitVersion { + using System; + using System.Linq; + public class Arguments { public Arguments() @@ -23,8 +26,34 @@ public Arguments() public string LogFilePath; public string ShowVariable; + public void SetShowVariable(string value) + { + string versionVariable = null; + + if (!string.IsNullOrWhiteSpace(value)) + { + versionVariable = VersionVariables.AvailableVariables.SingleOrDefault(av => av.Equals(value.Replace("'", ""), StringComparison.CurrentCultureIgnoreCase)); + } + + if (versionVariable == null) + { + var messageFormat = "show variable switch requires a valid version variable. Available variables are:\n{0}"; + var message = string.Format(messageFormat, String.Join(", ", VersionVariables.AvailableVariables.Select(x => string.Concat("'", x, "'")))); + throw new WarningException(message); + } + ShowVariable = versionVariable; + } + public OutputType Output; - + + public void SetOutPutType(string value) + { + if (!Enum.TryParse(value, true, out Output)) + { + throw new WarningException(string.Format("Value '{0}' cannot be parsed as output type, please use 'json' or 'buildserver'", value)); + } + } + public string Proj; public string ProjArgs; public string Exec; @@ -35,5 +64,6 @@ public Arguments() public bool ShowConfig; public bool NoFetch { get; set; } + } } \ No newline at end of file diff --git a/src/GitVersionExe/CaseInsensitiveOptionSet.cs b/src/GitVersionExe/CaseInsensitiveOptionSet.cs new file mode 100644 index 0000000000..70d15ea9ac --- /dev/null +++ b/src/GitVersionExe/CaseInsensitiveOptionSet.cs @@ -0,0 +1,47 @@ +namespace GitVersion +{ + using System; + using NDesk.Options; + + /// + /// Backwards comaptible option set that: + /// * accepts case-insensitive option names + /// + /// + /// Inspired by: + /// http://www.ndesk.org/doc/ndesk-options/NDesk.Options/Option.html#M:NDesk.Options.Option.OnParseComplete(NDesk.Options.OptionContext) + /// + class CaseInsensitiveOptionSet : OptionSet + { + // sadly, I do not know how to override the collection initialize to make sure option are passed in lower case. + + protected override void InsertItem(int index, Option item) + { + if (item.Prototype.ToLower() != item.Prototype) + { + throw new ArgumentException("Option prototypes must be lower-case"); + } + base.InsertItem(index, item); + } + + protected override OptionContext CreateOptionContext() + { + return new OptionContext(this); + } + + protected override bool Parse(string option, OptionContext c) + { + string f, n, s, v; + var haveParts = GetOptionParts(option, out f, out n, out s, out v); + var newOption = option; + + if (haveParts) + { + newOption = f + n.ToLower() + (v != null ? s + v : ""); + } + + return base.Parse(newOption, c); + } + + } +} diff --git a/src/GitVersionExe/GitVersionExe.csproj b/src/GitVersionExe/GitVersionExe.csproj index b085191626..6f62944733 100644 --- a/src/GitVersionExe/GitVersionExe.csproj +++ b/src/GitVersionExe/GitVersionExe.csproj @@ -58,8 +58,10 @@ + + diff --git a/src/GitVersionExe/HelpWriter.cs b/src/GitVersionExe/HelpWriter.cs index 022051992d..84282604b2 100644 --- a/src/GitVersionExe/HelpWriter.cs +++ b/src/GitVersionExe/HelpWriter.cs @@ -1,6 +1,7 @@ namespace GitVersion { using System; + using System.IO; class HelpWriter { @@ -11,46 +12,13 @@ public static void Write() public static void WriteTo(Action writeAction) { - const string message = @"Use convention to derive a SemVer product version from a GitFlow or GitHub based repository. - -GitVersion [path] - - path The directory containing .git. If not defined current directory is used. (Must be first argument) - init Configuration utility for gitversion - /h or /? Shows Help - - /targetpath Same as 'path', but not positional - /output Determines the output to the console. Can be either 'json' or 'buildserver', will default to 'json'. - /showvariable Used in conjuntion with /output json, will output just a particular variable. - eg /output json /showvariable SemVer - will output `1.2.3+beta.4` - /l Path to logfile. - /showconfig Outputs the effective GitVersion config (defaults + custom from GitVersion.yaml) in yaml format - - # AssemblyInfo updating - /updateassemblyinfo - Will recursively search for all 'AssemblyInfo.cs' files in the git repo and update them - /updateassemblyinfofilename - Specify name of AssemblyInfo file. Can also /updateAssemblyInfo GlobalAssemblyInfo.cs as a shorthand - - # Remote repository args - /url Url to remote git repository. - /b Name of the branch to use on the remote repository, must be used in combination with /url. - /u Username in case authentication is required. - /p Password in case authentication is required. - /c The commit id to check. If not specified, the latest available commit on the specified branch will be used. - /dynamicRepoLocation - By default dynamic repositories will be cloned to %tmp%. Use this switch to override - - # Execute build args - /exec Executes target executable making GitVersion variables available as environmental variables - /execargs Arguments for the executable specified by /exec - /proj Build a msbuild file, GitVersion variables will be passed as msbuild properties - /projargs Additional arguments to pass to msbuild - - -gitversion init Configuration utility for gitversion -"; + const string messageHeader = "Use convention to derive a SemVer product version from a GitFlow or GitHub based repository.\n\n"; + var options = ArgumentParser.GetOptionSet(new Arguments()); + var sw = new StringWriter(); + options.WriteOptionDescriptions(sw); + var message = messageHeader + sw; + writeAction(message); } } diff --git a/src/GitVersionExe/Options.cs b/src/GitVersionExe/Options.cs new file mode 100644 index 0000000000..86b503b57c --- /dev/null +++ b/src/GitVersionExe/Options.cs @@ -0,0 +1,1399 @@ +// +// REMARKS: this file was obtained from http://www.ndesk.org/Options, v 0.2.1 +// +// It was ONLY modified using ReSharper to meet this project's coding standard. +// (And to add these first 5 lines) +// +// Options.cs +// +// Authors: +// Jonathan Pryor +// +// Copyright (C) 2008 Novell (http://www.novell.com) +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// + +// Compile With: +// gmcs -debug+ -r:System.Core Options.cs -o:NDesk.Options.dll +// gmcs -debug+ -d:LINQ -r:System.Core Options.cs -o:NDesk.Options.dll +// +// The LINQ version just changes the implementation of +// OptionSet.Parse(IEnumerable), and confers no semantic changes. + +// +// A Getopt::Long-inspired option parsing library for C#. +// +// NDesk.Options.OptionSet is built upon a key/value table, where the +// key is a option format string and the value is a delegate that is +// invoked when the format string is matched. +// +// Option format strings: +// Regex-like BNF Grammar: +// name: .+ +// type: [=:] +// sep: ( [^{}]+ | '{' .+ '}' )? +// aliases: ( name type sep ) ( '|' name type sep )* +// +// Each '|'-delimited name is an alias for the associated action. If the +// format string ends in a '=', it has a required value. If the format +// string ends in a ':', it has an optional value. If neither '=' or ':' +// is present, no value is supported. `=' or `:' need only be defined on one +// alias, but if they are provided on more than one they must be consistent. +// +// Each alias portion may also end with a "key/value separator", which is used +// to split option values if the option accepts > 1 value. If not specified, +// it defaults to '=' and ':'. If specified, it can be any character except +// '{' and '}' OR the *string* between '{' and '}'. If no separator should be +// used (i.e. the separate values should be distinct arguments), then "{}" +// should be used as the separator. +// +// Options are extracted either from the current option by looking for +// the option name followed by an '=' or ':', or is taken from the +// following option IFF: +// - The current option does not contain a '=' or a ':' +// - The current option requires a value (i.e. not a Option type of ':') +// +// The `name' used in the option format string does NOT include any leading +// option indicator, such as '-', '--', or '/'. All three of these are +// permitted/required on any named option. +// +// Option bundling is permitted so long as: +// - '-' is used to start the option group +// - all of the bundled options are a single character +// - at most one of the bundled options accepts a value, and the value +// provided starts from the next character to the end of the string. +// +// This allows specifying '-a -b -c' as '-abc', and specifying '-D name=value' +// as '-Dname=value'. +// +// Option processing is disabled by specifying "--". All options after "--" +// are returned by OptionSet.Parse() unchanged and unprocessed. +// +// Unprocessed options are returned from OptionSet.Parse(). +// +// Examples: +// int verbose = 0; +// OptionSet p = new OptionSet () +// .Add ("v", v => ++verbose) +// .Add ("name=|value=", v => Console.WriteLine (v)); +// p.Parse (new string[]{"-v", "--v", "/v", "-name=A", "/name", "B", "extra"}); +// +// The above would parse the argument string array, and would invoke the +// lambda expression three times, setting `verbose' to 3 when complete. +// It would also print out "A" and "B" to standard output. +// The returned array would contain the string "extra". +// +// C# 3.0 collection initializers are supported and encouraged: +// var p = new OptionSet () { +// { "h|?|help", v => ShowHelp () }, +// }; +// +// System.ComponentModel.TypeConverter is also supported, allowing the use of +// custom data types in the callback type; TypeConverter.ConvertFromString() +// is used to convert the value option to an instance of the specified +// type: +// +// var p = new OptionSet () { +// { "foo=", (Foo f) => Console.WriteLine (f.ToString ()) }, +// }; +// +// Random other tidbits: +// - Boolean options (those w/o '=' or ':' in the option format string) +// are explicitly enabled if they are followed with '+', and explicitly +// disabled if they are followed with '-': +// string a = null; +// var p = new OptionSet () { +// { "a", s => a = s }, +// }; +// p.Parse (new string[]{"-a"}); // sets v != null +// p.Parse (new string[]{"-a+"}); // sets v != null +// p.Parse (new string[]{"-a-"}); // sets v == null +// + + +#if LINQ +using System.Linq; +#endif + +#if TEST +using NDesk.Options; +#endif + +namespace NDesk.Options +{ + using System; + using System.Collections; + using System.Collections.Generic; + using System.Collections.ObjectModel; + using System.ComponentModel; + using System.IO; + using System.Runtime.Serialization; + using System.Security.Permissions; + using System.Text; + using System.Text.RegularExpressions; + + public class OptionValueCollection : IList, IList + { + List values = new List(); + OptionContext c; + + internal OptionValueCollection(OptionContext c) + { + this.c = c; + } + + #region ICollection + + void ICollection.CopyTo(Array array, int index) + { + (values as ICollection).CopyTo(array, index); + } + + bool ICollection.IsSynchronized + { + get { return (values as ICollection).IsSynchronized; } + } + + object ICollection.SyncRoot + { + get { return (values as ICollection).SyncRoot; } + } + + #endregion + + #region ICollection + + public void Add(string item) + { + values.Add(item); + } + + public void Clear() + { + values.Clear(); + } + + public bool Contains(string item) + { + return values.Contains(item); + } + + public void CopyTo(string[] array, int arrayIndex) + { + values.CopyTo(array, arrayIndex); + } + + public bool Remove(string item) + { + return values.Remove(item); + } + + public int Count + { + get { return values.Count; } + } + + public bool IsReadOnly + { + get { return false; } + } + + #endregion + + #region IEnumerable + + IEnumerator IEnumerable.GetEnumerator() + { + return values.GetEnumerator(); + } + + #endregion + + #region IEnumerable + + public IEnumerator GetEnumerator() + { + return values.GetEnumerator(); + } + + #endregion + + #region IList + + int IList.Add(object value) + { + return (values as IList).Add(value); + } + + bool IList.Contains(object value) + { + return (values as IList).Contains(value); + } + + int IList.IndexOf(object value) + { + return (values as IList).IndexOf(value); + } + + void IList.Insert(int index, object value) + { + (values as IList).Insert(index, value); + } + + void IList.Remove(object value) + { + (values as IList).Remove(value); + } + + void IList.RemoveAt(int index) + { + (values as IList).RemoveAt(index); + } + + bool IList.IsFixedSize + { + get { return false; } + } + + object IList.this[int index] + { + get { return this[index]; } + set { (values as IList)[index] = value; } + } + + #endregion + + #region IList + + public int IndexOf(string item) + { + return values.IndexOf(item); + } + + public void Insert(int index, string item) + { + values.Insert(index, item); + } + + public void RemoveAt(int index) + { + values.RemoveAt(index); + } + + void AssertValid(int index) + { + if (c.Option == null) + { + throw new InvalidOperationException("OptionContext.Option is null."); + } + if (index >= c.Option.MaxValueCount) + { + throw new ArgumentOutOfRangeException("index"); + } + if (c.Option.OptionValueType == OptionValueType.Required && + index >= values.Count) + { + throw new OptionException(string.Format( + c.OptionSet.MessageLocalizer("Missing required value for option '{0}'."), c.OptionName), + c.OptionName); + } + } + + public string this[int index] + { + get + { + AssertValid(index); + return index >= values.Count ? null : values[index]; + } + set { values[index] = value; } + } + + #endregion + + public List ToList() + { + return new List(values); + } + + public string[] ToArray() + { + return values.ToArray(); + } + + public override string ToString() + { + return string.Join(", ", values.ToArray()); + } + } + + public class OptionContext + { + OptionSet set; + OptionValueCollection c; + + public OptionContext(OptionSet set) + { + this.set = set; + c = new OptionValueCollection(this); + } + + public Option Option { get; set; } + + public string OptionName { get; set; } + + public int OptionIndex { get; set; } + + public OptionSet OptionSet + { + get { return set; } + } + + public OptionValueCollection OptionValues + { + get { return c; } + } + } + + public enum OptionValueType + { + None, + Optional, + Required, + } + + public abstract class Option + { + string prototype, description; + string[] names; + OptionValueType type; + int count; + string[] separators; + + protected Option(string prototype, string description) + : this(prototype, description, 1) + { + } + + protected Option(string prototype, string description, int maxValueCount) + { + if (prototype == null) + { + throw new ArgumentNullException("prototype"); + } + if (prototype.Length == 0) + { + throw new ArgumentException("Cannot be the empty string.", "prototype"); + } + if (maxValueCount < 0) + { + throw new ArgumentOutOfRangeException("maxValueCount"); + } + + this.prototype = prototype; + names = prototype.Split('|'); + this.description = description; + count = maxValueCount; + type = ParsePrototype(); + + if (count == 0 && type != OptionValueType.None) + { + throw new ArgumentException( + "Cannot provide maxValueCount of 0 for OptionValueType.Required or " + + "OptionValueType.Optional.", + "maxValueCount"); + } + if (type == OptionValueType.None && maxValueCount > 1) + { + throw new ArgumentException( + string.Format("Cannot provide maxValueCount of {0} for OptionValueType.None.", maxValueCount), + "maxValueCount"); + } + if (Array.IndexOf(names, "<>") >= 0 && + ((names.Length == 1 && type != OptionValueType.None) || + (names.Length > 1 && MaxValueCount > 1))) + { + throw new ArgumentException( + "The default option handler '<>' cannot require values.", + "prototype"); + } + } + + public string Prototype + { + get { return prototype; } + } + + public string Description + { + get { return description; } + } + + public OptionValueType OptionValueType + { + get { return type; } + } + + public int MaxValueCount + { + get { return count; } + } + + public string[] GetNames() + { + return (string[]) names.Clone(); + } + + public string[] GetValueSeparators() + { + if (separators == null) + { + return new string[0]; + } + return (string[]) separators.Clone(); + } + + protected static T Parse(string value, OptionContext c) + { + var conv = TypeDescriptor.GetConverter(typeof(T)); + var t = default (T); + try + { + if (value != null) + { + t = (T) conv.ConvertFromString(value); + } + } + catch (Exception e) + { + throw new OptionException( + string.Format( + c.OptionSet.MessageLocalizer("Could not convert string `{0}' to type {1} for option `{2}'."), + value, typeof(T).Name, c.OptionName), + c.OptionName, e); + } + return t; + } + + internal string[] Names + { + get { return names; } + } + + internal string[] ValueSeparators + { + get { return separators; } + } + + static readonly char[] NameTerminator = new[] {'=', ':'}; + + OptionValueType ParsePrototype() + { + var type = '\0'; + var seps = new List(); + for (var i = 0; i < names.Length; ++i) + { + var name = names[i]; + if (name.Length == 0) + { + throw new ArgumentException("Empty option names are not supported.", "prototype"); + } + + var end = name.IndexOfAny(NameTerminator); + if (end == -1) + { + continue; + } + names[i] = name.Substring(0, end); + if (type == '\0' || type == name[end]) + { + type = name[end]; + } + else + { + throw new ArgumentException( + string.Format("Conflicting option types: '{0}' vs. '{1}'.", type, name[end]), + "prototype"); + } + AddSeparators(name, end, seps); + } + + if (type == '\0') + { + return OptionValueType.None; + } + + if (count <= 1 && seps.Count != 0) + { + throw new ArgumentException( + string.Format("Cannot provide key/value separators for Options taking {0} value(s).", count), + "prototype"); + } + if (count > 1) + { + if (seps.Count == 0) + { + separators = new[] {":", "="}; + } + else if (seps.Count == 1 && seps[0].Length == 0) + { + separators = null; + } + else + { + separators = seps.ToArray(); + } + } + + return type == '=' ? OptionValueType.Required : OptionValueType.Optional; + } + + static void AddSeparators(string name, int end, ICollection seps) + { + var start = -1; + for (var i = end + 1; i < name.Length; ++i) + { + switch (name[i]) + { + case '{': + if (start != -1) + { + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + } + start = i + 1; + break; + case '}': + if (start == -1) + { + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + } + seps.Add(name.Substring(start, i - start)); + start = -1; + break; + default: + if (start == -1) + { + seps.Add(name[i].ToString()); + } + break; + } + } + if (start != -1) + { + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + } + } + + public void Invoke(OptionContext c) + { + OnParseComplete(c); + c.OptionName = null; + c.Option = null; + c.OptionValues.Clear(); + } + + protected abstract void OnParseComplete(OptionContext c); + + public override string ToString() + { + return Prototype; + } + } + + [Serializable] + public class OptionException : Exception + { + string option; + + public OptionException() + { + } + + public OptionException(string message, string optionName) + : base(message) + { + option = optionName; + } + + public OptionException(string message, string optionName, Exception innerException) + : base(message, innerException) + { + option = optionName; + } + + protected OptionException(SerializationInfo info, StreamingContext context) + : base(info, context) + { + option = info.GetString("OptionName"); + } + + public string OptionName + { + get { return option; } + } + + [SecurityPermission(SecurityAction.LinkDemand, SerializationFormatter = true)] + public override void GetObjectData(SerializationInfo info, StreamingContext context) + { + base.GetObjectData(info, context); + info.AddValue("OptionName", option); + } + } + + public delegate void OptionAction(TKey key, TValue value); + + public class OptionSet : KeyedCollection + { + public OptionSet() + : this(delegate(string f) { return f; }) + { + } + + public OptionSet(Converter localizer) + { + this.localizer = localizer; + } + + Converter localizer; + + public Converter MessageLocalizer + { + get { return localizer; } + } + + protected override string GetKeyForItem(Option item) + { + if (item == null) + { + throw new ArgumentNullException("option"); + } + if (item.Names != null && item.Names.Length > 0) + { + return item.Names[0]; + } + // This should never happen, as it's invalid for Option to be + // constructed w/o any names. + throw new InvalidOperationException("Option has no names!"); + } + + [Obsolete("Use KeyedCollection.this[string]")] + protected Option GetOptionForName(string option) + { + if (option == null) + { + throw new ArgumentNullException("option"); + } + try + { + return base[option]; + } + catch (KeyNotFoundException) + { + return null; + } + } + + protected override void InsertItem(int index, Option item) + { + base.InsertItem(index, item); + AddImpl(item); + } + + protected override void RemoveItem(int index) + { + base.RemoveItem(index); + var p = Items[index]; + // KeyedCollection.RemoveItem() handles the 0th item + for (var i = 1; i < p.Names.Length; ++i) + { + Dictionary.Remove(p.Names[i]); + } + } + + protected override void SetItem(int index, Option item) + { + base.SetItem(index, item); + RemoveItem(index); + AddImpl(item); + } + + void AddImpl(Option option) + { + if (option == null) + { + throw new ArgumentNullException("option"); + } + var added = new List(option.Names.Length); + try + { + // KeyedCollection.InsertItem/SetItem handle the 0th name. + for (var i = 1; i < option.Names.Length; ++i) + { + Dictionary.Add(option.Names[i], option); + added.Add(option.Names[i]); + } + } + catch (Exception) + { + foreach (var name in added) + { + Dictionary.Remove(name); + } + throw; + } + } + + public new OptionSet Add(Option option) + { + base.Add(option); + return this; + } + + sealed class ActionOption : Option + { + Action action; + + public ActionOption(string prototype, string description, int count, Action action) + : base(prototype, description, count) + { + if (action == null) + { + throw new ArgumentNullException("action"); + } + this.action = action; + } + + protected override void OnParseComplete(OptionContext c) + { + action(c.OptionValues); + } + } + + public OptionSet Add(string prototype, Action action) + { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, Action action) + { + if (action == null) + { + throw new ArgumentNullException("action"); + } + Option p = new ActionOption(prototype, description, 1, + delegate(OptionValueCollection v) { action(v[0]); }); + base.Add(p); + return this; + } + + public OptionSet Add(string prototype, OptionAction action) + { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, OptionAction action) + { + if (action == null) + { + throw new ArgumentNullException("action"); + } + Option p = new ActionOption(prototype, description, 2, + delegate(OptionValueCollection v) { action(v[0], v[1]); }); + base.Add(p); + return this; + } + + sealed class ActionOption : Option + { + Action action; + + public ActionOption(string prototype, string description, Action action) + : base(prototype, description, 1) + { + if (action == null) + { + throw new ArgumentNullException("action"); + } + this.action = action; + } + + protected override void OnParseComplete(OptionContext c) + { + action(Parse(c.OptionValues[0], c)); + } + } + + sealed class ActionOption : Option + { + OptionAction action; + + public ActionOption(string prototype, string description, OptionAction action) + : base(prototype, description, 2) + { + if (action == null) + { + throw new ArgumentNullException("action"); + } + this.action = action; + } + + protected override void OnParseComplete(OptionContext c) + { + action( + Parse(c.OptionValues[0], c), + Parse(c.OptionValues[1], c)); + } + } + + public OptionSet Add(string prototype, Action action) + { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, Action action) + { + return Add(new ActionOption(prototype, description, action)); + } + + public OptionSet Add(string prototype, OptionAction action) + { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, OptionAction action) + { + return Add(new ActionOption(prototype, description, action)); + } + + protected virtual OptionContext CreateOptionContext() + { + return new OptionContext(this); + } + +#if LINQ + public List Parse (IEnumerable arguments) + { + bool process = true; + OptionContext c = CreateOptionContext (); + c.OptionIndex = -1; + var def = GetOptionForName ("<>"); + var unprocessed = + from argument in arguments + where ++c.OptionIndex >= 0 && (process || def != null) + ? process + ? argument == "--" + ? (process = false) + : !Parse (argument, c) + ? def != null + ? Unprocessed (null, def, c, argument) + : true + : false + : def != null + ? Unprocessed (null, def, c, argument) + : true + : true + select argument; + List r = unprocessed.ToList (); + if (c.Option != null) + c.Option.Invoke (c); + return r; + } +#else + public List Parse(IEnumerable arguments) + { + var c = CreateOptionContext(); + c.OptionIndex = -1; + var process = true; + var unprocessed = new List(); + var def = Contains("<>") ? this["<>"] : null; + foreach (var argument in arguments) + { + ++c.OptionIndex; + if (argument == "--") + { + process = false; + continue; + } + if (!process) + { + Unprocessed(unprocessed, def, c, argument); + continue; + } + if (!Parse(argument, c)) + { + Unprocessed(unprocessed, def, c, argument); + } + } + if (c.Option != null) + { + c.Option.Invoke(c); + } + return unprocessed; + } +#endif + + static bool Unprocessed(ICollection extra, Option def, OptionContext c, string argument) + { + if (def == null) + { + extra.Add(argument); + return false; + } + c.OptionValues.Add(argument); + c.Option = def; + c.Option.Invoke(c); + return false; + } + + readonly Regex ValueOption = new Regex( + @"^(?--|-|/)(?[^:=]+)((?[:=])(?.*))?$"); + + protected bool GetOptionParts(string argument, out string flag, out string name, out string sep, out string value) + { + if (argument == null) + { + throw new ArgumentNullException("argument"); + } + + flag = name = sep = value = null; + var m = ValueOption.Match(argument); + if (!m.Success) + { + return false; + } + flag = m.Groups["flag"].Value; + name = m.Groups["name"].Value; + if (m.Groups["sep"].Success && m.Groups["value"].Success) + { + sep = m.Groups["sep"].Value; + value = m.Groups["value"].Value; + } + return true; + } + + protected virtual bool Parse(string argument, OptionContext c) + { + if (c.Option != null) + { + ParseValue(argument, c); + return true; + } + + string f, n, s, v; + if (!GetOptionParts(argument, out f, out n, out s, out v)) + { + return false; + } + + if (Contains(n)) + { + var p = this[n]; + c.OptionName = f + n; + c.Option = p; + switch (p.OptionValueType) + { + case OptionValueType.None: + c.OptionValues.Add(n); + c.Option.Invoke(c); + break; + case OptionValueType.Optional: + case OptionValueType.Required: + ParseValue(v, c); + break; + } + return true; + } + // no match; is it a bool option? + if (ParseBool(argument, n, c)) + { + return true; + } + // is it a bundled option? + if (ParseBundledValue(f, string.Concat(n + s + v), c)) + { + return true; + } + + return false; + } + + void ParseValue(string option, OptionContext c) + { + if (option != null) + { + foreach (var o in c.Option.ValueSeparators != null + ? option.Split(c.Option.ValueSeparators, StringSplitOptions.None) + : new[] {option}) + { + c.OptionValues.Add(o); + } + } + if (c.OptionValues.Count == c.Option.MaxValueCount || + c.Option.OptionValueType == OptionValueType.Optional) + { + c.Option.Invoke(c); + } + else if (c.OptionValues.Count > c.Option.MaxValueCount) + { + throw new OptionException(localizer(string.Format( + "Error: Found {0} option values when expecting {1}.", + c.OptionValues.Count, c.Option.MaxValueCount)), + c.OptionName); + } + } + + bool ParseBool(string option, string n, OptionContext c) + { + string rn; + if (n.Length >= 1 && (n[n.Length - 1] == '+' || n[n.Length - 1] == '-') && + Contains((rn = n.Substring(0, n.Length - 1)))) + { + var p = this[rn]; + var v = n[n.Length - 1] == '+' ? option : null; + c.OptionName = option; + c.Option = p; + c.OptionValues.Add(v); + p.Invoke(c); + return true; + } + return false; + } + + bool ParseBundledValue(string f, string n, OptionContext c) + { + if (f != "-") + { + return false; + } + for (var i = 0; i < n.Length; ++i) + { + Option p; + var opt = f + n[i].ToString(); + var rn = n[i].ToString(); + if (!Contains(rn)) + { + if (i == 0) + { + return false; + } + throw new OptionException(string.Format(localizer( + "Cannot bundle unregistered option '{0}'."), opt), opt); + } + p = this[rn]; + switch (p.OptionValueType) + { + case OptionValueType.None: + Invoke(c, opt, n, p); + break; + case OptionValueType.Optional: + case OptionValueType.Required: + { + var v = n.Substring(i + 1); + c.Option = p; + c.OptionName = opt; + ParseValue(v.Length != 0 ? v : null, c); + return true; + } + default: + throw new InvalidOperationException("Unknown OptionValueType: " + p.OptionValueType); + } + } + return true; + } + + static void Invoke(OptionContext c, string name, string value, Option option) + { + c.OptionName = name; + c.Option = option; + c.OptionValues.Add(value); + option.Invoke(c); + } + + const int OptionWidth = 29; + + public void WriteOptionDescriptions(TextWriter o) + { + foreach (var p in this) + { + var written = 0; + if (!WriteOptionPrototype(o, p, ref written)) + { + continue; + } + + if (written < OptionWidth) + { + o.Write(new string(' ', OptionWidth - written)); + } + else + { + o.WriteLine(); + o.Write(new string(' ', OptionWidth)); + } + + var lines = GetLines(localizer(GetDescription(p.Description))); + o.WriteLine(lines[0]); + var prefix = new string(' ', OptionWidth + 2); + for (var i = 1; i < lines.Count; ++i) + { + o.Write(prefix); + o.WriteLine(lines[i]); + } + } + } + + bool WriteOptionPrototype(TextWriter o, Option p, ref int written) + { + var names = p.Names; + + var i = GetNextOptionIndex(names, 0); + if (i == names.Length) + { + return false; + } + + if (names[i].Length == 1) + { + Write(o, ref written, " -"); + Write(o, ref written, names[0]); + } + else + { + Write(o, ref written, " --"); + Write(o, ref written, names[0]); + } + + for (i = GetNextOptionIndex(names, i + 1); + i < names.Length; i = GetNextOptionIndex(names, i + 1)) + { + Write(o, ref written, ", "); + Write(o, ref written, names[i].Length == 1 ? "-" : "--"); + Write(o, ref written, names[i]); + } + + if (p.OptionValueType == OptionValueType.Optional || + p.OptionValueType == OptionValueType.Required) + { + if (p.OptionValueType == OptionValueType.Optional) + { + Write(o, ref written, localizer("[")); + } + Write(o, ref written, localizer("=" + GetArgumentName(0, p.MaxValueCount, p.Description))); + var sep = p.ValueSeparators != null && p.ValueSeparators.Length > 0 + ? p.ValueSeparators[0] + : " "; + for (var c = 1; c < p.MaxValueCount; ++c) + { + Write(o, ref written, localizer(sep + GetArgumentName(c, p.MaxValueCount, p.Description))); + } + if (p.OptionValueType == OptionValueType.Optional) + { + Write(o, ref written, localizer("]")); + } + } + return true; + } + + static int GetNextOptionIndex(string[] names, int i) + { + while (i < names.Length && names[i] == "<>") + { + ++i; + } + return i; + } + + static void Write(TextWriter o, ref int n, string s) + { + n += s.Length; + o.Write(s); + } + + static string GetArgumentName(int index, int maxIndex, string description) + { + if (description == null) + { + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + } + string[] nameStart; + if (maxIndex == 1) + { + nameStart = new[] {"{0:", "{"}; + } + else + { + nameStart = new[] {"{" + index + ":"}; + } + for (var i = 0; i < nameStart.Length; ++i) + { + int start, j = 0; + do + { + start = description.IndexOf(nameStart[i], j); + } while (start >= 0 && j != 0 ? description[j++ - 1] == '{' : false); + if (start == -1) + { + continue; + } + var end = description.IndexOf("}", start); + if (end == -1) + { + continue; + } + return description.Substring(start + nameStart[i].Length, end - start - nameStart[i].Length); + } + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + } + + static string GetDescription(string description) + { + if (description == null) + { + return string.Empty; + } + var sb = new StringBuilder(description.Length); + var start = -1; + for (var i = 0; i < description.Length; ++i) + { + switch (description[i]) + { + case '{': + if (i == start) + { + sb.Append('{'); + start = -1; + } + else if (start < 0) + { + start = i + 1; + } + break; + case '}': + if (start < 0) + { + if ((i + 1) == description.Length || description[i + 1] != '}') + { + throw new InvalidOperationException("Invalid option description: " + description); + } + ++i; + sb.Append("}"); + } + else + { + sb.Append(description.Substring(start, i - start)); + start = -1; + } + break; + case ':': + if (start < 0) + { + goto default; + } + start = i + 1; + break; + default: + if (start < 0) + { + sb.Append(description[i]); + } + break; + } + } + return sb.ToString(); + } + + static List GetLines(string description) + { + var lines = new List(); + if (string.IsNullOrEmpty(description)) + { + lines.Add(string.Empty); + return lines; + } + var length = 80 - OptionWidth - 2; + int start = 0, end; + do + { + end = GetLineEnd(start, length, description); + var cont = false; + if (end < description.Length) + { + var c = description[end]; + if (c == '-' || (char.IsWhiteSpace(c) && c != '\n')) + { + ++end; + } + else if (c != '\n') + { + cont = true; + --end; + } + } + lines.Add(description.Substring(start, end - start)); + if (cont) + { + lines[lines.Count - 1] += "-"; + } + start = end; + if (start < description.Length && description[start] == '\n') + { + ++start; + } + } while (end < description.Length); + return lines; + } + + static int GetLineEnd(int start, int length, string description) + { + var end = Math.Min(start + length, description.Length); + var sep = -1; + for (var i = start; i < end; ++i) + { + switch (description[i]) + { + case ' ': + case '\t': + case '\v': + case '-': + case ',': + case '.': + case ';': + sep = i; + break; + case '\n': + return i; + } + } + if (sep == -1 || end == description.Length) + { + return end; + } + return sep; + } + } +} +