Exemplo n.º 1
0
        public LaunchOptions Parse(string[] args)
        {
            var dotNetArgumentParser = new DotNetArgumentParser();

            DotNetCommandLineOptions dotNetOptions = dotNetArgumentParser.Parse(args);

            var nspecArgumentParser = new NSpecArgumentParser();

            NSpecCommandLineOptions nspecOptions = nspecArgumentParser.Parse(dotNetOptions.NSpecArgs);

            var allUnknownArgs = dotNetOptions.UnknownArgs
                                 .Concat(nspecOptions.UnknownArgs);

            var options = new LaunchOptions(dotNetOptions, nspecOptions, allUnknownArgs);

            return(options);
        }
Exemplo n.º 2
0
        public NSpecCommandLineOptions Parse(IEnumerable <string> args)
        {
            IEnumerable <string> remainingArgs;

            // set default option values

            var options = new NSpecCommandLineOptions()
            {
                FormatterOptions = new Dictionary <string, string>(),
                DebugTests       = new string[0],
            };

            // check for first argument (the class name), before remaining named options

            string firstArg = args.FirstOrDefault();

            if (IsUnknownArgument(firstArg))
            {
                options.ClassName = firstArg;

                remainingArgs = args.Skip(1);
            }
            else
            {
                remainingArgs = args;
            }

            // check for remaining named options

            remainingArgs = ParsingUtils.SetTextForOptionalArg(remainingArgs,
                                                               tagsKey, allKnownTokens, value => options.Tags = value);

            remainingArgs = ParsingUtils.SetBoolForSwitchArg(remainingArgs,
                                                             failFastKey, value => options.FailFast = value);

            remainingArgs = ParsingUtils.SetTextForOptionalArgPrefix(remainingArgs,
                                                                     formatterPrefix, value => options.FormatterName = value);

            remainingArgs = ParsingUtils.SetBoolForSwitchArg(remainingArgs,
                                                             debugChannelKey, value => options.DebugChannel = value);

            remainingArgs = ParsingUtils.SetTextForOptionalArg(remainingArgs,
                                                               debugTestsKey, allKnownTokens, value =>
            {
                options.DebugTests = value.Split(',')
                                     .Select(token => token.Trim())
                                     .ToArray();
            });

            int lastCount;

            do
            {
                lastCount = remainingArgs.Count();

                remainingArgs = ParsingUtils.SetTextForOptionalArgPrefix(remainingArgs,
                                                                         formatterOptionsPrefix, text =>
                {
                    string[] tokens = text.Split('=');

                    if (tokens.Length > 2)
                    {
                        throw new ArgumentException(
                            $"Formatter option '{text}' must be either a single 'flag' or a 'name=value' pair");
                    }

                    string name  = tokens.First();
                    string value = tokens.Last();

                    options.FormatterOptions[name] = value;
                });
            } while (lastCount != remainingArgs.Count());

            options.UnknownArgs = remainingArgs.ToArray();

            return(options);
        }
Exemplo n.º 3
0
 public NSpecCommandLineOptions(NSpecCommandLineOptions source)
     : base(source)
 {
     UnknownArgs = source.UnknownArgs;
 }