THIS IS A TEST INSTANCE ONLY! REPOSITORIES CAN BE DELETED AT ANY TIME!

Git Source Code Mirror - This is a publish-only repository and all pull requests are ignored. Please follow Documentation/SubmittingPatches procedure for any of your improvements.
git
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

319 lines
12KB

  1. #ifndef NOTES_H
  2. #define NOTES_H
  3. #include "string-list.h"
  4. struct object_id;
  5. struct strbuf;
  6. /*
  7. * Function type for combining two notes annotating the same object.
  8. *
  9. * When adding a new note annotating the same object as an existing note, it is
  10. * up to the caller to decide how to combine the two notes. The decision is
  11. * made by passing in a function of the following form. The function accepts
  12. * two object_ids -- of the existing note and the new note, respectively. The
  13. * function then combines the notes in whatever way it sees fit, and writes the
  14. * resulting oid into the first argument (cur_oid). A non-zero return
  15. * value indicates failure.
  16. *
  17. * The two given object_ids shall both be non-NULL and different from each
  18. * other. Either of them (but not both) may be == null_oid, which indicates an
  19. * empty/non-existent note. If the resulting oid (cur_oid) is == null_oid,
  20. * the note will be removed from the notes tree.
  21. *
  22. * The default combine_notes function (you get this when passing NULL) is
  23. * combine_notes_concatenate(), which appends the contents of the new note to
  24. * the contents of the existing note.
  25. */
  26. typedef int (*combine_notes_fn)(struct object_id *cur_oid,
  27. const struct object_id *new_oid);
  28. /* Common notes combinators */
  29. int combine_notes_concatenate(struct object_id *cur_oid,
  30. const struct object_id *new_oid);
  31. int combine_notes_overwrite(struct object_id *cur_oid,
  32. const struct object_id *new_oid);
  33. int combine_notes_ignore(struct object_id *cur_oid,
  34. const struct object_id *new_oid);
  35. int combine_notes_cat_sort_uniq(struct object_id *cur_oid,
  36. const struct object_id *new_oid);
  37. /*
  38. * Notes tree object
  39. *
  40. * Encapsulates the internal notes tree structure associated with a notes ref.
  41. * Whenever a struct notes_tree pointer is required below, you may pass NULL in
  42. * order to use the default/internal notes tree. E.g. you only need to pass a
  43. * non-NULL value if you need to refer to several different notes trees
  44. * simultaneously.
  45. */
  46. extern struct notes_tree {
  47. struct int_node *root;
  48. struct non_note *first_non_note, *prev_non_note;
  49. char *ref;
  50. char *update_ref;
  51. combine_notes_fn combine_notes;
  52. int initialized;
  53. int dirty;
  54. } default_notes_tree;
  55. /*
  56. * Return the default notes ref.
  57. *
  58. * The default notes ref is the notes ref that is used when notes_ref == NULL
  59. * is passed to init_notes().
  60. *
  61. * This the first of the following to be defined:
  62. * 1. The '--ref' option to 'git notes', if given
  63. * 2. The $GIT_NOTES_REF environment variable, if set
  64. * 3. The value of the core.notesRef config variable, if set
  65. * 4. GIT_NOTES_DEFAULT_REF (i.e. "refs/notes/commits")
  66. */
  67. const char *default_notes_ref(void);
  68. /*
  69. * Flags controlling behaviour of notes tree initialization
  70. *
  71. * Default behaviour is to initialize the notes tree from the tree object
  72. * specified by the given (or default) notes ref.
  73. */
  74. #define NOTES_INIT_EMPTY 1
  75. /*
  76. * By default, the notes tree is only readable, and the notes ref can be
  77. * any treeish. The notes tree can however be made writable with this flag,
  78. * in which case only strict ref names can be used.
  79. */
  80. #define NOTES_INIT_WRITABLE 2
  81. /*
  82. * Initialize the given notes_tree with the notes tree structure at the given
  83. * ref. If given ref is NULL, the value of the $GIT_NOTES_REF environment
  84. * variable is used, and if that is missing, the default notes ref is used
  85. * ("refs/notes/commits").
  86. *
  87. * If you need to re-initialize a notes_tree structure (e.g. when switching from
  88. * one notes ref to another), you must first de-initialize the notes_tree
  89. * structure by calling free_notes(struct notes_tree *).
  90. *
  91. * If you pass t == NULL, the default internal notes_tree will be initialized.
  92. *
  93. * The combine_notes function that is passed becomes the default combine_notes
  94. * function for the given notes_tree. If NULL is passed, the default
  95. * combine_notes function is combine_notes_concatenate().
  96. *
  97. * Precondition: The notes_tree structure is zeroed (this can be achieved with
  98. * memset(t, 0, sizeof(struct notes_tree)))
  99. */
  100. void init_notes(struct notes_tree *t, const char *notes_ref,
  101. combine_notes_fn combine_notes, int flags);
  102. /*
  103. * Add the given note object to the given notes_tree structure
  104. *
  105. * If there already exists a note for the given object_sha1, the given
  106. * combine_notes function is invoked to break the tie. If not given (i.e.
  107. * combine_notes == NULL), the default combine_notes function for the given
  108. * notes_tree is used.
  109. *
  110. * Passing note_sha1 == null_sha1 indicates the addition of an
  111. * empty/non-existent note. This is a (potentially expensive) no-op unless
  112. * there already exists a note for the given object_sha1, AND combining that
  113. * note with the empty note (using the given combine_notes function) results
  114. * in a new/changed note.
  115. *
  116. * Returns zero on success; non-zero means combine_notes failed.
  117. *
  118. * IMPORTANT: The changes made by add_note() to the given notes_tree structure
  119. * are not persistent until a subsequent call to write_notes_tree() returns
  120. * zero.
  121. */
  122. int add_note(struct notes_tree *t, const struct object_id *object_oid,
  123. const struct object_id *note_oid, combine_notes_fn combine_notes);
  124. /*
  125. * Remove the given note object from the given notes_tree structure
  126. *
  127. * IMPORTANT: The changes made by remove_note() to the given notes_tree
  128. * structure are not persistent until a subsequent call to write_notes_tree()
  129. * returns zero.
  130. *
  131. * Return 0 if a note was removed; 1 if there was no note to remove.
  132. */
  133. int remove_note(struct notes_tree *t, const unsigned char *object_sha1);
  134. /*
  135. * Get the note object SHA1 containing the note data for the given object
  136. *
  137. * Return NULL if the given object has no notes.
  138. */
  139. const struct object_id *get_note(struct notes_tree *t,
  140. const struct object_id *object_oid);
  141. /*
  142. * Copy a note from one object to another in the given notes_tree.
  143. *
  144. * Returns 1 if the to_obj already has a note and 'force' is false. Otherwise,
  145. * returns non-zero if 'force' is true, but the given combine_notes function
  146. * failed to combine from_obj's note with to_obj's existing note.
  147. * Returns zero on success.
  148. *
  149. * IMPORTANT: The changes made by copy_note() to the given notes_tree structure
  150. * are not persistent until a subsequent call to write_notes_tree() returns
  151. * zero.
  152. */
  153. int copy_note(struct notes_tree *t,
  154. const struct object_id *from_obj, const struct object_id *to_obj,
  155. int force, combine_notes_fn combine_notes);
  156. /*
  157. * Flags controlling behaviour of for_each_note()
  158. *
  159. * Default behaviour of for_each_note() is to traverse every single note object
  160. * in the given notes tree, unpacking subtree entries along the way.
  161. * The following flags can be used to alter the default behaviour:
  162. *
  163. * - DONT_UNPACK_SUBTREES causes for_each_note() NOT to unpack and recurse into
  164. * subtree entries while traversing the notes tree. This causes notes within
  165. * those subtrees NOT to be passed to the callback. Use this flag if you
  166. * don't want to traverse _all_ notes, but only want to traverse the parts
  167. * of the notes tree that have already been unpacked (this includes at least
  168. * all notes that have been added/changed).
  169. *
  170. * - YIELD_SUBTREES causes any subtree entries that are encountered to be
  171. * passed to the callback, before recursing into them. Subtree entries are
  172. * not note objects, but represent intermediate directories in the notes
  173. * tree. When passed to the callback, subtree entries will have a trailing
  174. * slash in their path, which the callback may use to differentiate between
  175. * note entries and subtree entries. Note that already-unpacked subtree
  176. * entries are not part of the notes tree, and will therefore not be yielded.
  177. * If this flag is used together with DONT_UNPACK_SUBTREES, for_each_note()
  178. * will yield the subtree entry, but not recurse into it.
  179. */
  180. #define FOR_EACH_NOTE_DONT_UNPACK_SUBTREES 1
  181. #define FOR_EACH_NOTE_YIELD_SUBTREES 2
  182. /*
  183. * Invoke the specified callback function for each note in the given notes_tree
  184. *
  185. * If the callback returns nonzero, the note walk is aborted, and the return
  186. * value from the callback is returned from for_each_note(). Hence, a zero
  187. * return value from for_each_note() indicates that all notes were walked
  188. * successfully.
  189. *
  190. * IMPORTANT: The callback function is NOT allowed to change the notes tree.
  191. * In other words, the following functions can NOT be invoked (on the current
  192. * notes tree) from within the callback:
  193. * - add_note()
  194. * - remove_note()
  195. * - copy_note()
  196. * - free_notes()
  197. */
  198. typedef int each_note_fn(const struct object_id *object_oid,
  199. const struct object_id *note_oid, char *note_path,
  200. void *cb_data);
  201. int for_each_note(struct notes_tree *t, int flags, each_note_fn fn,
  202. void *cb_data);
  203. /*
  204. * Write the given notes_tree structure to the object database
  205. *
  206. * Creates a new tree object encapsulating the current state of the given
  207. * notes_tree, and stores its object id into the 'result' argument.
  208. *
  209. * Returns zero on success, non-zero on failure.
  210. *
  211. * IMPORTANT: Changes made to the given notes_tree are not persistent until
  212. * this function has returned zero. Please also remember to create a
  213. * corresponding commit object, and update the appropriate notes ref.
  214. */
  215. int write_notes_tree(struct notes_tree *t, struct object_id *result);
  216. /* Flags controlling the operation of prune */
  217. #define NOTES_PRUNE_VERBOSE 1
  218. #define NOTES_PRUNE_DRYRUN 2
  219. /*
  220. * Remove all notes annotating non-existing objects from the given notes tree
  221. *
  222. * All notes in the given notes_tree that are associated with objects that no
  223. * longer exist in the database, are removed from the notes tree.
  224. *
  225. * IMPORTANT: The changes made by prune_notes() to the given notes_tree
  226. * structure are not persistent until a subsequent call to write_notes_tree()
  227. * returns zero.
  228. */
  229. void prune_notes(struct notes_tree *t, int flags);
  230. /*
  231. * Free (and de-initialize) the given notes_tree structure
  232. *
  233. * IMPORTANT: Changes made to the given notes_tree since the last, successful
  234. * call to write_notes_tree() will be lost.
  235. */
  236. void free_notes(struct notes_tree *t);
  237. struct string_list;
  238. struct display_notes_opt {
  239. int use_default_notes;
  240. struct string_list extra_notes_refs;
  241. };
  242. /*
  243. * Load the notes machinery for displaying several notes trees.
  244. *
  245. * If 'opt' is not NULL, then it specifies additional settings for the
  246. * displaying:
  247. *
  248. * - suppress_default_notes indicates that the notes from
  249. * core.notesRef and notes.displayRef should not be loaded.
  250. *
  251. * - extra_notes_refs may contain a list of globs (in the same style
  252. * as notes.displayRef) where notes should be loaded from.
  253. */
  254. void init_display_notes(struct display_notes_opt *opt);
  255. /*
  256. * Append notes for the given 'object_sha1' from all trees set up by
  257. * init_display_notes() to 'sb'.
  258. *
  259. * If 'raw' is false the note will be indented by 4 places and
  260. * a 'Notes (refname):' header added.
  261. *
  262. * You *must* call init_display_notes() before using this function.
  263. */
  264. void format_display_notes(const struct object_id *object_oid,
  265. struct strbuf *sb, const char *output_encoding, int raw);
  266. /*
  267. * Load the notes tree from each ref listed in 'refs'. The output is
  268. * an array of notes_tree*, terminated by a NULL.
  269. */
  270. struct notes_tree **load_notes_trees(struct string_list *refs, int flags);
  271. /*
  272. * Add all refs that match 'glob' to the 'list'.
  273. */
  274. void string_list_add_refs_by_glob(struct string_list *list, const char *glob);
  275. /*
  276. * Add all refs from a colon-separated glob list 'globs' to the end of
  277. * 'list'. Empty components are ignored. This helper is used to
  278. * parse GIT_NOTES_DISPLAY_REF style environment variables.
  279. */
  280. void string_list_add_refs_from_colon_sep(struct string_list *list,
  281. const char *globs);
  282. /* Expand inplace a note ref like "foo" or "notes/foo" into "refs/notes/foo" */
  283. void expand_notes_ref(struct strbuf *sb);
  284. /*
  285. * Similar to expand_notes_ref, but will check whether the ref can be located
  286. * via get_sha1 first, and only falls back to expand_notes_ref in the case
  287. * where get_sha1 fails.
  288. */
  289. void expand_loose_notes_ref(struct strbuf *sb);
  290. #endif