Esempio n. 1
0
        static CommandLineOptions.CommandLineOptions Parse(string [] args)
        {
            var result = CliProgram.Parse(args);

            if (result.Tag == CommandLine.ParserResultType.NotParsed)
            {
                return(null);
            }

            var options = ((CommandLine.Parsed <CommandLineOptions.CommandLineOptions>)result).Value;

            if (string.IsNullOrEmpty(options.Format))
            {
                options.Format = MarkdownWriters.First().FormatName;
            }
            if (options.IgnoreMethods)
            {
                options.DocumentMethodDetails = false;
            }
            if (options.AssemblyName != null && options.OutputFile == null)
            {
                options.OutputFile = Path.GetFileNameWithoutExtension(options.AssemblyName) + ".md";
            }
            return(options);
        }
Esempio n. 2
0
        static CommandLineOptions Parse(string [] args)
        {
            var options = new CommandLineOptions()
            {
                Format = MarkdownWriters.First().FormatName,
            };

            for (var i = 0; i < args.Length; i++)
            {
                switch (args[i])
                {
                case "--output":
                case "-o":
                    if (++i == args.Length)
                    {
                        Console.WriteLine("Error: Missing output file name");
                        return(null);
                    }
                    options.OutputFile = args[i];
                    break;

                case "--format":
                case "-f":
                    if (++i == args.Length)
                    {
                        Console.WriteLine("Error: Missing format");
                        return(null);
                    }
                    options.Format = args[i];
                    break;

                case "--ignore-methods":
                case "-m":
                    options.IgnoreMethods         = true;
                    options.DocumentMethodDetails = false;
                    break;

                case "--method-details":
                case "-d":
                    if (!options.IgnoreMethods)
                    {
                        options.DocumentMethodDetails = true;
                    }
                    break;

                case "--ignore-attribute":
                case "-a":
                    if (++i == args.Length)
                    {
                        Console.WriteLine("Error: Missing attribute name");
                        return(null);
                    }
                    options.IgnoreAttributes.Add(args[i]);
                    break;

                case "--recursive":
                case "-r":
                    options.Recursive = true;
                    if (i + 1 < args.Length &&
                        !args[i + 1].StartsWith('-'))
                    {
                        options.RecursiveAssemblies.Add(args[++i]);
                    }
                    break;

                case "--type":
                case "-t":
                    if (++i == args.Length)
                    {
                        Console.WriteLine("Error: Missing type name");
                        return(null);
                    }
                    options.TypeName = args[i];
                    break;

                case "--help":
                case "-h":
                    return(null);

                case "--msdn":
                case "-s":
                    options.MsdnLinks = true;
                    if (i + 1 < args.Length && !args[i + 1].StartsWith('-'))
                    {
                        options.MsdnLinkViewParameter = args[++i];
                    }
                    break;

                case "--no-title":
                case "-n":
                    options.ShowDocumentDateTime = false;
                    break;

                case "--title":
                case "-i":
                    if (i + 1 < args.Length && !args[i + 1].StartsWith('-'))
                    {
                        options.DocumentTitle = args[++i];
                    }
                    break;

                case "--verbose":
                case "-v":
                    options.Verbose = true;
                    break;

                default:
                    if (args[i].StartsWith("-"))
                    {
                        Console.WriteLine($"Error: Unknown parameter {args[i]}");
                        return(null);
                    }
                    if (options.AssemblyName == null)
                    {
                        options.AssemblyName = args[i];
                    }
                    break;
                }
            }

            if (options.AssemblyName != null && options.OutputFile == null)
            {
                options.OutputFile = Path.GetFileNameWithoutExtension(options.AssemblyName) + ".md";
            }

            return(options);
        }
Esempio n. 3
0
                bool Recursive, List <string> RecursiveAssemblies) Parse(string [] args)
        {
            string assemblyName = null, typeName = null, outputFile = null, format = MarkdownWriters.First().FormatName;
            var    ignoreMethods       = false;
            var    ignoreAttributes    = new List <string>();
            var    recursive           = false;
            var    recursiveAssemblies = new List <string>();
            var    errorReturn         = ((string)null, (string)null, (string)null, (string)null, false, (List <string>)null, false, (List <string>)null);

            for (var i = 0; i < args.Length; i++)
            {
                switch (args[i])
                {
                case "--output":
                case "-o":
                    if (++i == args.Length)
                    {
                        Console.WriteLine("Error: Missing output file name");
                        return(errorReturn);
                    }
                    outputFile = args[i];
                    break;

                case "--format":
                case "-f":
                    if (++i == args.Length)
                    {
                        Console.WriteLine("Error: Missing format");
                        return(errorReturn);
                    }
                    format = args[i];
                    break;

                case "--ignore-methods":
                case "-m":
                    ignoreMethods = true;
                    break;

                case "--ignore-attribute":
                case "-a":
                    if (++i == args.Length)
                    {
                        Console.WriteLine("Error: Missing attribute name");
                        return(errorReturn);
                    }
                    ignoreAttributes.Add(args[i]);
                    break;

                case "--recursive":
                case "-r":
                    recursive = true;
                    if (i + 1 < args.Length &&
                        !args[i + 1].StartsWith('-'))
                    {
                        recursiveAssemblies.Add(args[++i]);
                    }
                    break;

                case "--type":
                case "-t":
                    if (++i == args.Length)
                    {
                        Console.WriteLine("Error: Missing type name");
                        return(errorReturn);
                    }
                    typeName = args[i];
                    break;

                case "--help":
                case "-h":
                    return(errorReturn);

                default:
                    if (args[i].StartsWith("-"))
                    {
                        Console.WriteLine($"Error: Unknown parameter {args[i]}");
                        return(errorReturn);
                    }
                    if (assemblyName == null)
                    {
                        assemblyName = args[i];
                    }
                    break;
                }
            }

            if (assemblyName != null && outputFile == null)
            {
                outputFile = Path.GetFileNameWithoutExtension(assemblyName) + ".md";
            }

            return(assemblyName, typeName, outputFile, format, ignoreMethods, ignoreAttributes, recursive, recursiveAssemblies);
        }