Exemple #1
0
        private static string AddArgument(ValidOption option)
        {
            switch (option.OptionType)
            {
            case OptionType.Optional:
                return(string.Format(" [{0}]", option.ArgumentName));

            case OptionType.Required:
                return(string.Format(" {0}", option.ArgumentName));

            default:
                return(string.Empty);
            }
        }
        public IEnumerable <ValidOption> Parse(string shortcut)
        {
            var validOptions = new List <ValidOption>();

            if (string.IsNullOrWhiteSpace(shortcut))
            {
                return(validOptions);
            }
            ValidOption validOption = null;

            foreach (char flag in shortcut)
            {
                if (flag != ':')
                {
                    if (validOption != null)
                    {
                        validOptions.Add(validOption);
                    }
                    if (validOptions.Count(v => v.Flag == flag) != 0)
                    {
                        throw new InvalidDefinitionException(string.Format("{0} is used more than once in the shortcut list '{1}'",
                                                                           flag, shortcut));
                    }
                    validOption = new ValidOption {
                        Flag = flag
                    };
                    continue;
                }
                if (validOption != null)
                {
                    validOption.OptionType++;
                }
            }
            if (validOption == null)
            {
                return(validOptions);
            }
            if (validOptions.Contains(validOption))
            {
                return(validOptions);
            }
            validOptions.Add(validOption);
            return(validOptions);
        }
        public void Parse(IEnumerable <string> argv)
        {
            Options   = new List <Option>();
            Arguments = new List <string>();
            bool needOptArg   = false;
            bool stopScanning = false;

            foreach (string argument in argv)
            {
                if (stopScanning)
                {
                    Arguments.Add(argument);
                    continue;
                }
                if (!argument.StartsWith("-"))
                {
                    if (!needOptArg)
                    {
                        Arguments.Add(argument);
                        continue;
                    }
                    Options[Options.Count - 1].Argument = argument;
                    needOptArg = false;
                    continue;
                }
                if (argument == "--")
                {
                    stopScanning = true;
                    continue;
                }
                if (argument.StartsWith("--"))
                {
                    string[]    parts       = argument.Split('=', ':');
                    string      longOpt     = parts[0].Substring(2);
                    ValidOption validOption = GetLongOption(longOpt);
                    Options.Add(new Option {
                        Flag = validOption.Flag
                    });
                    if (validOption.OptionType != OptionType.None)
                    {
                        if (parts.Length > 1)
                        {
                            Options[Options.Count - 1].Argument = parts[1];
                        }
                        else
                        {
                            needOptArg = true;
                        }
                    }
                    continue;
                }
                foreach (char flag in argument.Where(c => c != '-'))
                {
                    if (ValidOptions.Count(v => v.Flag == flag) == 0)
                    {
                        throw new InvalidOptionException(string.Format("{0} is not a valid option.", flag));
                    }
                    Options.Add(new Option {
                        Flag = flag
                    });
                }
                needOptArg = ValidOptions.Last(m => m.Flag == Options[Options.Count - 1].Flag).OptionType !=
                             OptionType.None;
            }
        }