mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Notes API: get_commit_notes() -> format_note() + remove the commit restriction

Browse Source 
There is really no reason why only commit objects can be annotated. By
changing the struct commit parameter to get_commit_notes() into a sha1 we
gain the ability to annotate any object type. To reflect this in the function
naming as well, we rename get_commit_notes() to format_note().

This patch also fixes comments and variable names throughout notes.c as a
consequence of the removal of the unnecessary 'commit' restriction.

Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Johan Herland
2010-02-13 22:28:10 +01:00
committed by Junio C Hamano
parent 0ab1faae39
commit a7e7eff662
3 changed files with 30 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
notes.c
View File

@ -1,5 +1,4 @@
#include "cache.h" #include "cache.h"
#include "commit.h"
#include "notes.h" #include "notes.h"
#include "utf8.h" #include "utf8.h"
#include "strbuf.h" #include "strbuf.h"
@ -24,10 +23,10 @@ struct int_node {
/* /*
* Leaf nodes come in two variants, note entries and subtree entries, * Leaf nodes come in two variants, note entries and subtree entries,
* distinguished by the LSb of the leaf node pointer (see above). * distinguished by the LSb of the leaf node pointer (see above).
* As a note entry, the key is the SHA1 of the referenced commit, and the * As a note entry, the key is the SHA1 of the referenced object, and the
* value is the SHA1 of the note object. * value is the SHA1 of the note object.
* As a subtree entry, the key is the prefix SHA1 (w/trailing NULs) of the * As a subtree entry, the key is the prefix SHA1 (w/trailing NULs) of the
* referenced commit, using the last byte of the key to store the length of * referenced object, using the last byte of the key to store the length of
* the prefix. The value is the SHA1 of the tree object containing the notes * the prefix. The value is the SHA1 of the tree object containing the notes
* subtree. * subtree.
*/ */
@ -210,7 +209,7 @@ static void note_tree_insert(struct int_node *tree, unsigned char n,
if (concatenate_notes(l->val_sha1, if (concatenate_notes(l->val_sha1,
entry->val_sha1)) entry->val_sha1))
die("failed to concatenate note %s " die("failed to concatenate note %s "
"into note %s for commit %s", "into note %s for object %s",
sha1_to_hex(entry->val_sha1), sha1_to_hex(entry->val_sha1),
sha1_to_hex(l->val_sha1), sha1_to_hex(l->val_sha1),
sha1_to_hex(l->key_sha1)); sha1_to_hex(l->key_sha1));
@ -298,7 +297,7 @@ static int get_sha1_hex_segment(const char *hex, unsigned int hex_len,
static void load_subtree(struct leaf_node *subtree, struct int_node *node, static void load_subtree(struct leaf_node *subtree, struct int_node *node,
unsigned int n) unsigned int n)
{ {
unsigned char commit_sha1[20]; unsigned char object_sha1[20];
unsigned int prefix_len; unsigned int prefix_len;
void *buf; void *buf;
struct tree_desc desc; struct tree_desc desc;
@ -311,23 +310,23 @@ static void load_subtree(struct leaf_node *subtree, struct int_node *node,
prefix_len = subtree->key_sha1[19]; prefix_len = subtree->key_sha1[19];
assert(prefix_len * 2 >= n); assert(prefix_len * 2 >= n);
memcpy(commit_sha1, subtree->key_sha1, prefix_len); memcpy(object_sha1, subtree->key_sha1, prefix_len);
while (tree_entry(&desc, &entry)) { while (tree_entry(&desc, &entry)) {
int len = get_sha1_hex_segment(entry.path, strlen(entry.path), int len = get_sha1_hex_segment(entry.path, strlen(entry.path),
commit_sha1 + prefix_len, 20 - prefix_len); object_sha1 + prefix_len, 20 - prefix_len);
if (len < 0) if (len < 0)
continue; /* entry.path is not a SHA1 sum. Skip */ continue; /* entry.path is not a SHA1 sum. Skip */
len += prefix_len; len += prefix_len;
/* /*
* If commit SHA1 is complete (len == 20), assume note object * If object SHA1 is complete (len == 20), assume note object
* If commit SHA1 is incomplete (len < 20), assume note subtree * If object SHA1 is incomplete (len < 20), assume note subtree
*/ */
if (len <= 20) { if (len <= 20) {
unsigned char type = PTR_TYPE_NOTE; unsigned char type = PTR_TYPE_NOTE;
struct leaf_node *l = (struct leaf_node *) struct leaf_node *l = (struct leaf_node *)
xcalloc(sizeof(struct leaf_node), 1); xcalloc(sizeof(struct leaf_node), 1);
hashcpy(l->key_sha1, commit_sha1); hashcpy(l->key_sha1, object_sha1);
hashcpy(l->val_sha1, entry.sha1); hashcpy(l->val_sha1, entry.sha1);
if (len < 20) { if (len < 20) {
if (!S_ISDIR(entry.mode)) if (!S_ISDIR(entry.mode))
@ -343,12 +342,12 @@ static void load_subtree(struct leaf_node *subtree, struct int_node *node,
static void initialize_notes(const char *notes_ref_name) static void initialize_notes(const char *notes_ref_name)
{ {
unsigned char sha1[20], commit_sha1[20]; unsigned char sha1[20], object_sha1[20];
unsigned mode; unsigned mode;
struct leaf_node root_tree; struct leaf_node root_tree;
if (!notes_ref_name || read_ref(notes_ref_name, commit_sha1) || if (!notes_ref_name || read_ref(notes_ref_name, object_sha1) ||
get_tree_entry(commit_sha1, "", sha1, &mode)) get_tree_entry(object_sha1, "", sha1, &mode))
return; return;
hashclr(root_tree.key_sha1); hashclr(root_tree.key_sha1);
@ -356,9 +355,9 @@ static void initialize_notes(const char *notes_ref_name)
load_subtree(&root_tree, &root_node, 0); load_subtree(&root_tree, &root_node, 0);
} }
static unsigned char *lookup_notes(const unsigned char *commit_sha1) static unsigned char *lookup_notes(const unsigned char *object_sha1)
{ {
struct leaf_node *found = note_tree_find(&root_node, 0, commit_sha1); struct leaf_node *found = note_tree_find(&root_node, 0, object_sha1);
if (found) if (found)
return found->val_sha1; return found->val_sha1;
return NULL; return NULL;
@ -371,7 +370,7 @@ void free_notes(void)
initialized = 0; initialized = 0;
} }
void get_commit_notes(const struct commit *commit, struct strbuf *sb, void format_note(const unsigned char *object_sha1, struct strbuf *sb,
const char *output_encoding, int flags) const char *output_encoding, int flags)
{ {
static const char utf8[] = "utf-8"; static const char utf8[] = "utf-8";
@ -390,7 +389,7 @@ void get_commit_notes(const struct commit *commit, struct strbuf *sb,
initialized = 1; initialized = 1;
} }
sha1 = lookup_notes(commit->object.sha1); sha1 = lookup_notes(object_sha1);
if (!sha1) if (!sha1)
return; return;

11
notes.h
View File

@ -4,10 +4,19 @@
/* Free (and de-initialize) the internal notes tree structure */ /* Free (and de-initialize) the internal notes tree structure */
void free_notes(void); void free_notes(void);
/* Flags controlling how notes are formatted */
#define NOTES_SHOW_HEADER 1 #define NOTES_SHOW_HEADER 1
#define NOTES_INDENT 2 #define NOTES_INDENT 2
void get_commit_notes(const struct commit *commit, struct strbuf *sb, /*
* Fill the given strbuf with the notes associated with the given object.
*
* If the internal notes structure is not initialized, it will be auto-
* initialized to the default value (see documentation for init_notes() above).
*
* 'flags' is a bitwise combination of the above formatting flags.
*/
void format_note(const unsigned char *object_sha1, struct strbuf *sb,
const char *output_encoding, int flags); const char *output_encoding, int flags);
#endif #endif

4
pretty.c
View File

@ -775,7 +775,7 @@ static size_t format_commit_one(struct strbuf *sb, const char *placeholder,
} }
return 0; /* unknown %g placeholder */ return 0; /* unknown %g placeholder */
case 'N': case 'N':
get_commit_notes(commit, sb, git_log_output_encoding ? format_note(commit->object.sha1, sb, git_log_output_encoding ?
git_log_output_encoding : git_commit_encoding, 0); git_log_output_encoding : git_commit_encoding, 0);
return 1; return 1;
} }
@ -1095,7 +1095,7 @@ void pretty_print_commit(enum cmit_fmt fmt, const struct commit *commit,
strbuf_addch(sb, '\n'); strbuf_addch(sb, '\n');
if (context->show_notes) if (context->show_notes)
get_commit_notes(commit, sb, encoding, format_note(commit->object.sha1, sb, encoding,
NOTES_SHOW_HEADER | NOTES_INDENT); NOTES_SHOW_HEADER | NOTES_INDENT);
free(reencoded); free(reencoded);