commandlineparser verb template using git example

CSharp · Console

/Program.cs

// @nuget: CommandLineParser -Version 2.6.0
using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using CommandLine;

public class Program
{
	public static void Main()
	{
		int runcount=1;
		foreach(var args in new List<string[]> { 
			//experiment with different command line values here
			new string[] { "--help" }
			,new string[] { "clone", "--help" }
			,new string[] { "clone", "git://github.com/commandlineparser/commandline.git" }
			,new string[] { "add","--help" }
			,new string[] { "add", "addfile.cs" }
			,new string[] { "commit", "-m", "initial commit" }
			,new string[] { "push", "-f" }
			,new string[] { "push", "--force" }
			,new string[] { "push" }
		}) {
			Console.WriteLine("** RUN #{0}.  Args: {1}", runcount++, String.Join(" ", args));
			__YourMain(args);
			Console.WriteLine("");
        }						   
	}
	//using default parser
	static int __YourMain(string[] args)
	{
		int exitcode;
		
		
		exitcode = CommandLine.Parser.Default
			.ParseArguments<CommitOptions,CloneOptions>(args)
			.MapResult(
			(CommitOptions opts) => RunCommitCommand(opts),
			(CloneOptions opts) => RunCloneCommand(opts), 
			//(AddOptions opts) => RunAddCommand(opts), 
			(parserErrors) => 1
		);
		
		return exitcode;
	}
	//using custom parser 
	static int __YourMain2(string[] args)
	{
		
		int exitcode;
		TextWriter helpWriter= new StringWriter();
		var parser = new Parser (config=>{
			config.HelpWriter=helpWriter;
		});
		exitcode = CommandLine.Parser.Default
			.ParseArguments<CommitOptions,CloneOptions>(args)
			.MapResult(
			(CommitOptions opts) => RunCommitCommand(opts),
			(CloneOptions opts) => RunCloneCommand(opts), 
			//(AddOptions opts) => RunAddCommand(opts), 
			(parserErrors) => DisplayHelp(parserErrors,helpWriter)
		);
		
		return exitcode;
	}
	static int DisplayHelp (IEnumerable<Error> errs, TextWriter helpWriter) {
 		//if (errs.IsVersion () || errs.IsHelp ())
 			Console.WriteLine (helpWriter.ToString ());
 		//else
 		//	Console.Error.WriteLine (helpWriter.ToString ());
		return 1;
 	}
	static int RunCommitCommand(CommitOptions CommitOptions)
	{
		WriteProgramOptions(CommitOptions);
		
		Console.WriteLine("commit message: '{0}'", CommitOptions.Message);
		Console.WriteLine("commit amend: {0}", CommitOptions.Amend);
		
		if(string.IsNullOrEmpty(CommitOptions.Message)==true) {
			Console.WriteLine("Aborting commit due to empty commit message.");	
			return 1;
		}
		
		Console.WriteLine(); 
		return 0;
	}
	
	static int RunCloneCommand(CloneOptions CloneOptions)
	{
		WriteProgramOptions(CloneOptions);

		if(string.IsNullOrEmpty(CloneOptions.DestinationDirectory))
		{
			System.Uri Uri;
			if(System.Uri.TryCreate(CloneOptions.Source, UriKind.Absolute, out Uri))
			{
				CloneOptions.DestinationDirectory = Uri.Segments.Last().TrimStart('/').Replace(".git","");
			}
		}
		
		Console.WriteLine("clone source: {0}", CloneOptions.Source);
		Console.WriteLine("clone destination: {0}", String.Join(" ", CloneOptions.DestinationDirectory));
		
		return 0;
	}
	
	static void WriteProgramOptions(ProgramOptions ProgramOptions)
	{
		Console.WriteLine("ProgramOptions type: {0}", ProgramOptions.GetType().Name);
		Console.WriteLine("Verbose: {0}", ProgramOptions.Verbose);
		Console.WriteLine("Porcelain: {0}", ProgramOptions.Porcelain);
	}
	
	
}

public abstract class ProgramOptions
{
	[Option("verbose")]
	public bool Verbose { get; set; } 
	
	[Option("porcelain", HelpText="use output that can be parsed")]
	public bool Porcelain { get; set; }
}

[Verb("commit")]
public class CommitOptions : ProgramOptions
{
	[Value(0)]
	public IEnumerable<string> InputFiles { get; set; }
	[Option('m',"message")]
	public string Message { get; set; }
	[Option("amend")]
	public string Amend { get; set; }
}

[Verb("clone")]
public class CloneOptions : ProgramOptions
{
	[Value(0)]
	public string Source { get; set; }
	
	[Value(1)]
	public string DestinationDirectory { get; set; }
}