GitSharp

Abstract base class of all git commands. It provides basic infrastructure

Abbreviates a ref-name, used in internal output

long ref abbreviate as remote

Performs upward recursive lookup to return git directory. Honors the environment variable GIT_DIR.

Execute the git command.

Returns the value of the process' environment variable GIT_DIR

This command's output stream. If not explicitly set, the command writes to Git.OutputStream out.

The git repository that is either result of the command (init, clone) or subject to alteration (all other commands). If not explicitly set, the command uses Git.Commands.Repository. Note: InitCommand and CloneCommand ignore this property and overwrite it as a result of Execute.

The git directory. If not explicitly set, the command uses Git.GitDirectory.

Get the directory where the Init command will initialize the repository. if GitDirectory is null ActualDirectory is used to initialize the repository.

Not implemented Don't actually add the file(s), just show if they exist.

Not implemented Be verbose.

Not implemented Allow adding otherwise ignored files.

Not implemented Add modified contents in the working tree interactively to the index. Optional path arguments may be supplied to limit operation to a subset of the working tree. See ``Interactive mode'' for details.

Not implemented Interactively choose hunks of patch between the index and the work tree and add them to the index. This gives the user a chance to review the difference before adding modified contents to the index. + This effectively runs `add --interactive`, but bypasses the initial command menu and directly jumps to the `patch` subcommand. See ``Interactive mode'' for details.

Not implemented Open the diff vs. the index in an editor and let the user edit it. After the editor was closed, adjust the hunk headers and apply the patch to the index. + *NOTE*: Obviously, if you change anything else than the first character on lines beginning with a space or a minus, the patch will no longer apply.

Not implemented Update only files that git already knows about, staging modified content for commit and marking deleted files for removal. This is similar to what "git commit -a" does in preparation for making a commit, except that the update is limited to paths specified on the command line. If no paths are specified, all tracked files in the current directory and its subdirectories are updated.

Not implemented Update files that git already knows about (same as '\--update') and add all untracked files that are not ignored by '.gitignore' mechanism.

Not implemented Record only the fact that the path will be added later. An entry for the path is placed in the index with no content. This is useful for, among other things, showing the unstaged content of such files with 'git diff' and committing them with 'git commit -a'.

Not implemented Don't add the file(s), but only refresh their stat() information in the index.

Not implemented If some files could not be added because of errors indexing them, do not abort the operation, but continue adding the others. The command shall still exit with non-zero status.

Not implemented Add a `Signed-off-by:` line to the commit message, using the committer identity of yourself.

Not implemented Pass `-k` flag to 'git-mailinfo' (see linkgit:git-mailinfo[1]).

Not implemented Remove everything in body before a scissors line (see linkgit:git-mailinfo[1]).

Not implemented Ignore scissors lines (see linkgit:git-mailinfo[1]).

Not implemented Be quiet. Only print error messages.

Not implemented Pass `-u` flag to 'git-mailinfo' (see linkgit:git-mailinfo[1]). The proposed commit log message taken from the e-mail is re-coded into UTF-8 encoding (configuration variable `i18n.commitencoding` can be used to specify project's preferred encoding if it is not UTF-8). + This was optional in prior versions of git, but now it is the default. You can use `--no-utf8` to override this.

Not implemented Pass `-n` flag to 'git-mailinfo' (see linkgit:git-mailinfo[1]).

Not implemented When the patch does not apply cleanly, fall back on 3-way merge if the patch records the identity of blobs it is supposed to apply to and we have those blobs available locally.

Not implemented These flags are passed to the 'git-apply' (see linkgit:git-apply[1]) program that applies the patch.

Not implemented Run interactively.

Not implemented By default the command records the date from the e-mail message as the commit author date, and uses the time of commit creation as the committer date. This allows the user to lie about the committer date by using the same value as the author date.

Not implemented By default the command records the date from the e-mail message as the commit author date, and uses the time of commit creation as the committer date. This allows the user to lie about the author date by using the same value as the committer date.

Not implemented Skip the current patch. This is only meaningful when restarting an aborted patch.

Not implemented After a patch failure (e.g. attempting to apply conflicting patch), the user has applied it by hand and the index file stores the result of the application. Make a commit using the authorship and commit log extracted from the e-mail message and the current index file, and continue.

Not implemented When a patch failure occurs, <msg> will be printed to the screen before exiting. This overrides the standard message informing you to use `--resolved` or `--skip` to handle the failure. This is solely for internal use between 'git-rebase' and 'git-am'.

Not implemented Restore the original branch and abort the patching operation.

Not implemented Show blank SHA-1 for boundary commits. This can also be controlled via the `blame.blankboundary` config option.

Not implemented Do not treat root commits as boundaries. This can also be controlled via the `blame.showroot` config option.

Not implemented Include additional statistics at the end of blame output.

Not implemented Annotate only the given line range. <start> and <end> can take one of these forms:

Not implemented Show long rev (Default: off).

Not implemented Show raw timestamp (Default: off).

Not implemented Use revisions from revs-file instead of calling linkgit:git-rev-list[1].

Not implemented Walk history forward instead of backward. Instead of showing the revision in which a line appeared, this shows the last revision in which a line has existed. This requires a range of revision like START..END where the path to blame exists in START.

Not implemented Show in a format designed for machine consumption.

Not implemented Show the result incrementally in a format designed for machine consumption.

Not implemented Specifies the encoding used to output author names and commit summaries. Setting it to `none` makes blame output unconverted data. For more information see the discussion about encoding in the linkgit:git-log[1] manual page.

Not implemented When <rev> is not specified, the command annotates the changes starting backwards from the working tree copy. This flag makes the command pretend as if the working tree copy has the contents of the named file (specify `-` to make the command read from the standard input).

Not implemented The value is one of the following alternatives: {relative,local,default,iso,rfc,short}. If --date is not provided, the value of the blame.date config variable is used. If the blame.date config variable is also not set, the iso format is used. For more information, See the discussion of the --date option at linkgit:git-log[1].

Not implemented Detect moving lines in the file as well. When a commit moves a block of lines in a file (e.g. the original file has A and then B, and the commit changes it to B and then A), the traditional 'blame' algorithm typically blames the lines that were moved up (i.e. B) to the parent and assigns blame to the lines that were moved down (i.e. A) to the child commit. With this option, both groups of lines are blamed on the parent. + alphanumeric characters that git must detect as moving within a file for it to associate those lines with the parent commit.

Not implemented In addition to `-M`, detect lines copied from other files that were modified in the same commit. This is useful when you reorganize your program and move code around across files. When this option is given twice, the command additionally looks for copies from all other files in the parent for the commit that creates the file. + alphanumeric characters that git must detect as moving between files for it to associate those lines with the parent commit.

Not implemented Show help message.

Not implemented Instead of applying the patch, output diffstat for the input. Turns off "apply".

Not implemented Similar to `--stat`, but shows the number of added and deleted lines in decimal notation and the pathname without abbreviation, to make it more machine friendly. For binary files, outputs two `-` instead of saying `0 0`. Turns off "apply".

Not implemented Instead of applying the patch, output a condensed summary of information obtained from git diff extended headers, such as creations, renames and mode changes. Turns off "apply".

Not implemented Instead of applying the patch, see if the patch is applicable to the current working tree and/or the index file and detects errors. Turns off "apply".

Not implemented When `--check` is in effect, or when applying the patch (which is the default when none of the options that disables it is in effect), make sure the patch is applicable to what the current index file records. If the file to be patched in the working tree is not up-to-date, it is flagged as an error. This flag also causes the index file to be updated.

Not implemented Apply a patch without touching the working tree. Instead take the cached data, apply the patch, and store the result in the index without using the working tree. This implies `--index`.

Not implemented Newer 'git-diff' output has embedded 'index information' for each blob to help identify the original version that the patch applies to. When this flag is given, and if the original versions of the blobs are available locally, builds a temporary index containing those blobs. + When a pure mode change is encountered (which has no index information), the information is read from the current index instead.

Not implemented Apply the patch in reverse.

Not implemented For atomicity, 'git-apply' by default fails the whole patch and does not touch the working tree when some of the hunks do not apply. This option makes it apply the parts of the patch that are applicable, and leave the rejected hunks in corresponding *.rej files.

Not implemented When `--numstat` has been given, do not munge pathnames, but use a NUL-terminated machine-readable format. + Without this option, each pathname output will have TAB, LF, double quotes, and backslash characters replaced with `\t`, `\n`, `\"`, and `\\`, respectively, and the pathname will be enclosed in double quotes if any of those replacements occurred.

Not implemented Remove <n> leading slashes from traditional diff paths. The default is 1.

Not implemented Ensure at least <n> lines of surrounding context match before and after each change. When fewer lines of surrounding context exist they all must match. By default no context is ever ignored.

Not implemented By default, 'git-apply' expects that the patch being applied is a unified diff with at least one line of context. This provides good safety measures, but breaks down when applying a diff generated with `--unified=0`. To bypass these checks use `--unidiff-zero`. + Note, for the reasons stated above usage of context-free patches is discouraged.

Not implemented If you use any of the options marked "Turns off 'apply'" above, 'git-apply' reads and outputs the requested information without actually applying the patch. Give this flag after those flags to also apply the patch.

Not implemented When applying a patch, ignore additions made by the patch. This can be used to extract the common part between two files by first running 'diff' on them and applying the result with this option, which would apply the deletion part but not the addition part.

Not implemented Historically we did not allow binary patch applied without an explicit permission from the user, and this flag was the way to do so. Currently we always allow binary patch application, so this is a no-op.

Not implemented Don't apply changes to files matching the given path pattern. This can be useful when importing patchsets, where you want to exclude certain files or directories.

Not implemented Apply changes to files matching the given path pattern. This can be useful when importing patchsets, where you want to include certain files or directories. + When `--exclude` and `--include` patterns are used, they are examined in the order they appear on the command line, and the first match determines if a patch to each path is used. A patch to a path that does not match any on the command line, and ignored if there is any include pattern.

Not implemented When applying a patch, ignore changes in whitespace in context lines if necessary. Context lines will preserve their whitespace, and they will not undergo whitespace fixing regardless of the value of the `--whitespace` option. New lines will still be fixed, though.

Not implemented When applying a patch, detect a new or modified line that has whitespace errors. What are considered whitespace errors is controlled by `core.whitespace` configuration. By default, trailing whitespaces (including lines that solely consist of whitespaces) and a space character that is immediately followed by a tab character inside the initial indent of the line are considered whitespace errors. + By default, the command outputs warning messages but applies the patch. When `git-apply` is used for statistics and not applying a patch, it defaults to `nowarn`. + You can use different `<action>` values to control this behavior: + * `nowarn` turns off the trailing whitespace warning. * `warn` outputs warnings for a few such errors, but applies the

Not implemented Format of the resulting archive: 'tar' or 'zip'. If this option is not given, and the output file is specified, the format is inferred from the filename if possible (e.g. writing to "foo.zip" makes the output to be in the zip format). Otherwise the output format is `tar`.

Not implemented Show all available formats.

Not implemented Report progress to stderr.

Not implemented Prepend <prefix>/ to each filename in the archive.

Not implemented Write the archive to <file> instead of stdout.

Not implemented Look for attributes in .gitattributes in working directory too.

Not implemented Instead of making a tar archive from the local repository, retrieve a tar archive from a remote repository.

Not implemented Used with --remote to specify the path to the 'git-upload-archive' on the remote side.

Not implemented Use the same output mode as linkgit:git-annotate[1] (Default: off).

Not implemented Include debugging information related to the movement of lines between files (see `-C`) and lines moved within a file (see `-M`). The first number listed is the score. This is the number of alphanumeric characters detected as having been moved between or within files. This must be above a certain threshold for 'git-blame' to consider those lines of code to have been moved.

Not implemented Show the filename in the original commit. By default the filename is shown if there is any line that came from a file with a different name, due to rename detection.

Not implemented Show the line number in the original commit (Default: off).

Not implemented Suppress the author name and timestamp from the output.

Not implemented Ignore whitespace when comparing the parent's version and the child's to find where the lines came from.

Not implemented Show blank SHA-1 for boundary commits. This can also be controlled via the `blame.blankboundary` config option.

Not implemented Do not treat root commits as boundaries. This can also be controlled via the `blame.showroot` config option.

Not implemented Include additional statistics at the end of blame output.

Not implemented Annotate only the given line range. <start> and <end> can take one of these forms:

Not implemented Show long rev (Default: off).

Not implemented Show raw timestamp (Default: off).

Not implemented Use revisions from revs-file instead of calling linkgit:git-rev-list[1].

Not implemented Show in a format designed for machine consumption.

Not implemented Show the result incrementally in a format designed for machine consumption.

Not implemented Show help message.

Not implemented Delete a branch. The branch must be fully merged in HEAD.

Not implemented Delete a branch irrespective of its merged status.

Not implemented Create the branch's reflog. This activates recording of all changes made to the branch ref, enabling use of date based sha1 expressions such as "<branchname<@\{yesterday}".

Not implemented Reset <branchname> to <startpoint> if <branchname> exists already. Without `-f` 'git-branch' refuses to change an existing branch.

Not implemented Move/rename a branch and the corresponding reflog.

Not implemented Move/rename a branch even if the new branch name already exists.

Not implemented Color branches to highlight current, local, and remote branches.

Not implemented Turn off branch colors, even when the configuration file gives the default to color output.

Not implemented List or delete (if used with -d) the remote-tracking branches.

Not implemented List both remote-tracking branches and local branches.

Not implemented Show sha1 and commit subject line for each head, along with relationship to upstream branch (if any). If given twice, print the name of the upstream branch, as well.

Not implemented Alter the sha1's minimum display length in the output listing. The default value is 7.

Not implemented Display the full sha1s in the output listing rather than abbreviating them.

Not implemented When creating a new branch, set up configuration to mark the start-point branch as "upstream" from the new branch. This configuration will tell git to show the relationship between the two branches in `git status` and `git branch -v`. Furthermore, it directs `git pull` without arguments to pull from the upstream when the new branch is checked out. + This behavior is the default when the start point is a remote branch. Set the branch.autosetupmerge configuration variable to `false` if you want `git checkout` and `git branch` to always behave as if '--no-track' were given. Set it to `always` if you want this behavior when the start-point is either a local or remote branch.

Not implemented Do not set up "upstream" configuration, even if the branch.autosetupmerge configuration variable is true.

Not implemented Only list branches which contain the specified commit.

Not implemented Only list branches whose tips are reachable from the specified commit (HEAD if not specified).

Not implemented Only list branches whose tips are not reachable from the specified commit (HEAD if not specified).

Not implemented Instead of the content, show the object type identified by <object>.

Not implemented Instead of the content, show the object size identified by <object<.

Not implemented Suppress all output; instead exit with zero status if <object> exists and is a valid object.

Not implemented Pretty-print the contents of <object> based on its type.

Not implemented Print the SHA1, type, size, and contents of each object provided on stdin. May not be combined with any other options or arguments.

Not implemented Print the SHA1, type, and size of each object provided on stdin. May not be combined with any other options or arguments.

Quiet, suppress feedback messages.

Not implemented When switching branches, proceed even if the index or the working tree differs from HEAD. This is used to throw away local changes. + When checking out paths from the index, do not fail upon unmerged entries; instead, unmerged entries are ignored.

Not implemented When checking out paths from the index, check out stage #2 ('ours') or #3 ('theirs') for unmerged paths.

Not implemented Create a new branch named <new_branch> and start it at <start_point>; see linkgit:git-branch[1] for details.

Not implemented When creating a new branch, set up "upstream" configuration. See "--track" in linkgit:git-branch[1] for details. + If no '-b' option is given, the name of the new branch will be derived from the remote branch. If "remotes/" or "refs/remotes/" is prefixed it is stripped away, and then the part up to the next slash (which would be the nickname of the remote) is removed. This would tell us to use "hack" as the local branch when branching off of "origin/hack" (or "remotes/origin/hack", or even "refs/remotes/origin/hack"). If the given name has no slash, or the above guessing results in an empty name, the guessing is aborted. You can explicitly give a name with '-b' in such a case.

Not implemented Do not set up "upstream" configuration, even if the branch.autosetupmerge configuration variable is true.

Not implemented Create the new branch's reflog; see linkgit:git-branch[1] for details.

Not implemented When switching branches, if you have local modifications to one or more files that are different between the current branch and the branch to which you are switching, the command refuses to switch branches in order to preserve your modifications in context. However, with this option, a three-way merge between the current branch, your working tree contents, and the new branch is done, and you will be on the new branch. + When a merge conflict happens, the index entries for conflicting paths are left unmerged, and you need to resolve the conflicts and mark the resolved paths with `git add` (or `git rm` if the merge should result in deletion of the path). + When checking out paths from the index, this option lets you recreate the conflicted merge in the specified paths.

Not implemented The same as --merge option above, but changes the way the conflicting hunks are presented, overriding the merge.conflictstyle configuration variable. Possible values are "merge" (default) and "diff3" (in addition to what is shown by "merge" style, shows the original contents).

Not implemented Interactively select hunks in the difference between the <tree-ish> (or the index, if unspecified) and the working tree. The chosen hunks are then applied in reverse to the working tree (and if a <tree-ish> was specified, the index). + This means that you can use `git checkout -p` to selectively discard edits from your current working tree.

Not implemented update stat information for the checked out entries in the index file.

Not implemented be quiet if files exist or are not in the index

Not implemented forces overwrite of existing files

Not implemented checks out all files in the index. Cannot be used together with explicit filenames.

Not implemented Don't checkout new files, only refresh files already checked out.

Not implemented When creating files, prepend <string> (usually a directory including a trailing /)

Not implemented Instead of checking out unmerged entries, copy out the files from named stage. <number> must be between 1 and 3. Note: --stage=all automatically implies --temp.

Not implemented Instead of copying the files to the working directory write the content to temporary files. The temporary name associations will be written to stdout.

Not implemented Instead of taking list of paths from the command line, read list of paths from the standard input. Paths are separated by LF (i.e. one path per line) by default.

Not implemented Only meaningful with `--stdin`; paths are separated with NUL character instead of LF.

Not implemented Verbose.

Not implemented With this option, 'git-cherry-pick' will let you edit the commit message prior to committing.

Not implemented When recording the commit, append to the original commit message a note that indicates which commit this change was cherry-picked from. Append the note only for cherry picks without conflicts. Do not use this option if you are cherry-picking from your private branch because the information is useless to the recipient. If on the other hand you are cherry-picking between two publicly visible branches (e.g. backporting a fix to a maintenance branch for an older release from a development branch), adding this information can be useful.

Not implemented It used to be that the command defaulted to do `-x` described above, and `-r` was to disable it. Now the default is not to do `-x` so this option is a no-op.

Not implemented Usually you cannot cherry-pick a merge because you do not know which side of the merge should be considered the mainline. This option specifies the parent number (starting from 1) of the mainline and allows cherry-pick to replay the change relative to the specified parent.

Not implemented Usually the command automatically creates a commit. This flag applies the change necessary to cherry-pick the named commit to your working tree and the index, but does not make the commit. In addition, when this option is used, your index does not have to match the HEAD commit. The cherry-pick is done against the beginning state of your index. + This is useful when cherry-picking more than one commits' effect to your index in a row.

Not implemented Add Signed-off-by line at the end of the commit message.

Not implemented Remove untracked directories in addition to untracked files. If an untracked directory is managed by a different git repository, it is not removed by default. Use -f option twice if you really want to remove such a directory.

Not implemented If the git configuration specifies clean.requireForce as true, 'git-clean' will refuse to run unless given -f or -n.

Not implemented Don't actually remove anything, just show what would be done.

Not implemented Be quiet, only report errors, but not the files that are successfully removed.

Not implemented Don't use the ignore rules. This allows removing all untracked files, including build products. This can be used (possibly in conjunction with 'git-reset') to create a pristine working directory to test a clean build.

Not implemented Remove only files ignored by git. This may be useful to rebuild everything from scratch, but keep manually created files.

Represents git's clone command line interface command.

Do it.

The name of a new directory to clone into.

The (possibly remote) repository to clone from.

Not implemented When the repository to clone from is on a local machine, this flag bypasses normal "git aware" transport mechanism and clones the repository by making a copy of HEAD and everything under objects and refs directories. The files under .git/objects/ directory are hardlinked to save space when possible. This is now the default when the source repository is specified with /path/to/repo syntax, so it essentially is a no-op option. To force copying instead of hardlinking (which may be desirable if you are trying to make a back-up of your repository), but still avoid the usual "git aware" transport mechanism, --no-hardlinks can be used.

Not implemented Optimize the cloning process from a repository on a local filesystem by copying files under .git/objects directory.

Not implemented When the repository to clone is on the local machine, instead of using hard links, automatically setup .git/objects/info/alternates to share the objects with the source repository. The resulting repository starts out without any object of its own. NOTE: this is a possibly dangerous operation; do not use it unless you understand what it does. If you clone your repository using this option and then delete branches (or use any other git command that makes any existing commit unreferenced) in the source repository, some objects may become unreferenced (or dangling). These objects may be removed by normal git operations (such as git-commit) which automatically call git gc --auto. (See git-gc(1).) If these objects are removed and were referenced by the cloned repository, then the cloned repository will become corrupt.

Not implemented If the reference repository is on the local machine automatically setup .git/objects/info/alternates to obtain objects from the reference repository. Using an already existing repository as an alternate will require fewer objects to be copied from the repository being cloned, reducing network and local storage costs. NOTE: see NOTE to --shared option.

Operate quietly. This flag is also passed to the `rsync' command when given.

Display the progressbar, even in case the standard output is not a terminal.

No checkout of HEAD is performed after the clone is complete.

Make a bare GIT repository. That is, instead of creating "directory" and placing the administrative files in "directory"/.git, make the "directory" itself the $GIT_DIR. This obviously implies the -n because there is nowhere to check out the working tree. Also the branch heads at the remote are copied directly to corresponding local branch heads, without mapping them to refs/remotes/origin/. When this option is used, neither remote-tracking branches nor the related configuration variables are created.

Set up a mirror of the remote repository. This implies --bare.

Instead of using the remote name origin to keep track of the upstream repository, use "name".

Not implemented. When given, and the repository to clone from is accessed via ssh, this specifies a non-default path for the command run on the other end.

Not implemented. Specify the directory from which templates will be used; if unset the templates are taken from the installation defined default, typically /usr/share/git-core/templates.

Not implemented. Create a shallow clone with a history truncated to the specified number of revisions. A shallow repository has a number of limitations (you cannot clone or fetch from it, nor push from nor into it), but is adequate if you are only interested in the recent history of a large project with a long history, and would want to send in fixes as patches.

Not implemented Tell the command to automatically stage files that have been modified and deleted, but new files you have not told git about are not affected.

Not implemented Take an existing commit object, and reuse the log message and the authorship information (including the timestamp) when creating the commit.

Not implemented Like '-C', but with '-c' the editor is invoked, so that the user can further edit the commit message.

Not implemented When used with -C/-c/--amend options, declare that the authorship of the resulting commit now belongs of the committer. This also renews the author timestamp.

Not implemented Take the commit message from the given file. Use '-' to read the message from the standard input.

Not implemented Override the author name used in the commit. You can use the standard `A U Thor <author@example.com>` format. Otherwise, an existing commit that matches the given string and its author name is used.

Not implemented Use the given <msg> as the commit message.

Not implemented Use the contents of the given file as the initial version of the commit message. The editor is invoked and you can make subsequent changes. If a message is specified using the `-m` or `-F` options, this option has no effect. This overrides the `commit.template` configuration variable.

Not implemented Add Signed-off-by line by the committer at the end of the commit log message.

Not implemented This option bypasses the pre-commit and commit-msg hooks. See also linkgit:githooks[5].

Not implemented Usually recording a commit that has the exact same tree as its sole parent commit is a mistake, and the command prevents you from making such a commit. This option bypasses the safety, and is primarily for use by foreign scm interface scripts.

Not implemented This option sets how the commit message is cleaned up. The '<mode>' can be one of 'verbatim', 'whitespace', 'strip', and 'default'. The 'default' mode will strip leading and trailing empty lines and #commentary from the commit message only if the message is to be edited. Otherwise only whitespace removed. The 'verbatim' mode does not change message at all, 'whitespace' removes just leading/trailing whitespace lines and 'strip' removes both whitespace and commentary.

Not implemented The message taken from file with `-F`, command line with `-m`, and from file with `-C` are usually used as the commit log message unmodified. This option lets you further edit the message taken from these sources.

Not implemented Used to amend the tip of the current branch. Prepare the tree object you would want to replace the latest commit as usual (this includes the usual -i/-o and explicit paths), and the commit log editor is seeded with the commit message from the tip of the current branch. The commit you create replaces the current tip -- if it was a merge, it will have the parents of the current tip as parents -- so the current top commit is discarded. +

Not implemented Each '-p' indicates the id of a parent commit object.

Displays list of all the variables set in the config file

Not implemented. For multi-line options only.

Not implemented 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`.

Not implemented Instead of using only the annotated tags, use any ref found in `.git/refs/`. This option enables matching any known branch, remote branch, or lightweight tag.

Not implemented Instead of using only the annotated tags, use any tag found in `.git/refs/tags`. This option enables matching a lightweight (non-annotated) tag.

Not implemented Instead of finding the tag that predates the commit, find the tag that comes after the commit, and thus contains it. Automatically implies --tags.

Not implemented Instead of using the default 7 hexadecimal digits as the abbreviated object name, use <n> digits, or as many digits as needed to form a unique object name. An <n> of 0 will suppress long format, only showing the closest tag.

Not implemented Instead of considering only the 10 most recent tags as candidates to describe the input committish consider up to <n> candidates. Increasing <n> above 10 will take slightly longer but may produce a more accurate result. An <n> of 0 will cause only exact matches to be output.

Not implemented Only output exact matches (a tag directly references the supplied commit). This is a synonym for --candidates=0.

Not implemented Verbosely display information about the searching strategy being employed to standard error. The tag name will still be printed to standard out.

Not implemented Always output the long format (the tag, the number of commits and the abbreviated commit name) even when it matches a tag. This is useful when you want to see parts of the commit object name in "describe" output, even when the commit in question happens to be a tagged version. Instead of just emitting the tag name, it will describe such a commit as v1.2-0-gdeadbee (0th commit since tag v1.2 that points at object deadbee....).

Not implemented Only consider tags matching the given pattern (can be used to avoid leaking private tags made from the repository).

Not implemented Show uniquely abbreviated commit object as fallback.

Not implemented ifdef::git-format-patch[] Generate plain patches without any diffstats. endif::git-format-patch[]

Not implemented ifndef::git-format-patch[] Generate patch (see section on generating patches). {git-diff? This is the default.} endif::git-format-patch[]

Not implemented Generate diffs with <n> lines of context instead of the usual three. ifndef::git-format-patch[] Implies `-p`. endif::git-format-patch[]

Not implemented ifndef::git-format-patch[] Generate the raw format. {git-diff-core? This is the default.} endif::git-format-patch[]

Not implemented ifndef::git-format-patch[] Synonym for `-p --raw`. endif::git-format-patch[]

Not implemented Generate a diff using the "patience diff" algorithm.

Not implemented Generate a diffstat. You can override the default output width for 80-column terminal by `--stat=width`. The width of the filename part can be controlled by giving another width to it separated by a comma.

Not implemented Similar to `\--stat`, but shows number of added and deleted lines in decimal notation and pathname without abbreviation, to make it more machine friendly. For binary files, outputs two `-` instead of saying `0 0`.

Not implemented Output only the last line of the `--stat` format containing total number of modified files, as well as number of added and deleted lines.

Not implemented Output the distribution of relative amount of changes (number of lines added or removed) for each sub-directory. Directories with changes below a cut-off percent (3% by default) are not shown. The cut-off percent can be set with `--dirstat=limit`. Changes in a child directory is not counted for the parent directory, unless `--cumulative` is used.

Not implemented Same as `--dirstat`, but counts changed files instead of lines.

Not implemented Output a condensed summary of extended header information such as creations, renames and mode changes.

Not implemented ifndef::git-format-patch[] Synonym for `-p --stat`. endif::git-format-patch[]

Not implemented ifdef::git-log[] Separate the commits with NULs instead of with new newlines. + Also, when `--raw` or `--numstat` has been given, do not munge pathnames and use NULs as output field terminators. endif::git-log[] ifndef::git-log[] When `--raw` or `--numstat` has been given, do not munge pathnames and use NULs as output field terminators. endif::git-log[] + Without this option, each pathname output will have TAB, LF, double quotes, and backslash characters replaced with `\t`, `\n`, `\"`, and `\\`, respectively, and the pathname will be enclosed in double quotes if any of those replacements occurred.

Not implemented Show only names of changed files.

Not implemented Show only names and status of changed files. See the description of the `--diff-filter` option on what the status letters mean.

Not implemented Chose the output format for submodule differences. <format> can be one of 'short' and 'log'. 'short' just shows pairs of commit names, this format is used when this option is not given. 'log' is the default value for this option and lists the commits in that commit range like the 'summary' option of linkgit:git-submodule[1] does.

Not implemented Show colored diff.

Not implemented Turn off colored diff, even when the configuration file gives the default to color output.

Not implemented Show colored word diff, i.e., color words which have changed. By default, words are separated by whitespace. + When a <regex> is specified, every non-overlapping match of the considered whitespace and ignored(!) for the purposes of finding differences. You may want to append `|[^[:space:]]` to your regular expression to make sure that it matches all non-whitespace characters. A match that contains a newline is silently truncated(!) at the newline. + The regex can also be set via a diff driver or configuration option, see linkgit:gitattributes[1] or linkgit:git-config[1]. Giving it explicitly overrides any diff driver or configuration setting. Diff drivers override configuration settings. endif::git-format-patch[]

Not implemented Turn off rename detection, even when the configuration file gives the default to do so.

Not implemented ifndef::git-format-patch[] Warn if changes introduce trailing whitespace or an indent that uses a space before a tab. Exits with non-zero status if problems are found. Not compatible with --exit-code. endif::git-format-patch[]

Not implemented Instead of the first handful of characters, show the full pre- and post-image blob object names on the "index" line when generating patch format output.

Not implemented In addition to `--full-index`, output a binary diff that can be applied with `git-apply`.

Not implemented Instead of showing the full 40-byte hexadecimal object name in diff-raw format output and diff-tree header lines, show only a partial prefix. This is independent of the `--full-index` option above, which controls the diff-patch output format. Non default number of digits can be specified with `--abbrev=<n>`.

Not implemented Break complete rewrite changes into pairs of delete and create.

Not implemented Detect renames.

Not implemented Detect copies as well as renames. See also `--find-copies-harder`.

Not implemented ifndef::git-format-patch[] Select only files that are Added (`A`), Copied (`C`), Deleted (`D`), Modified (`M`), Renamed (`R`), have their type (i.e. regular file, symlink, submodule, ...) changed (`T`), are Unmerged (`U`), are Unknown (`X`), or have had their pairing Broken (`B`). Any combination of the filter characters may be used. When `*` (All-or-none) is added to the combination, all paths are selected if there is any file that matches other criteria in the comparison; if there is no file that matches other criteria, nothing is selected. endif::git-format-patch[]

Not implemented For performance reasons, by default, `-C` option finds copies only if the original file of the copy was modified in the same changeset. This flag makes the command inspect unmodified files as candidates for the source of copy. This is a very expensive operation for large projects, so use it with caution. Giving more than one `-C` option has the same effect.

Not implemented The `-M` and `-C` options require O(n^2) processing time where n is the number of potential rename/copy targets. This option prevents rename/copy detection from running if the number of rename/copy targets exceeds the specified number.

Not implemented ifndef::git-format-patch[] Look for differences that introduce or remove an instance of <string>. Note that this is different than the string simply appearing in diff output; see the 'pickaxe' entry in linkgit:gitdiffcore[7] for more details.

Not implemented When `-S` finds a change, show all the changes in that changeset, not just the files that contain the change in <string>.

Not implemented Make the <string> not a plain string but an extended POSIX regex to match. endif::git-format-patch[]

Not implemented Output the patch in the order specified in the <orderfile>, which has one shell glob pattern per line.

Not implemented ifndef::git-format-patch[] Swap two inputs; that is, show differences from index or on-disk file to tree contents.

Not implemented When run from a subdirectory of the project, it can be told to exclude changes outside the directory and show pathnames relative to it with this option. When you are not in a subdirectory (e.g. in a bare repository), you can name which subdirectory to make the output relative to by giving a <path> as an argument. endif::git-format-patch[]

Not implemented Treat all files as text.

Not implemented Ignore changes in whitespace at EOL.

Not implemented Ignore changes in amount of whitespace. This ignores whitespace at line end, and considers all other sequences of one or more whitespace characters to be equivalent.

Not implemented Ignore whitespace when comparing lines. This ignores differences even if one line has whitespace where the other line has none.

Not implemented Show the context between diff hunks, up to the specified number of lines, thereby fusing hunks that are close to each other.

Not implemented ifndef::git-format-patch[] Make the program exit with codes similar to diff(1). That is, it exits with 1 if there were differences and 0 means no differences.

Not implemented Disable all output of the program. Implies `--exit-code`. endif::git-format-patch[]

Not implemented Allow an external diff helper to be executed. If you set an external diff driver with linkgit:gitattributes[5], you need to use this option with linkgit:git-log[1] and friends.

Not implemented Disallow external diff drivers.

Not implemented Ignore changes to submodules in the diff generation.

Not implemented Show the given source prefix instead of "a/".

Not implemented Show the given destination prefix instead of "b/".

Not implemented Do not show any source or destination prefix.

Not implemented Diff against the "base" version, "our branch" or "their branch" respectively. With these options, diffs for merged entries are not shown. + The default is to diff against our branch (-2) and the cleanly resolved paths. The option -0 can be given to omit diff output for unmerged entries and just show "Unmerged".

Not implemented This compares stage 2 (our branch), stage 3 (their branch) and the working tree file and outputs a combined diff, similar to the way 'diff-tree' shows a merge commit with these flags.

Not implemented Remain silent even on nonexistent files