public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "unreachable", "Print out objects that exist but that aren't readable from any of the reference nodes", v => cmd.Unreachable = true },
{ "root", "Report root nodes", v => cmd.Root = true },
{ "tags", "Report tags", v => cmd.Tags = true },
{ "cache", "Consider any object recorded in the index also as a head node for an unreachability trace", v => cmd.Cache = true },
{ "no-reflogs", "Do not consider commits that are referenced only by an entry in a reflog to be reachable", v => cmd.NoReflogs = true },
{ "full", "Check not just objects in GIT_OBJECT_DIRECTORY ($GIT_DIR/objects), but also the ones found in alternate object pools listed in GIT_ALTERNATE_OBJECT_DIRECTORIES or $GIT_DIR/objects/info/alternates, and in packed git archives found in $GIT_DIR/objects/pack and corresponding pack subdirectories in alternate object pools", v => cmd.Full = true },
{ "strict", "Enable more strict checking, namely to catch a file mode recorded with g+w bit set, which was created by older versions of git", v => cmd.Strict = true },
{ "verbose", "Be chatty", v => cmd.Verbose = true },
{ "lost-found", "Write dangling objects into", v => cmd.LostFound = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "l", "Cause the logical variables to be listed", v => cmd.L = true },
};
try
{
List<String> Arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
cmd.Quiet = false;
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "q|quiet", "Do not issue an error message if the <name> is not a symbolic ref but a detached HEAD; instead exit with non-zero status silently", v => cmd.Quiet = true },
{ "m=", "Update the reflog for <name> with <reason>", v => cmd.M = v },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "n", "Do not remove anything; just report what it would remove", v => cmd.N = true },
{ "v", "Report all removed objects", v => cmd.V = true },
{ "expire=", "Only expire loose objects older than <time>", v => cmd.Expire = v },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "shared=", "Only used with the 'init' command", v => cmd.Shared = v },
{ "template=", "Only used with the 'init' command", v => cmd.Template = v },
{ "r|revision=", "Used with the 'fetch' command", v => cmd.Revision = v },
{ ":|stdin", "Only used with the 'set-tree' command", v => cmd.Stdin = true },
{ "rmdir", "Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands", v => cmd.Rmdir = true },
{ "e|edit", "Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands", v => cmd.Edit = true },
{ "l|find-copies-harder=", "Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands", v => cmd.FindCopiesHarder = v },
{ "A|authors-file=", "", v => cmd.AuthorsFile = v },
};
try
{
List<String> Arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "e|edit", "With this option, 'git-revert' will let you edit the commit message prior to committing the revert", v => cmd.Edit = true },
{ "m|mainline", "Usually you cannot revert a merge because you do not know which side of the merge should be considered the mainline", v => cmd.Mainline = true },
{ "no-edit", "With this option, 'git-revert' will not start the commit message editor", v => cmd.NoEdit = true },
{ "n|no-commit", "Usually the command automatically creates a commit with a commit log message stating which commit was reverted", v => cmd.NoCommit = true },
{ "s|signoff", "Add Signed-off-by line at the end of the commit message", v => cmd.Signoff = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "L=", "This option may be given up to three times, and specifies labels to be used in place of the corresponding file names in conflict reports", v => cmd.L = v },
{ "p", "Send results to standard output instead of overwriting `<current-file>`", v => cmd.P = true },
{ "q", "Quiet; do not warn about conflicts", v => cmd.Q = true },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "k", "Usually the program 'cleans up' the Subject: header line to extract the title line for the commit log message, among which (1) remove 'Re:' or 're:', (2) leading whitespaces, (3) '[' up to ']', typically '[PATCH]', and then prepends \"[PATCH] \"", v => cmd.K = true },
{ "b", "When -k is not in effect, all leading strings bracketed with '[' and ']' pairs are stripped", v => cmd.B = true },
{ "u", "The commit log message, author name and author email are taken from the e-mail, and after minimally decoding MIME transfer encoding, re-coded in UTF-8 by transliterating them", v => cmd.U = true },
{ "encoding=", "Similar to -u but if the local convention is different from what is specified by i18n", v => cmd.Encoding = v },
{ "n", "Disable all charset re-coding of the metadata", v => cmd.N = true },
{ "scissors", "Remove everything in body before a scissors line", v => cmd.Scissors = true },
{ "no-scissors", "Ignore scissors lines", v => cmd.NoScissors = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
cmd.Quiet = false;
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "n|dry-run", "Don't actually remove any objects, only show those that would have been removed", v => cmd.DryRun = true },
{ "q|quiet", "Squelch the progress indicator", v => cmd.Quiet = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "format=", "Format of the resulting archive: 'tar' or 'zip'", v => cmd.Format = v },
{ "l|list", "Show all available formats", v => cmd.List = true },
{ "v|verbose", "Report progress to stderr", v => cmd.Verbose = true },
{ "prefix=", "Prepend <prefix>/ to each filename in the archive", v => cmd.Prefix = v },
{ "o|output=", "Write the archive to <file> instead of stdout", v => cmd.Output = v },
{ "worktree-attributes", "Look for attributes in", v => cmd.WorktreeAttributes = true },
{ "remote=", "Instead of making a tar archive from the local repository, retrieve a tar archive from a remote repository", v => cmd.Remote = v },
{ "exec=", "Used with --remote to specify the path to the 'git-upload-archive' on the remote side", v => cmd.Exec = v },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "t|tool=", "Use the merge resolution program specified by <tool>", v => cmd.Tool = v },
{ "y|no-prompt", "Don't prompt before each invocation of the merge resolution program", v => cmd.NoPrompt = true },
{ "prompt", "Prompt before each invocation of the merge resolution program", v => cmd.Prompt = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "h|help", "Print a short usage message and exit", v => cmd.Help = true },
{ "n|numbered", "Sort output according to the number of commits per author instead of author alphabetic order", v => cmd.Numbered = true },
{ "s|summary", "Suppress commit description and provide a commit count summary only", v => cmd.Summary = true },
{ "e|email", "Show the email address of each author", v => cmd.Email = true },
{ "w=", "Linewrap the output by wrapping each line at `width`", v => cmd.W = v },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "z", "Read the NUL-terminated `ls-tree -z` output instead", v => cmd.Z = true },
{ "missing", "Allow missing objects", v => cmd.Missing = true },
{ "batch", "Allow building of more than one tree object before exiting", v => cmd.Batch = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "e|edit", "With this option, 'git-cherry-pick' will let you edit the commit message prior to committing", v => cmd.Edit = true },
{ "x", "When recording the commit, append to the original commit message a note that indicates which commit this change was cherry-picked from", v => cmd.X = true },
{ "r", "It used to be that the command defaulted to do `-x` described above, and `-r` was to disable it", v => cmd.R = true },
{ "m|mainline", "Usually you cannot cherry-pick a merge because you do not know which side of the merge should be considered the mainline", v => cmd.Mainline = true },
{ "n|no-commit", "Usually the command automatically creates a commit", v => cmd.NoCommit = true },
{ "s|signoff", "Add Signed-off-by line at the end of the commit message", v => cmd.Signoff = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "tags", "Do not use branch names, but only tags to name the commits", v => cmd.Tags = true },
{ "refs=", "Only use refs whose names match a given shell pattern", v => cmd.Refs = v },
{ "all", "List all commits reachable from all refs", v => cmd.All = true },
{ "stdin=", "Read from stdin, append \"(<rev_name>)\" to all sha1's of nameable commits, and pass to stdout", v => cmd.Stdin = v },
{ "name-only", "Instead of printing both the SHA-1 and the name, print only the name", v => cmd.NameOnly = true },
{ "no-undefined", "Die with error code != 0 when a reference is undefined, instead of printing `undefined`", v => cmd.NoUndefined = true },
{ "always", "Show uniquely abbreviated commit object as fallback", v => cmd.Always = true },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "shell", "If given, strings that substitute `%(fieldname)` placeholders are quoted as string literals suitable for the specified host language", v => cmd.Shell = true },
{ "perl", "If given, strings that substitute `%(fieldname)` placeholders are quoted as string literals suitable for the specified host language", v => cmd.Perl = true },
{ "python", "If given, strings that substitute `%(fieldname)` placeholders are quoted as string literals suitable for the specified host language", v => cmd.Python = true },
{ "tcl", "If given, strings that substitute `%(fieldname)` placeholders are quoted as string literals suitable for the specified host language", v => cmd.Tcl = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "p=", "Each '-p' indicates the id of a parent commit object", v => cmd.P = v },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "v|verbose", "Be a little more verbose and show remote url after name", v => cmd.Verbose = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "remote=", "Instead of making a tar archive from local repository, retrieve a tar archive from a remote repository", v => cmd.Remote = v },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "v|verbose", "In addition to the number of loose objects and disk space consumed, it reports the number of in-pack objects, number of packs, disk space consumed by those packs, and number of objects that can be removed by running `git prune-packed`", v => cmd.Verbose = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "v", "Be verbose about what is going on, including progress status", v => cmd.V = true },
{ "o=", "Write the generated pack index into the specified file", v => cmd.O = v },
{ "stdin", "When this flag is provided, the pack is read from stdin instead and a copy is then written to <pack-file>", v => cmd.Stdin = true },
{ "fix-thin", "It is possible for 'git-pack-objects' to build \"thin\" pack, which records objects in deltified form based on objects not included in the pack to reduce network traffic", v => cmd.FixThin = true },
// [Mr Happy] I have no idea how OptionSet handles the two lines below this one.
// might or might not work, haven't tested yet.
{ "keep", "Before moving the index into its final destination create an empty", v => cmd.Keep = true },
{ "keep=", "Like --keep create a", v => cmd.KeepMsg = v },
{ "index-version=", "This is intended to be used by the test suite only", v => cmd.IndexVersion = v },
{ "strict", "Die, if the pack contains broken objects or links", v => cmd.Strict = true },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "n", "Do not remove anything; just report what it would remove", v => cmd.N = true },
{ "v", "Report all removed objects", v => cmd.V = true },
{ "expire=", "Only expire loose objects older than <time>", v => cmd.Expire = v },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "receive-pack=", "Path to the 'git-receive-pack' program on the remote end", v => cmd.ReceivePack = v },
{ "exec=", "Same as --receive-pack=<git-receive-pack>", v => cmd.Exec = v },
{ "all", "Instead of explicitly specifying which refs to update, update all heads that locally exist", v => cmd.All = true },
{ "dry-run", "Do everything except actually send the updates", v => cmd.DryRun = true },
{ "force", "Usually, the command refuses to update a remote ref that is not an ancestor of the local ref used to overwrite it", v => cmd.Force = true },
{ "verbose", "Run verbosely", v => cmd.Verbose = true },
{ "thin", "Spend extra cycles to minimize the number of objects to be sent", v => cmd.Thin = true },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(String[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
#if ported
{ "pretty|format", "Pretty print the contents of the commit logs in a specified {format}", (string v) => prettyFormat = v},
{ "abbrev-commit", "Show only a commit object's partial name", (string v) => abbrevCommit = v},
{ "oneline", "Shorthand for --pretty=online and --abbrev-commit together", v=>{isOneLine = true;}},
{ "encoding", "Display the commit log message(s) using the specified {encoding}", (string v) => encoding = v},
#endif
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
DoShow(arguments);
}
else if (args.Length <= 0)
{
//Do show with preset arguments
DoShow(arguments);
}
else
{
OfflineHelp();
}
} catch (OptionException e) {
Console.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "progress=", "Insert 'progress' statements every <n> objects, to be shown by 'git-fast-import' during import", v => cmd.Progress = v },
{ "signed-tags=", "Specify how to handle signed tags", v => cmd.SignedTags = v },
{ "tag-of-filtered-object=", "Specify how to handle tags whose tagged objectis filtered out", v => cmd.TagOfFilteredObject = v },
{ "M", "Perform move and/or copy detection, as described in the linkgit:git-diff[1] manual page, and use it to generate rename and copy commands in the output dump", v => cmd.M = true },
{ "C", "Perform move and/or copy detection, as described in the linkgit:git-diff[1] manual page, and use it to generate rename and copy commands in the output dump", v => cmd.C = true },
{ "export-marks=", "Dumps the internal marks table to <file> when complete", v => cmd.ExportMarks = v },
{ "import-marks=", "Before processing any input, load the marks specified in <file>", v => cmd.ImportMarks = v },
{ "fake-missing-tagger", "Some old repositories have tags without a tagger", v => cmd.FakeMissingTagger = true },
{ "no-data", "Skip output of blob objects and instead refer to blobs via their original SHA-1 hash", v => cmd.NoData = true },
};
try
{
List<String> Arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "v|verbose", "After verifying the pack, show list of objects contained in the pack and a histogram of delta chain length", v => cmd.Verbose = true },
{ "s|stat-only", "Do not verify the pack contents; only show the histogram of delta chain length", v => cmd.StatOnly = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "o=", "Directory in which to place the individual messages", v => cmd.O = v },
{ "b", "If any file doesn't begin with a From line, assume it is a single mail message instead of signaling error", v => cmd.B = true },
{ "d=", "Instead of the default 4 digits with leading zeros, different precision can be specified for the generated filenames", v => cmd.D = v },
{ "f=", "Skip the first <nn> numbers, for example if -f3 is specified, start the numbering with 0004", v => cmd.F = v },
};
try
{
List<String> Arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "p=", "Each '-p' indicates the id of a parent commit object", v => cmd.P = v },
};
try
{
List<String> Arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "upload-pack=", "Use this to specify the path to 'git-upload-pack' on the remote side, if it is not found on your $PATH", v => cmd.UploadPack = v },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(String[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
#if ported
{ "n|dry-run", "Dry run", v=> {isDryRun = true;}},
{ "f|force", "Override the up-to-date check", v=>{isForced = true;}},
{ "q|quiet", "Be quiet", v=>{isQuiet = true;}},
{ "cached", "Only remove from the index", v=>{isCached = true;}},
{ "r", "Allow recursive removal", v=>{allowRecursiveRemoval = true;}},
{ "ignore-match", "Exit with a zero status even if nothing is matched", v=>{ignoreUnmatch = true;}},
#endif
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
DoRm(arguments);
}
else
{
OfflineHelp();
}
} catch (OptionException e) {
Console.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
cmd.Quiet = false;
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "aggressive", "Usually 'git-gc' runs very quickly while providing good disk space utilization and performance", v => cmd.Aggressive = true },
{ "auto", "With this option, 'git-gc' checks whether any housekeeping is required; if not, it exits without performing any work", v => cmd.Auto = true },
{ "prune=", "Prune loose objects older than date (default is 2 weeks ago, overridable by the config variable `gc", v => cmd.Prune = v },
{ "no-prune", "Do not prune any loose objects", v => cmd.NoPrune = true },
{ "quiet", "Suppress all progress reports", v => cmd.Quiet = true },
};
try
{
List<String> Arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "shared=", "Only used with the 'init' command", v => cmd.Shared = v },
{ "template=", "Only used with the 'init' command", v => cmd.Template = v },
{ "r|revision=", "Used with the 'fetch' command", v => cmd.Revision = v },
{ ":|stdin", "Only used with the 'set-tree' command", v => cmd.Stdin = true },
{ "rmdir", "Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands", v => cmd.Rmdir = true },
{ "e|edit", "Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands", v => cmd.Edit = true },
{ "l|find-copies-harder=", "Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands", v => cmd.FindCopiesHarder = v },
{ "A|authors-file=", "", v => cmd.AuthorsFile = v },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "f|force", "Force renaming or moving of a file even if the target exists Skip move or rename actions which would lead to an error condition", v => cmd.Force = true },
{ "k", "Force renaming or moving of a file even if the target exists Skip move or rename actions which would lead to an error condition", v => cmd.K = true },
{ "n|dry-run", "Force renaming or moving of a file even if the target exists Skip move or rename actions which would lead to an error condition", v => cmd.DryRun = true },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "m=", "Use the given note message (instead of prompting)", v => cmd.M = v },
{ "F=", "Take the note message from the given file", v => cmd.F = v },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "progress=", "Insert 'progress' statements every <n> objects, to be shown by 'git-fast-import' during import", v => cmd.Progress = v },
{ "signed-tags=", "Specify how to handle signed tags", v => cmd.SignedTags = v },
{ "tag-of-filtered-object=", "Specify how to handle tags whose tagged objectis filtered out", v => cmd.TagOfFilteredObject = v },
{ "M", "Perform move and/or copy detection, as described in the linkgit:git-diff[1] manual page, and use it to generate rename and copy commands in the output dump", v => cmd.M = true },
{ "C", "Perform move and/or copy detection, as described in the linkgit:git-diff[1] manual page, and use it to generate rename and copy commands in the output dump", v => cmd.C = true },
{ "export-marks=", "Dumps the internal marks table to <file> when complete", v => cmd.ExportMarks = v },
{ "import-marks=", "Before processing any input, load the marks specified in <file>", v => cmd.ImportMarks = v },
{ "fake-missing-tagger", "Some old repositories have tags without a tagger", v => cmd.FakeMissingTagger = true },
{ "no-data", "Skip output of blob objects and instead refer to blobs via their original SHA-1 hash", v => cmd.NoData = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "a|all", "Output all merge bases for the commits, instead of just one", v => cmd.All = true },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "m", "Perform a merge, not just a read", v => cmd.M = true },
{ "reset", "Same as -m, except that unmerged entries are discarded instead of failing", v => cmd.Reset = true },
{ "u", "After a successful merge, update the files in the work tree with the result of the merge", v => cmd.U = true },
{ "i", "Usually a merge requires the index file as well as the files in the working tree are up to date with the current head commit, in order not to lose local changes", v => cmd.I = true },
{ "v", "Show the progress of checking files out", v => cmd.V = true },
{ "trivial", "Restrict three-way merge by 'git-read-tree' to happen only if there is no file-level merging required, instead of resolving merge for trivial cases and leaving conflicting files unresolved in the index", v => cmd.Trivial = true },
{ "aggressive", "Usually a three-way merge by 'git-read-tree' resolves the merge for really trivial cases and leaves other cases unresolved in the index, so that Porcelains can implement different merge policies", v => cmd.Aggressive = true },
{ "prefix=", "Keep the current index contents, and read the contents of named tree-ish under directory at `<prefix>`", v => cmd.Prefix = v },
{ "exclude-per-directory=", "When running the command with `-u` and `-m` options, the merge result may need to overwrite paths that are not tracked in the current branch", v => cmd.ExcludePerDirectory = v },
{ "index-output=", "Instead of writing the results out to `$GIT_INDEX_FILE`, write the resulting index in the named file", v => cmd.IndexOutput = v },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "f", "If an existing replace ref for the same object exists, it will be overwritten (instead of failing)", v => cmd.F = true },
{ "d", "Delete existing replace refs for the given objects", v => cmd.D = true },
{ "l=", "List replace refs for objects that match the given pattern (or all if no pattern is given)", v => cmd.L = v },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "v|verbose", "Be a little more verbose and show remote url after name", v => cmd.Verbose = true },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "t", "Instead of the content, show the object type identified by <object>", v => cmd.T = true },
{ "s", "Instead of the content, show the object size identified by <object>", v => cmd.S = true },
{ "e=", "Suppress all output; instead exit with zero status if <object> exists and is a valid object", v => cmd.E = v },
{ "p=", "Pretty-print the contents of <object> based on its type", v => cmd.P = v },
{ "batch", "Print the SHA1, type, size, and contents of each object provided on stdin", v => cmd.Batch = true },
{ "batch-check", "Print the SHA1, type, and size of each object provided on stdin", v => cmd.BatchCheck = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "y|no-prompt", "Do not prompt before launching a diff tool", v => cmd.NoPrompt = true },
{ "prompt", "Prompt before each invocation of the diff tool", v => cmd.Prompt = true },
{ "t|tool=", "Use the diff tool specified by <tool>", v => cmd.Tool = v },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
cmd.Quiet = false;
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "parseopt", "Use 'git-rev-parse' in option parsing mode (see PARSEOPT section below)", v => cmd.Parseopt = true },
{ "keep-dashdash", "Only meaningful in `--parseopt` mode", v => cmd.KeepDashdash = true },
{ "stop-at-non-option", "Only meaningful in `--parseopt` mode", v => cmd.StopAtNonOption = true },
{ "sq-quote", "Use 'git-rev-parse' in shell quoting mode (see SQ-QUOTE section below)", v => cmd.SqQuote = true },
{ "revs-only", "Do not output flags and parameters not meant for 'git-rev-list' command", v => cmd.RevsOnly = true },
{ "no-revs", "Do not output flags and parameters meant for 'git-rev-list' command", v => cmd.NoRevs = true },
{ "flags", "Do not output non-flag parameters", v => cmd.Flags = true },
{ "no-flags", "Do not output flag parameters", v => cmd.NoFlags = true },
{ "default=", "If there is no parameter given by the user, use `<arg>` instead", v => cmd.Default = v },
{ "verify", "The parameter given must be usable as a single, valid object name", v => cmd.Verify = true },
{ "q|quiet", "Only meaningful in `--verify` mode", v => cmd.Quiet = true },
{ "sq", "Usually the output is made one line per flag and parameter", v => cmd.Sq = true },
{ "not", "When showing object names, prefix them with '{caret}' and strip '{caret}' prefix from the object names that already have one", v => cmd.Not = true },
{ "symbolic", "Usually the object names are output in SHA1 form (with possible '{caret}' prefix); this option makes them output in a form as close to the original input as possible", v => cmd.Symbolic = true },
{ "symbolic-full-name", "This is similar to --symbolic, but it omits input that are not refs (i", v => cmd.SymbolicFullName = true },
{ "abbrev-ref=", "A non-ambiguous short name of the objects name", v => cmd.AbbrevRef = v },
{ "all", "Show all refs found in `$GIT_DIR/refs`", v => cmd.All = true },
{ "branches", "Show branch refs found in `$GIT_DIR/refs/heads`", v => cmd.Branches = true },
{ "tags", "Show tag refs found in `$GIT_DIR/refs/tags`", v => cmd.Tags = true },
{ "remotes", "Show tag refs found in `$GIT_DIR/refs/remotes`", v => cmd.Remotes = true },
{ "show-prefix", "When the command is invoked from a subdirectory, show the path of the current directory relative to the top-level directory", v => cmd.ShowPrefix = true },
{ "show-cdup", "When the command is invoked from a subdirectory, show the path of the top-level directory relative to the current directory (typically a sequence of \"", v => cmd.ShowCdup = true },
{ "git-dir", "Show `$GIT_DIR` if defined else show the path to the", v => cmd.GitDir = true },
{ "is-inside-git-dir", "When the current working directory is below the repository directory print \"true\", otherwise \"false\"", v => cmd.IsInsideGitDir = true },
{ "is-inside-work-tree", "When the current working directory is inside the work tree of the repository print \"true\", otherwise \"false\"", v => cmd.IsInsideWorkTree = true },
{ "is-bare-repository", "When the repository is bare print \"true\", otherwise \"false\"", v => cmd.IsBareRepository = true },
// [Mr Happy] Don't know how CmdParseOptionSet handles this. Might rename a property of the RevParseCommand-class.
//{ "short", "Instead of outputting the full SHA1 values of object names try to abbreviate them to a shorter unique name", v => cmd.Short = true },
{ "short=", "Instead of outputting the full SHA1 values of object names try to abbreviate them to a shorter unique name", v => cmd.Short = v },
{ "since=", "Parse the date string, and output the corresponding --max-age= parameter for 'git-rev-list'", v => cmd.Since = v },
{ "after=", "Parse the date string, and output the corresponding --max-age= parameter for 'git-rev-list'", v => cmd.After = v },
{ "until=", "Parse the date string, and output the corresponding --min-age= parameter for 'git-rev-list'", v => cmd.Until = v },
{ "before=", "Parse the date string, and output the corresponding --min-age= parameter for 'git-rev-list'", v => cmd.Before = v },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "v", "Be verbose about what is going on, including progress status", v => cmd.V = true },
{ "o=", "Write the generated pack index into the specified file", v => cmd.O = v },
{ "stdin", "When this flag is provided, the pack is read from stdin instead and a copy is then written to <pack-file>", v => cmd.Stdin = true },
{ "fix-thin", "It is possible for 'git-pack-objects' to build \"thin\" pack, which records objects in deltified form based on objects not included in the pack to reduce network traffic", v => cmd.FixThin = true },
// [Mr Happy] I have no idea how OptionSet handles the two lines below this one.
// might or might not work, haven't tested yet.
{ "keep", "Before moving the index into its final destination create an empty", v => cmd.Keep = true },
{ "keep=", "Like --keep create a", v => cmd.KeepMsg = v },
{ "index-version=", "This is intended to be used by the test suite only", v => cmd.IndexVersion = v },
{ "strict", "Die, if the pack contains broken objects or links", v => cmd.Strict = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "all", "Processes all packs", v => cmd.All = true },
{ "alt-odb", "Don't require objects present in packs from alternate object directories to be present in local packs", v => cmd.AltOdb = true },
{ "verbose", "Outputs some statistics to stderr", v => cmd.Verbose = true },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
override public void Run(String[] args)
{
// The command takes the same options as git-commit. It shows what would be
// committed if the same options are given.
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
#if ported
{ "q|quiet", "Be quiet", v => { isQuiet = true; } },
{ "v|verbose", "Be verbose", v => { isVerbose = true; } },
{ "F|file=", "Read log from {file}", (string v) => logFile = v },
{ "author=", "Override {author} for commit", (string v) => author = v },
{ "m|message=", "Specify commit {message}", (string v) => message = v },
{ "c|reedit-message=", "Reuse and edit {message} from specified commit", (string v) => reEditMessage = v },
{ "C|reuse-message=", "Reuse {message} from specified commit", (string v) => reUseMessage = v },
{ "s|signoff", "Add Signed-off-by:", v => { isSignOff = true; } },
{ "t|template=", "Use specified {template} file", (string v) => templateFile = v },
{ "e|edit", "Force edit of commit", v => { isForceEdit = true; } },
{ "a|all", "Commit all changed files.", v => { isCommitAll = true; } },
{ "i|include", "Add specified files to index for commit", v => { isInclude = true; } },
{ "interactive", "Interactively add files", v => { isInteractive = true; } },
{ "o|only", "Commit only specified files", v => { isCommitOnly = true; } },
{ "n|no-verify", "Bypass pre-commit hook", v => { isNoVerify = true; } },
{ "amend", "Amend previous commit", v => { isAmend = true; } },
{ "u|untracked-files=", "Show untracked files, optional {MODE}s: all, normal, no.", (string v) => untrackedFileMode = v },
{ "allow-empty", "Ok to record an empty change", v => { isAllowEmpty = true; } },
{ "cleanup=", "How to strip spaces and #comments from message. Options are: " +
"verbatim, whitespace, strip, and default.", (string v) => cleanupOption = v },
{ "dry-run", "Don't actually commit the files, just show if they exist.", v => { isDryRun = true; } },
#endif
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
//Execute the status using the specified file pattern
//cmd.Source = arguments[0];
cmd.Execute();
Display();
}
else if (args.Length <= 0)
{
//Display status if no changes are added to commit
//If changes have been made, commit them?
//Console.WriteLine("These commands still need to be implemented.");
cmd.Execute();
Display();
}
else
{
OfflineHelp();
}
}
catch (OptionException e)
{
OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "k", "Usually the program 'cleans up' the Subject: header line to extract the title line for the commit log message, among which (1) remove 'Re:' or 're:', (2) leading whitespaces, (3) '[' up to ']', typically '[PATCH]', and then prepends \"[PATCH] \"", v => cmd.K = true },
{ "b", "When -k is not in effect, all leading strings bracketed with '[' and ']' pairs are stripped", v => cmd.B = true },
{ "u", "The commit log message, author name and author email are taken from the e-mail, and after minimally decoding MIME transfer encoding, re-coded in UTF-8 by transliterating them", v => cmd.U = true },
{ "encoding=", "Similar to -u but if the local convention is different from what is specified by i18n", v => cmd.Encoding = v },
{ "n", "Disable all charset re-coding of the metadata", v => cmd.N = true },
{ "scissors", "Remove everything in body before a scissors line", v => cmd.Scissors = true },
{ "no-scissors", "Ignore scissors lines", v => cmd.NoScissors = true },
};
try
{
List<String> Arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "z", "Read the NUL-terminated `ls-tree -z` output instead", v => cmd.Z = true },
{ "missing", "Allow missing objects", v => cmd.Missing = true },
{ "batch", "Allow building of more than one tree object before exiting", v => cmd.Batch = true },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "log", "In addition to branch names, populate the log message with one-line descriptions from the actual commits that are being merged", v => cmd.Log = true },
{ "no-log", "Do not list one-line descriptions from the actual commits being merged", v => cmd.Log = false },
// [obsolete]
//{ "summary", "Synonyms to --log and --no-log; these are deprecated and will be removed in the future", v => cmd.Summary = true },
//{ "no-summary", "Synonyms to --log and --no-log; these are deprecated and will be removed in the future", v => cmd.NoSummary = true },
{ "F|file=", "Take the list of merged objects from <file> instead of stdin", v =>
{
//cmd.File = v
}
},
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
//cmd.Arguments = arguments;
//cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
//cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "n|dry-run", "Walk through the patches in the series and warn if we cannot find all of the necessary information to commit a patch", v => cmd.DryRun = true },
{ "author=", "The author name and email address to use when no author information can be found in the patch description", v => cmd.Author = v },
{ "patches=", "The directory to find the quilt patches and the quilt series file", v => cmd.Patches = v },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "m", "Perform a merge, not just a read", v => cmd.M = true },
{ "reset", "Same as -m, except that unmerged entries are discarded instead of failing", v => cmd.Reset = true },
{ "u", "After a successful merge, update the files in the work tree with the result of the merge", v => cmd.U = true },
{ "i", "Usually a merge requires the index file as well as the files in the working tree are up to date with the current head commit, in order not to lose local changes", v => cmd.I = true },
{ "v", "Show the progress of checking files out", v => cmd.V = true },
{ "trivial", "Restrict three-way merge by 'git-read-tree' to happen only if there is no file-level merging required, instead of resolving merge for trivial cases and leaving conflicting files unresolved in the index", v => cmd.Trivial = true },
{ "aggressive", "Usually a three-way merge by 'git-read-tree' resolves the merge for really trivial cases and leaves other cases unresolved in the index, so that Porcelains can implement different merge policies", v => cmd.Aggressive = true },
{ "prefix=", "Keep the current index contents, and read the contents of named tree-ish under directory at `<prefix>`", v => cmd.Prefix = v },
{ "exclude-per-directory=", "When running the command with `-u` and `-m` options, the merge result may need to overwrite paths that are not tracked in the current branch", v => cmd.ExcludePerDirectory = v },
{ "index-output=", "Instead of writing the results out to `$GIT_INDEX_FILE`, write the resulting index in the named file", v => cmd.IndexOutput = v },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "format=", "Format of the resulting archive: 'tar' or 'zip'", v => cmd.Format = v },
{ "l|list", "Show all available formats", v => cmd.List = true },
{ "v|verbose", "Report progress to stderr", v => cmd.Verbose = true },
{ "prefix=", "Prepend <prefix>/ to each filename in the archive", v => cmd.Prefix = v },
{ "o|output=", "Write the archive to <file> instead of stdout", v => cmd.Output = v },
{ "worktree-attributes", "Look for attributes in", v => cmd.WorktreeAttributes = true },
{ "remote=", "Instead of making a tar archive from the local repository, retrieve a tar archive from a remote repository", v => cmd.Remote = v },
{ "exec=", "Used with --remote to specify the path to the 'git-upload-archive' on the remote side", v => cmd.Exec = v },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "t", "Instead of the content, show the object type identified by <object>", v => cmd.T = true },
{ "s", "Instead of the content, show the object size identified by <object>", v => cmd.S = true },
{ "e=", "Suppress all output; instead exit with zero status if <object> exists and is a valid object", v => cmd.E = v },
{ "p=", "Pretty-print the contents of <object> based on its type", v => cmd.P = v },
{ "batch", "Print the SHA1, type, size, and contents of each object provided on stdin", v => cmd.Batch = true },
{ "batch-check", "Print the SHA1, type, and size of each object provided on stdin", v => cmd.BatchCheck = true },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "a", "Run merge against all files in the index that need merging", v => cmd.A = true },
{ "o", "Instead of stopping at the first failed merge, do all of them in one shot - continue with merging even when previous merges returned errors, and only return the error code after all the merges", v => cmd.O = true },
{ "q", "Do not complain about a failed merge program (a merge program failure usually indicates conflicts during the merge)", v => cmd.Q = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "d", "Show only the named tree entry itself, not its children", v => cmd.D = true },
{ "r", "Recurse into sub-trees", v => cmd.R = true },
{ "t", "Show tree entries even when going to recurse them", v => cmd.T = true },
{ "l|long", "Show object size of blob (file) entries", v => cmd.Long = true },
{ "z", "0 line termination on output", v => cmd.Z = true },
{ "name-only", "List only filenames (instead of the \"long\" output), one per line", v => cmd.NameOnly = true },
{ "name-status", "List only filenames (instead of the \"long\" output), one per line", v => cmd.NameStatus = true },
{ "abbrev=", "Instead of showing the full 40-byte hexadecimal object lines, show only a partial prefix", v => cmd.Abbrev = v },
{ "full-name", "Instead of showing the path names relative to the current working directory, show the full path names", v => cmd.FullName = true },
{ "full-tree", "Do not limit the listing to the current working directory", v => cmd.FullTree = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "v|verbose", "In addition to the number of loose objects and disk space consumed, it reports the number of in-pack objects, number of packs, disk space consumed by those packs, and number of objects that can be removed by running `git prune-packed`", v => cmd.Verbose = true },
};
try
{
List<String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "L=", "This option may be given up to three times, and specifies labels to be used in place of the corresponding file names in conflict reports", v => cmd.L = v },
{ "p", "Send results to standard output instead of overwriting `<current-file>`", v => cmd.P = true },
{ "q", "Quiet; do not warn about conflicts", v => cmd.Q = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "log", "In addition to branch names, populate the log message with one-line descriptions from the actual commits that are being merged", v => cmd.Log = true },
{ "no-log", "Do not list one-line descriptions from the actual commits being merged", v => cmd.Log = false },
// [obsolete]
//{ "summary", "Synonyms to --log and --no-log; these are deprecated and will be removed in the future", v => cmd.Summary = true },
//{ "no-summary", "Synonyms to --log and --no-log; these are deprecated and will be removed in the future", v => cmd.NoSummary = true },
{ "F|file=", "Take the list of merged objects from <file> instead of stdin", v =>
{
//cmd.File = v
} },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
//cmd.Arguments = arguments;
//cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
//cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "f", "If an existing replace ref for the same object exists, it will be overwritten (instead of failing)", v => cmd.F = true },
{ "d", "Delete existing replace refs for the given objects", v => cmd.D = true },
{ "l=", "List replace refs for objects that match the given pattern (or all if no pattern is given)", v => cmd.L = v },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
{ "stale-fix", "This revamps the logic -- the definition of \"broken commit\" becomes: a commit that is not reachable from any of the refs and there is a missing object among the commit, tree, or blob objects reachable from it that is not reachable from any of the refs", v => cmd.StaleFix = true },
{ "expire=", "Entries older than this time are pruned", v => cmd.Expire = v },
{ "expire-unreachable=", "Entries older than this time and not reachable from the current tip of the branch are pruned", v => cmd.ExpireUnreachable = v },
{ "all=", "Instead of listing <refs> explicitly, prune all refs", v => cmd.All = v },
{ "updateref", "Update the ref with the sha1 of the top reflog entry (i", v => cmd.Updateref = true },
{ "rewrite", "While expiring or deleting, adjust each reflog entry to ensure that the `old` sha1 field points to the `new` sha1 field of the previous entry", v => cmd.Rewrite = true },
{ "verbose", "Print extra information on screen", v => cmd.Verbose = true },
};
try
{
List<String> Arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
public override void Run(string[] args)
{
cmd.Quiet = false;
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
{ "d", "Remove untracked directories in addition to untracked files", v => cmd.D = true },
{ "f|force", "If the git configuration specifies clean", v => cmd.Force = true },
{ "n|dry-run", "Don't actually remove anything, just show what would be done", v => cmd.DryRun = true },
{ "q|quiet", "Be quiet, only report errors, but not the files that are successfully removed", v => cmd.Quiet = true },
{ "x", "Don't use the ignore rules", v => cmd.x = true },
{ "X", "Remove only files ignored by git", v => cmd.X = true },
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
cmd.Arguments = arguments;
cmd.Execute();
}
else
{
OfflineHelp();
}
}
catch (Exception e)
{
cmd.OutputStream.WriteLine(e.Message);
}
}
