Documentation / git-notes.txton commit Merge branch 'dl/subtree-avoid-tricky-echo' (b54301b)
   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] [--allow-empty] [-F <file> | -m <msg> | (-c | -C) <object>] [<object>]
  13'git notes' copy [-f] ( --stdin | <from-object> <to-object> )
  14'git notes' append [--allow-empty] [-F <file> | -m <msg> | (-c | -C) <object>] [<object>]
  15'git notes' edit [--allow-empty] [<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--allow-empty::
 159        Allow an empty note object to be stored. The default behavior is
 160        to automatically remove empty notes.
 161
 162--ref <ref>::
 163        Manipulate the notes tree in <ref>.  This overrides
 164        'GIT_NOTES_REF' and the "core.notesRef" configuration.  The ref
 165        is taken to be in `refs/notes/` if it is not qualified.
 166
 167--ignore-missing::
 168        Do not consider it an error to request removing notes from an
 169        object that does not have notes attached to it.
 170
 171--stdin::
 172        Also read the object names to remove notes from from the standard
 173        input (there is no reason you cannot combine this with object
 174        names from the command line).
 175
 176-n::
 177--dry-run::
 178        Do not remove anything; just report the object names whose notes
 179        would be removed.
 180
 181-s <strategy>::
 182--strategy=<strategy>::
 183        When merging notes, resolve notes conflicts using the given
 184        strategy. The following strategies are recognized: "manual"
 185        (default), "ours", "theirs", "union" and "cat_sort_uniq".
 186        See the "NOTES MERGE STRATEGIES" section below for more
 187        information on each notes merge strategy.
 188
 189--commit::
 190        Finalize an in-progress 'git notes merge'. Use this option
 191        when you have resolved the conflicts that 'git notes merge'
 192        stored in .git/NOTES_MERGE_WORKTREE. This amends the partial
 193        merge commit created by 'git notes merge' (stored in
 194        .git/NOTES_MERGE_PARTIAL) by adding the notes in
 195        .git/NOTES_MERGE_WORKTREE. The notes ref stored in the
 196        .git/NOTES_MERGE_REF symref is updated to the resulting commit.
 197
 198--abort::
 199        Abort/reset a in-progress 'git notes merge', i.e. a notes merge
 200        with conflicts. This simply removes all files related to the
 201        notes merge.
 202
 203-q::
 204--quiet::
 205        When merging notes, operate quietly.
 206
 207-v::
 208--verbose::
 209        When merging notes, be more verbose.
 210        When pruning notes, report all object names whose notes are
 211        removed.
 212
 213
 214DISCUSSION
 215----------
 216
 217Commit notes are blobs containing extra information about an object
 218(usually information to supplement a commit's message).  These blobs
 219are taken from notes refs.  A notes ref is usually a branch which
 220contains "files" whose paths are the object names for the objects
 221they describe, with some directory separators included for performance
 222reasons footnote:[Permitted pathnames have the form
 223'ab'`/`'cd'`/`'ef'`/`'...'`/`'abcdef...': a sequence of directory
 224names of two hexadecimal digits each followed by a filename with the
 225rest of the object ID.].
 226
 227Every notes change creates a new commit at the specified notes ref.
 228You can therefore inspect the history of the notes by invoking, e.g.,
 229`git log -p notes/commits`.  Currently the commit message only records
 230which operation triggered the update, and the commit authorship is
 231determined according to the usual rules (see linkgit:git-commit[1]).
 232These details may change in the future.
 233
 234It is also permitted for a notes ref to point directly to a tree
 235object, in which case the history of the notes can be read with
 236`git log -p -g <refname>`.
 237
 238
 239NOTES MERGE STRATEGIES
 240----------------------
 241
 242The default notes merge strategy is "manual", which checks out
 243conflicting notes in a special work tree for resolving notes conflicts
 244(`.git/NOTES_MERGE_WORKTREE`), and instructs the user to resolve the
 245conflicts in that work tree.
 246When done, the user can either finalize the merge with
 247'git notes merge --commit', or abort the merge with
 248'git notes merge --abort'.
 249
 250"ours" automatically resolves conflicting notes in favor of the local
 251version (i.e. the current notes ref).
 252
 253"theirs" automatically resolves notes conflicts in favor of the remote
 254version (i.e. the given notes ref being merged into the current notes
 255ref).
 256
 257"union" automatically resolves notes conflicts by concatenating the
 258local and remote versions.
 259
 260"cat_sort_uniq" is similar to "union", but in addition to concatenating
 261the local and remote versions, this strategy also sorts the resulting
 262lines, and removes duplicate lines from the result. This is equivalent
 263to applying the "cat | sort | uniq" shell pipeline to the local and
 264remote versions. This strategy is useful if the notes follow a line-based
 265format where one wants to avoid duplicated lines in the merge result.
 266Note that if either the local or remote version contain duplicate lines
 267prior to the merge, these will also be removed by this notes merge
 268strategy.
 269
 270
 271EXAMPLES
 272--------
 273
 274You can use notes to add annotations with information that was not
 275available at the time a commit was written.
 276
 277------------
 278$ git notes add -m 'Tested-by: Johannes Sixt <j6t@kdbg.org>' 72a144e2
 279$ git show -s 72a144e
 280[...]
 281    Signed-off-by: Junio C Hamano <gitster@pobox.com>
 282
 283Notes:
 284    Tested-by: Johannes Sixt <j6t@kdbg.org>
 285------------
 286
 287In principle, a note is a regular Git blob, and any kind of
 288(non-)format is accepted.  You can binary-safely create notes from
 289arbitrary files using 'git hash-object':
 290
 291------------
 292$ cc *.c
 293$ blob=$(git hash-object -w a.out)
 294$ git notes --ref=built add --allow-empty -C "$blob" HEAD
 295------------
 296
 297(You cannot simply use `git notes --ref=built add -F a.out HEAD`
 298because that is not binary-safe.)
 299Of course, it doesn't make much sense to display non-text-format notes
 300with 'git log', so if you use such notes, you'll probably need to write
 301some special-purpose tools to do something useful with them.
 302
 303
 304CONFIGURATION
 305-------------
 306
 307core.notesRef::
 308        Notes ref to read and manipulate instead of
 309        `refs/notes/commits`.  Must be an unabbreviated ref name.
 310        This setting can be overridden through the environment and
 311        command line.
 312
 313notes.displayRef::
 314        Which ref (or refs, if a glob or specified more than once), in
 315        addition to the default set by `core.notesRef` or
 316        'GIT_NOTES_REF', to read notes from when showing commit
 317        messages with the 'git log' family of commands.
 318        This setting can be overridden on the command line or by the
 319        'GIT_NOTES_DISPLAY_REF' environment variable.
 320        See linkgit:git-log[1].
 321
 322notes.rewrite.<command>::
 323        When rewriting commits with <command> (currently `amend` or
 324        `rebase`), if this variable is `false`, git will not copy
 325        notes from the original to the rewritten commit.  Defaults to
 326        `true`.  See also "`notes.rewriteRef`" below.
 327+
 328This setting can be overridden by the 'GIT_NOTES_REWRITE_REF'
 329environment variable.
 330
 331notes.rewriteMode::
 332        When copying notes during a rewrite, what to do if the target
 333        commit already has a note.  Must be one of `overwrite`,
 334        `concatenate`, and `ignore`.  Defaults to `concatenate`.
 335+
 336This setting can be overridden with the `GIT_NOTES_REWRITE_MODE`
 337environment variable.
 338
 339notes.rewriteRef::
 340        When copying notes during a rewrite, specifies the (fully
 341        qualified) ref whose notes should be copied.  May be a glob,
 342        in which case notes in all matching refs will be copied.  You
 343        may also specify this configuration several times.
 344+
 345Does not have a default value; you must configure this variable to
 346enable note rewriting.
 347+
 348Can be overridden with the 'GIT_NOTES_REWRITE_REF' environment variable.
 349
 350
 351ENVIRONMENT
 352-----------
 353
 354'GIT_NOTES_REF'::
 355        Which ref to manipulate notes from, instead of `refs/notes/commits`.
 356        This overrides the `core.notesRef` setting.
 357
 358'GIT_NOTES_DISPLAY_REF'::
 359        Colon-delimited list of refs or globs indicating which refs,
 360        in addition to the default from `core.notesRef` or
 361        'GIT_NOTES_REF', to read notes from when showing commit
 362        messages.
 363        This overrides the `notes.displayRef` setting.
 364+
 365A warning will be issued for refs that do not exist, but a glob that
 366does not match any refs is silently ignored.
 367
 368'GIT_NOTES_REWRITE_MODE'::
 369        When copying notes during a rewrite, what to do if the target
 370        commit already has a note.
 371        Must be one of `overwrite`, `concatenate`, and `ignore`.
 372        This overrides the `core.rewriteMode` setting.
 373
 374'GIT_NOTES_REWRITE_REF'::
 375        When rewriting commits, which notes to copy from the original
 376        to the rewritten commit.  Must be a colon-delimited list of
 377        refs or globs.
 378+
 379If not set in the environment, the list of notes to copy depends
 380on the `notes.rewrite.<command>` and `notes.rewriteRef` settings.
 381
 382GIT
 383---
 384Part of the linkgit:git[7] suite