[thirdparty/git.git] / blame.c

#include "cache.h"
#include "refs.h"
#include "cache-tree.h"
#include "blame.h"

void blame_origin_decref(struct blame_origin *o)
{
	if (o && --o->refcnt <= 0) {
		struct blame_origin *p, *l = NULL;
		if (o->previous)
			blame_origin_decref(o->previous);
		free(o->file.ptr);
		/* Should be present exactly once in commit chain */
		for (p = o->commit->util; p; l = p, p = p->next) {
			if (p == o) {
				if (l)
					l->next = p->next;
				else
					o->commit->util = p->next;
				free(o);
				return;
			}
		}
		die("internal error in blame_origin_decref");
	}
}

/*
 * Given a commit and a path in it, create a new origin structure.
 * The callers that add blame to the scoreboard should use
 * get_origin() to obtain shared, refcounted copy instead of calling
 * this function directly.
 */
static struct blame_origin *make_origin(struct commit *commit, const char *path)
{
	struct blame_origin *o;
	FLEX_ALLOC_STR(o, path, path);
	o->commit = commit;
	o->refcnt = 1;
	o->next = commit->util;
	commit->util = o;
	return o;
}

/*
 * Locate an existing origin or create a new one.
 * This moves the origin to front position in the commit util list.
 */
struct blame_origin *get_origin(struct commit *commit, const char *path)
{
	struct blame_origin *o, *l;

	for (o = commit->util, l = NULL; o; l = o, o = o->next) {
		if (!strcmp(o->path, path)) {
			/* bump to front */
			if (l) {
				l->next = o->next;
				o->next = commit->util;
				commit->util = o;
			}
			return blame_origin_incref(o);
		}
	}
	return make_origin(commit, path);
}


static void verify_working_tree_path(struct commit *work_tree, const char *path)
{
	struct commit_list *parents;
	int pos;

	for (parents = work_tree->parents; parents; parents = parents->next) {
		const struct object_id *commit_oid = &parents->item->object.oid;
		struct object_id blob_oid;
		unsigned mode;

		if (!get_tree_entry(commit_oid->hash, path, blob_oid.hash, &mode) &&
		    sha1_object_info(blob_oid.hash, NULL) == OBJ_BLOB)
			return;
	}

	pos = cache_name_pos(path, strlen(path));
	if (pos >= 0)
		; /* path is in the index */
	else if (-1 - pos < active_nr &&
		 !strcmp(active_cache[-1 - pos]->name, path))
		; /* path is in the index, unmerged */
	else
		die("no such path '%s' in HEAD", path);
}

static struct commit_list **append_parent(struct commit_list **tail, const struct object_id *oid)
{
	struct commit *parent;

	parent = lookup_commit_reference(oid->hash);
	if (!parent)
		die("no such commit %s", oid_to_hex(oid));
	return &commit_list_insert(parent, tail)->next;
}

static void append_merge_parents(struct commit_list **tail)
{
	int merge_head;
	struct strbuf line = STRBUF_INIT;

	merge_head = open(git_path_merge_head(), O_RDONLY);
	if (merge_head < 0) {
		if (errno == ENOENT)
			return;
		die("cannot open '%s' for reading", git_path_merge_head());
	}

	while (!strbuf_getwholeline_fd(&line, merge_head, '\n')) {
		struct object_id oid;
		if (line.len < GIT_SHA1_HEXSZ || get_oid_hex(line.buf, &oid))
			die("unknown line in '%s': %s", git_path_merge_head(), line.buf);
		tail = append_parent(tail, &oid);
	}
	close(merge_head);
	strbuf_release(&line);
}

/*
 * This isn't as simple as passing sb->buf and sb->len, because we
 * want to transfer ownership of the buffer to the commit (so we
 * must use detach).
 */
static void set_commit_buffer_from_strbuf(struct commit *c, struct strbuf *sb)
{
	size_t len;
	void *buf = strbuf_detach(sb, &len);
	set_commit_buffer(c, buf, len);
}

/*
 * Prepare a dummy commit that represents the work tree (or staged) item.
 * Note that annotating work tree item never works in the reverse.
 */
struct commit *fake_working_tree_commit(struct diff_options *opt,
					const char *path,
					const char *contents_from)
{
	struct commit *commit;
	struct blame_origin *origin;
	struct commit_list **parent_tail, *parent;
	struct object_id head_oid;
	struct strbuf buf = STRBUF_INIT;
	const char *ident;
	time_t now;
	int size, len;
	struct cache_entry *ce;
	unsigned mode;
	struct strbuf msg = STRBUF_INIT;

	read_cache();
	time(&now);
	commit = alloc_commit_node();
	commit->object.parsed = 1;
	commit->date = now;
	parent_tail = &commit->parents;

	if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, head_oid.hash, NULL))
		die("no such ref: HEAD");

	parent_tail = append_parent(parent_tail, &head_oid);
	append_merge_parents(parent_tail);
	verify_working_tree_path(commit, path);

	origin = make_origin(commit, path);

	ident = fmt_ident("Not Committed Yet", "not.committed.yet", NULL, 0);
	strbuf_addstr(&msg, "tree 0000000000000000000000000000000000000000\n");
	for (parent = commit->parents; parent; parent = parent->next)
		strbuf_addf(&msg, "parent %s\n",
			    oid_to_hex(&parent->item->object.oid));
	strbuf_addf(&msg,
		    "author %s\n"
		    "committer %s\n\n"
		    "Version of %s from %s\n",
		    ident, ident, path,
		    (!contents_from ? path :
		     (!strcmp(contents_from, "-") ? "standard input" : contents_from)));
	set_commit_buffer_from_strbuf(commit, &msg);

	if (!contents_from || strcmp("-", contents_from)) {
		struct stat st;
		const char *read_from;
		char *buf_ptr;
		unsigned long buf_len;

		if (contents_from) {
			if (stat(contents_from, &st) < 0)
				die_errno("Cannot stat '%s'", contents_from);
			read_from = contents_from;
		}
		else {
			if (lstat(path, &st) < 0)
				die_errno("Cannot lstat '%s'", path);
			read_from = path;
		}
		mode = canon_mode(st.st_mode);

		switch (st.st_mode & S_IFMT) {
		case S_IFREG:
			if (DIFF_OPT_TST(opt, ALLOW_TEXTCONV) &&
			    textconv_object(read_from, mode, &null_oid, 0, &buf_ptr, &buf_len))
				strbuf_attach(&buf, buf_ptr, buf_len, buf_len + 1);
			else if (strbuf_read_file(&buf, read_from, st.st_size) != st.st_size)
				die_errno("cannot open or read '%s'", read_from);
			break;
		case S_IFLNK:
			if (strbuf_readlink(&buf, read_from, st.st_size) < 0)
				die_errno("cannot readlink '%s'", read_from);
			break;
		default:
			die("unsupported file type %s", read_from);
		}
	}
	else {
		/* Reading from stdin */
		mode = 0;
		if (strbuf_read(&buf, 0, 0) < 0)
			die_errno("failed to read from stdin");
	}
	convert_to_git(path, buf.buf, buf.len, &buf, 0);
	origin->file.ptr = buf.buf;
	origin->file.size = buf.len;
	pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_oid.hash);

	/*
	 * Read the current index, replace the path entry with
	 * origin->blob_sha1 without mucking with its mode or type
	 * bits; we are not going to write this index out -- we just
	 * want to run "diff-index --cached".
	 */
	discard_cache();
	read_cache();

	len = strlen(path);
	if (!mode) {
		int pos = cache_name_pos(path, len);
		if (0 <= pos)
			mode = active_cache[pos]->ce_mode;
		else
			/* Let's not bother reading from HEAD tree */
			mode = S_IFREG | 0644;
	}
	size = cache_entry_size(len);
	ce = xcalloc(1, size);
	oidcpy(&ce->oid, &origin->blob_oid);
	memcpy(ce->name, path, len);
	ce->ce_flags = create_ce_flags(0);
	ce->ce_namelen = len;
	ce->ce_mode = create_ce_mode(mode);
	add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);

	cache_tree_invalidate_path(&the_index, path);

	return commit;
}
Commit	Line	Data
072bf432 JS	1	#include "cache.h"
	2	#include "refs.h"
	3	#include "cache-tree.h"
f5dd754c JS	4	#include "blame.h"
	5
	6	void blame_origin_decref(struct blame_origin *o)
	7	{
	8	if (o && --o->refcnt <= 0) {
	9	struct blame_origin p, l = NULL;
	10	if (o->previous)
	11	blame_origin_decref(o->previous);
	12	free(o->file.ptr);
	13	/* Should be present exactly once in commit chain */
	14	for (p = o->commit->util; p; l = p, p = p->next) {
	15	if (p == o) {
	16	if (l)
	17	l->next = p->next;
	18	else
	19	o->commit->util = p->next;
	20	free(o);
	21	return;
	22	}
	23	}
	24	die("internal error in blame_origin_decref");
	25	}
	26	}
	27
	28	/*
	29	* Given a commit and a path in it, create a new origin structure.
	30	* The callers that add blame to the scoreboard should use
	31	* get_origin() to obtain shared, refcounted copy instead of calling
	32	* this function directly.
	33	*/
072bf432	34	static struct blame_origin make_origin(struct commit commit, const char *path)
f5dd754c JS	35	{
	36	struct blame_origin *o;
	37	FLEX_ALLOC_STR(o, path, path);
	38	o->commit = commit;
	39	o->refcnt = 1;
	40	o->next = commit->util;
	41	commit->util = o;
	42	return o;
	43	}
	44
	45	/*
	46	* Locate an existing origin or create a new one.
	47	* This moves the origin to front position in the commit util list.
	48	*/
	49	struct blame_origin get_origin(struct commit commit, const char *path)
	50	{
	51	struct blame_origin o, l;
	52
	53	for (o = commit->util, l = NULL; o; l = o, o = o->next) {
	54	if (!strcmp(o->path, path)) {
	55	/* bump to front */
	56	if (l) {
	57	l->next = o->next;
	58	o->next = commit->util;
	59	commit->util = o;
	60	}
	61	return blame_origin_incref(o);
	62	}
	63	}
	64	return make_origin(commit, path);
	65	}
072bf432 JS	66
	67
	68
	69	static void verify_working_tree_path(struct commit work_tree, const char path)
	70	{
	71	struct commit_list *parents;
	72	int pos;
	73
	74	for (parents = work_tree->parents; parents; parents = parents->next) {
	75	const struct object_id *commit_oid = &parents->item->object.oid;
	76	struct object_id blob_oid;
	77	unsigned mode;
	78
	79	if (!get_tree_entry(commit_oid->hash, path, blob_oid.hash, &mode) &&
	80	sha1_object_info(blob_oid.hash, NULL) == OBJ_BLOB)
	81	return;
	82	}
	83
	84	pos = cache_name_pos(path, strlen(path));
	85	if (pos >= 0)
	86	; /* path is in the index */
	87	else if (-1 - pos < active_nr &&
	88	!strcmp(active_cache[-1 - pos]->name, path))
	89	; /* path is in the index, unmerged */
	90	else
	91	die("no such path '%s' in HEAD", path);
	92	}
	93
	94	static struct commit_list append_parent(struct commit_list tail, const struct object_id *oid)
	95	{
	96	struct commit *parent;
	97
	98	parent = lookup_commit_reference(oid->hash);
	99	if (!parent)
	100	die("no such commit %s", oid_to_hex(oid));
	101	return &commit_list_insert(parent, tail)->next;
	102	}
	103
	104	static void append_merge_parents(struct commit_list **tail)
	105	{
	106	int merge_head;
	107	struct strbuf line = STRBUF_INIT;
	108
	109	merge_head = open(git_path_merge_head(), O_RDONLY);
	110	if (merge_head < 0) {
	111	if (errno == ENOENT)
	112	return;
	113	die("cannot open '%s' for reading", git_path_merge_head());
	114	}
	115
	116	while (!strbuf_getwholeline_fd(&line, merge_head, '\n')) {
	117	struct object_id oid;
	118	if (line.len < GIT_SHA1_HEXSZ \|\| get_oid_hex(line.buf, &oid))
	119	die("unknown line in '%s': %s", git_path_merge_head(), line.buf);
	120	tail = append_parent(tail, &oid);
	121	}
	122	close(merge_head);
	123	strbuf_release(&line);
	124	}
	125
	126	/*
	127	* This isn't as simple as passing sb->buf and sb->len, because we
	128	* want to transfer ownership of the buffer to the commit (so we
	129	* must use detach).
130	*/
131	static void set_commit_buffer_from_strbuf(struct commit c, struct strbuf sb)
132	{
133	size_t len;
134	void *buf = strbuf_detach(sb, &len);
135	set_commit_buffer(c, buf, len);
136	}
137
138	/*
139	* Prepare a dummy commit that represents the work tree (or staged) item.
140	* Note that annotating work tree item never works in the reverse.
141	*/
142	struct commit fake_working_tree_commit(struct diff_options opt,
143	const char *path,
144	const char *contents_from)
145	{
146	struct commit *commit;
147	struct blame_origin *origin;
148	struct commit_list *parent_tail, parent;
149	struct object_id head_oid;
150	struct strbuf buf = STRBUF_INIT;
151	const char *ident;
152	time_t now;
153	int size, len;
154	struct cache_entry *ce;
155	unsigned mode;
156	struct strbuf msg = STRBUF_INIT;
157
158	read_cache();
159	time(&now);
160	commit = alloc_commit_node();
161	commit->object.parsed = 1;
162	commit->date = now;
163	parent_tail = &commit->parents;
164
165	if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, head_oid.hash, NULL))
166	die("no such ref: HEAD");
167
168	parent_tail = append_parent(parent_tail, &head_oid);
169	append_merge_parents(parent_tail);
170	verify_working_tree_path(commit, path);
171
172	origin = make_origin(commit, path);
173
174	ident = fmt_ident("Not Committed Yet", "not.committed.yet", NULL, 0);
175	strbuf_addstr(&msg, "tree 0000000000000000000000000000000000000000\n");
176	for (parent = commit->parents; parent; parent = parent->next)
177	strbuf_addf(&msg, "parent %s\n",
178	oid_to_hex(&parent->item->object.oid));
179	strbuf_addf(&msg,
180	"author %s\n"
181	"committer %s\n\n"
182	"Version of %s from %s\n",
183	ident, ident, path,
184	(!contents_from ? path :
185	(!strcmp(contents_from, "-") ? "standard input" : contents_from)));
186	set_commit_buffer_from_strbuf(commit, &msg);
187
188	if (!contents_from \|\| strcmp("-", contents_from)) {
189	struct stat st;
190	const char *read_from;
191	char *buf_ptr;
192	unsigned long buf_len;
193
194	if (contents_from) {
195	if (stat(contents_from, &st) < 0)
196	die_errno("Cannot stat '%s'", contents_from);
197	read_from = contents_from;
198	}
199	else {
200	if (lstat(path, &st) < 0)
201	die_errno("Cannot lstat '%s'", path);
202	read_from = path;
203	}
204	mode = canon_mode(st.st_mode);
205
206	switch (st.st_mode & S_IFMT) {
207	case S_IFREG:
208	if (DIFF_OPT_TST(opt, ALLOW_TEXTCONV) &&
209	textconv_object(read_from, mode, &null_oid, 0, &buf_ptr, &buf_len))
210	strbuf_attach(&buf, buf_ptr, buf_len, buf_len + 1);
211	else if (strbuf_read_file(&buf, read_from, st.st_size) != st.st_size)
212	die_errno("cannot open or read '%s'", read_from);
213	break;
214	case S_IFLNK:
215	if (strbuf_readlink(&buf, read_from, st.st_size) < 0)
216	die_errno("cannot readlink '%s'", read_from);
217	break;
218	default:
219	die("unsupported file type %s", read_from);
220	}
221	}
222	else {
223	/* Reading from stdin */
224	mode = 0;
225	if (strbuf_read(&buf, 0, 0) < 0)
226	die_errno("failed to read from stdin");
227	}
228	convert_to_git(path, buf.buf, buf.len, &buf, 0);
229	origin->file.ptr = buf.buf;
230	origin->file.size = buf.len;
231	pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_oid.hash);
232
233	/*
234	* Read the current index, replace the path entry with
235	* origin->blob_sha1 without mucking with its mode or type
236	* bits; we are not going to write this index out -- we just
237	* want to run "diff-index --cached".
238	*/
239	discard_cache();
240	read_cache();
241
242	len = strlen(path);
243	if (!mode) {
244	int pos = cache_name_pos(path, len);
245	if (0 <= pos)
246	mode = active_cache[pos]->ce_mode;
247	else
248	/* Let's not bother reading from HEAD tree */
249	mode = S_IFREG \| 0644;
250	}
251	size = cache_entry_size(len);
252	ce = xcalloc(1, size);
253	oidcpy(&ce->oid, &origin->blob_oid);
254	memcpy(ce->name, path, len);
255	ce->ce_flags = create_ce_flags(0);
256	ce->ce_namelen = len;
257	ce->ce_mode = create_ce_mode(mode);
258	add_cache_entry(ce, ADD_CACHE_OK_TO_ADD\|ADD_CACHE_OK_TO_REPLACE);
259
260	cache_tree_invalidate_path(&the_index, path);
261
262	return commit;
263	}