Documentation / git-notes.txton commit documentation: trivial whitespace cleanups (240ae2b)
   1git-notes(1)
   2============
   3
   4NAME
   5----
   6git-notes - Add or inspect object notes
   7
   8SYNOPSIS
   9--------
  10[verse]
  11'git notes' [list [<object>]]
  12'git notes' add [-f] [-F <file> | -m <msg> | (-c | -C) <object>] [<object>]
  13'git notes' copy [-f] ( --stdin | <from-object> <to-object> )
  14'git notes' append [-F <file> | -m <msg> | (-c | -C) <object>] [<object>]
  15'git notes' edit [<object>]
  16'git notes' show [<object>]
  17'git notes' merge [-v | -q] [-s <strategy> ] <notes_ref>
  18'git notes' merge --commit [-v | -q]
  19'git notes' merge --abort [-v | -q]
  20'git notes' remove [--ignore-missing] [--stdin] [<object>...]
  21'git notes' prune [-n | -v]
  22'git notes' get-ref
  23
  24
  25DESCRIPTION
  26-----------
  27Adds, removes, or reads notes attached to objects, without touching
  28the objects themselves.
  29
  30By default, notes are saved to and read from `refs/notes/commits`, but
  31this default can be overridden.  See the OPTIONS, CONFIGURATION, and
  32ENVIRONMENT sections below.  If this ref does not exist, it will be
  33quietly created when it is first needed to store a note.
  34
  35A typical use of notes is to supplement a commit message without
  36changing the commit itself. Notes can be shown by 'git log' along with
  37the original commit message. To distinguish these notes from the
  38message stored in the commit object, the notes are indented like the
  39message, after an unindented line saying "Notes (<refname>):" (or
  40"Notes:" for `refs/notes/commits`).
  41
  42Notes can also be added to patches prepared with `git format-patch` by
  43using the `--notes` option. Such notes are added as a patch commentary
  44after a three dash separator line.
  45
  46To change which notes are shown by 'git log', see the
  47"notes.displayRef" configuration in linkgit:git-log[1].
  48
  49See the "notes.rewrite.<command>" configuration for a way to carry
  50notes across commands that rewrite commits.
  51
  52
  53SUBCOMMANDS
  54-----------
  55
  56list::
  57        List the notes object for a given object. If no object is
  58        given, show a list of all note objects and the objects they
  59        annotate (in the format "<note object> <annotated object>").
  60        This is the default subcommand if no subcommand is given.
  61
  62add::
  63        Add notes for a given object (defaults to HEAD). Abort if the
  64        object already has notes (use `-f` to overwrite existing notes).
  65        However, if you're using `add` interactively (using an editor
  66        to supply the notes contents), then - instead of aborting -
  67        the existing notes will be opened in the editor (like the `edit`
  68        subcommand).
  69
  70copy::
  71        Copy the notes for the first object onto the second object.
  72        Abort if the second object already has notes, or if the first
  73        object has none (use -f to overwrite existing notes to the
  74        second object). This subcommand is equivalent to:
  75        `git notes add [-f] -C $(git notes list <from-object>) <to-object>`
  76+
  77In `--stdin` mode, take lines in the format
  78+
  79----------
  80<from-object> SP <to-object> [ SP <rest> ] LF
  81----------
  82+
  83on standard input, and copy the notes from each <from-object> to its
  84corresponding <to-object>.  (The optional `<rest>` is ignored so that
  85the command can read the input given to the `post-rewrite` hook.)
  86
  87append::
  88        Append to the notes of an existing object (defaults to HEAD).
  89        Creates a new notes object if needed.
  90
  91edit::
  92        Edit the notes for a given object (defaults to HEAD).
  93
  94show::
  95        Show the notes for a given object (defaults to HEAD).
  96
  97merge::
  98        Merge the given notes ref into the current notes ref.
  99        This will try to merge the changes made by the given
 100        notes ref (called "remote") since the merge-base (if
 101        any) into the current notes ref (called "local").
 102+
 103If conflicts arise and a strategy for automatically resolving
 104conflicting notes (see the -s/--strategy option) is not given,
 105the "manual" resolver is used. This resolver checks out the
 106conflicting notes in a special worktree (`.git/NOTES_MERGE_WORKTREE`),
 107and instructs the user to manually resolve the conflicts there.
 108When done, the user can either finalize the merge with
 109'git notes merge --commit', or abort the merge with
 110'git notes merge --abort'.
 111
 112remove::
 113        Remove the notes for given objects (defaults to HEAD). When
 114        giving zero or one object from the command line, this is
 115        equivalent to specifying an empty note message to
 116        the `edit` subcommand.
 117
 118prune::
 119        Remove all notes for non-existing/unreachable objects.
 120
 121get-ref::
 122        Print the current notes ref. This provides an easy way to
 123        retrieve the current notes ref (e.g. from scripts).
 124
 125OPTIONS
 126-------
 127-f::
 128--force::
 129        When adding notes to an object that already has notes,
 130        overwrite the existing notes (instead of aborting).
 131
 132-m <msg>::
 133--message=<msg>::
 134        Use the given note message (instead of prompting).
 135        If multiple `-m` options are given, their values
 136        are concatenated as separate paragraphs.
 137        Lines starting with `#` and empty lines other than a
 138        single line between paragraphs will be stripped out.
 139
 140-F <file>::
 141--file=<file>::
 142        Take the note message from the given file.  Use '-' to
 143        read the note message from the standard input.
 144        Lines starting with `#` and empty lines other than a
 145        single line between paragraphs will be stripped out.
 146
 147-C <object>::
 148--reuse-message=<object>::
 149        Take the given blob object (for example, another note) as the
 150        note message. (Use `git notes copy <object>` instead to
 151        copy notes between objects.)
 152
 153-c <object>::
 154--reedit-message=<object>::
 155        Like '-C', but with '-c' the editor is invoked, so that
 156        the user can further edit the note message.
 157
 158--ref <ref>::
 159        Manipulate the notes tree in <ref>.  This overrides
 160        'GIT_NOTES_REF' and the "core.notesRef" configuration.  The ref
 161        is taken to be in `refs/notes/` if it is not qualified.
 162
 163--ignore-missing::
 164        Do not consider it an error to request removing notes from an
 165        object that does not have notes attached to it.
 166
 167--stdin::
 168        Also read the object names to remove notes from from the standard
 169        input (there is no reason you cannot combine this with object
 170        names from the command line).
 171
 172-n::
 173--dry-run::
 174        Do not remove anything; just report the object names whose notes
 175        would be removed.
 176
 177-s <strategy>::
 178--strategy=<strategy>::
 179        When merging notes, resolve notes conflicts using the given
 180        strategy. The following strategies are recognized: "manual"
 181        (default), "ours", "theirs", "union" and "cat_sort_uniq".
 182        See the "NOTES MERGE STRATEGIES" section below for more
 183        information on each notes merge strategy.
 184
 185--commit::
 186        Finalize an in-progress 'git notes merge'. Use this option
 187        when you have resolved the conflicts that 'git notes merge'
 188        stored in .git/NOTES_MERGE_WORKTREE. This amends the partial
 189        merge commit created by 'git notes merge' (stored in
 190        .git/NOTES_MERGE_PARTIAL) by adding the notes in
 191        .git/NOTES_MERGE_WORKTREE. The notes ref stored in the
 192        .git/NOTES_MERGE_REF symref is updated to the resulting commit.
 193
 194--abort::
 195        Abort/reset a in-progress 'git notes merge', i.e. a notes merge
 196        with conflicts. This simply removes all files related to the
 197        notes merge.
 198
 199-q::
 200--quiet::
 201        When merging notes, operate quietly.
 202
 203-v::
 204--verbose::
 205        When merging notes, be more verbose.
 206        When pruning notes, report all object names whose notes are
 207        removed.
 208
 209
 210DISCUSSION
 211----------
 212
 213Commit notes are blobs containing extra information about an object
 214(usually information to supplement a commit's message).  These blobs
 215are taken from notes refs.  A notes ref is usually a branch which
 216contains "files" whose paths are the object names for the objects
 217they describe, with some directory separators included for performance
 218reasons footnote:[Permitted pathnames have the form
 219'ab'`/`'cd'`/`'ef'`/`'...'`/`'abcdef...': a sequence of directory
 220names of two hexadecimal digits each followed by a filename with the
 221rest of the object ID.].
 222
 223Every notes change creates a new commit at the specified notes ref.
 224You can therefore inspect the history of the notes by invoking, e.g.,
 225`git log -p notes/commits`.  Currently the commit message only records
 226which operation triggered the update, and the commit authorship is
 227determined according to the usual rules (see linkgit:git-commit[1]).
 228These details may change in the future.
 229
 230It is also permitted for a notes ref to point directly to a tree
 231object, in which case the history of the notes can be read with
 232`git log -p -g <refname>`.
 233
 234
 235NOTES MERGE STRATEGIES
 236----------------------
 237
 238The default notes merge strategy is "manual", which checks out
 239conflicting notes in a special work tree for resolving notes conflicts
 240(`.git/NOTES_MERGE_WORKTREE`), and instructs the user to resolve the
 241conflicts in that work tree.
 242When done, the user can either finalize the merge with
 243'git notes merge --commit', or abort the merge with
 244'git notes merge --abort'.
 245
 246"ours" automatically resolves conflicting notes in favor of the local
 247version (i.e. the current notes ref).
 248
 249"theirs" automatically resolves notes conflicts in favor of the remote
 250version (i.e. the given notes ref being merged into the current notes
 251ref).
 252
 253"union" automatically resolves notes conflicts by concatenating the
 254local and remote versions.
 255
 256"cat_sort_uniq" is similar to "union", but in addition to concatenating
 257the local and remote versions, this strategy also sorts the resulting
 258lines, and removes duplicate lines from the result. This is equivalent
 259to applying the "cat | sort | uniq" shell pipeline to the local and
 260remote versions. This strategy is useful if the notes follow a line-based
 261format where one wants to avoid duplicated lines in the merge result.
 262Note that if either the local or remote version contain duplicate lines
 263prior to the merge, these will also be removed by this notes merge
 264strategy.
 265
 266
 267EXAMPLES
 268--------
 269
 270You can use notes to add annotations with information that was not
 271available at the time a commit was written.
 272
 273------------
 274$ git notes add -m 'Tested-by: Johannes Sixt <j6t@kdbg.org>' 72a144e2
 275$ git show -s 72a144e
 276[...]
 277    Signed-off-by: Junio C Hamano <gitster@pobox.com>
 278
 279Notes:
 280    Tested-by: Johannes Sixt <j6t@kdbg.org>
 281------------
 282
 283In principle, a note is a regular Git blob, and any kind of
 284(non-)format is accepted.  You can binary-safely create notes from
 285arbitrary files using 'git hash-object':
 286
 287------------
 288$ cc *.c
 289$ blob=$(git hash-object -w a.out)
 290$ git notes --ref=built add -C "$blob" HEAD
 291------------
 292
 293(You cannot simply use `git notes --ref=built add -F a.out HEAD`
 294because that is not binary-safe.)
 295Of course, it doesn't make much sense to display non-text-format notes
 296with 'git log', so if you use such notes, you'll probably need to write
 297some special-purpose tools to do something useful with them.
 298
 299
 300CONFIGURATION
 301-------------
 302
 303core.notesRef::
 304        Notes ref to read and manipulate instead of
 305        `refs/notes/commits`.  Must be an unabbreviated ref name.
 306        This setting can be overridden through the environment and
 307        command line.
 308
 309notes.displayRef::
 310        Which ref (or refs, if a glob or specified more than once), in
 311        addition to the default set by `core.notesRef` or
 312        'GIT_NOTES_REF', to read notes from when showing commit
 313        messages with the 'git log' family of commands.
 314        This setting can be overridden on the command line or by the
 315        'GIT_NOTES_DISPLAY_REF' environment variable.
 316        See linkgit:git-log[1].
 317
 318notes.rewrite.<command>::
 319        When rewriting commits with <command> (currently `amend` or
 320        `rebase`), if this variable is `false`, git will not copy
 321        notes from the original to the rewritten commit.  Defaults to
 322        `true`.  See also "`notes.rewriteRef`" below.
 323+
 324This setting can be overridden by the 'GIT_NOTES_REWRITE_REF'
 325environment variable.
 326
 327notes.rewriteMode::
 328        When copying notes during a rewrite, what to do if the target
 329        commit already has a note.  Must be one of `overwrite`,
 330        `concatenate`, and `ignore`.  Defaults to `concatenate`.
 331+
 332This setting can be overridden with the `GIT_NOTES_REWRITE_MODE`
 333environment variable.
 334
 335notes.rewriteRef::
 336        When copying notes during a rewrite, specifies the (fully
 337        qualified) ref whose notes should be copied.  May be a glob,
 338        in which case notes in all matching refs will be copied.  You
 339        may also specify this configuration several times.
 340+
 341Does not have a default value; you must configure this variable to
 342enable note rewriting.
 343+
 344Can be overridden with the 'GIT_NOTES_REWRITE_REF' environment variable.
 345
 346
 347ENVIRONMENT
 348-----------
 349
 350'GIT_NOTES_REF'::
 351        Which ref to manipulate notes from, instead of `refs/notes/commits`.
 352        This overrides the `core.notesRef` setting.
 353
 354'GIT_NOTES_DISPLAY_REF'::
 355        Colon-delimited list of refs or globs indicating which refs,
 356        in addition to the default from `core.notesRef` or
 357        'GIT_NOTES_REF', to read notes from when showing commit
 358        messages.
 359        This overrides the `notes.displayRef` setting.
 360+
 361A warning will be issued for refs that do not exist, but a glob that
 362does not match any refs is silently ignored.
 363
 364'GIT_NOTES_REWRITE_MODE'::
 365        When copying notes during a rewrite, what to do if the target
 366        commit already has a note.
 367        Must be one of `overwrite`, `concatenate`, and `ignore`.
 368        This overrides the `core.rewriteMode` setting.
 369
 370'GIT_NOTES_REWRITE_REF'::
 371        When rewriting commits, which notes to copy from the original
 372        to the rewritten commit.  Must be a colon-delimited list of
 373        refs or globs.
 374+
 375If not set in the environment, the list of notes to copy depends
 376on the `notes.rewrite.<command>` and `notes.rewriteRef` settings.
 377
 378
 379Author
 380------
 381Written by Johannes Schindelin <johannes.schindelin@gmx.de> and
 382Johan Herland <johan@herland.net>
 383
 384Documentation
 385-------------
 386Documentation by Johannes Schindelin and Johan Herland
 387
 388GIT
 389---
 390Part of the linkgit:git[7] suite