reflog.c 4.87 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6 7 8
 */

#include "reflog.h"
9

10 11 12
#include "repository.h"
#include "filebuf.h"
#include "signature.h"
13
#include "refdb.h"
14

15 16
#include "git2/sys/refdb_backend.h"
#include "git2/sys/reflog.h"
17

18
void git_reflog_entry__free(git_reflog_entry *entry)
19 20
{
	git_signature_free(entry->committer);
21

22 23
	git__free(entry->msg);
	git__free(entry);
24 25 26 27
}

void git_reflog_free(git_reflog *reflog)
{
28
	size_t i;
29 30
	git_reflog_entry *entry;

31 32 33
	if (reflog == NULL)
		return;

34 35 36
	if (reflog->db)
		GIT_REFCOUNT_DEC(reflog->db, git_refdb__free);

37 38 39
	for (i=0; i < reflog->entries.length; i++) {
		entry = git_vector_get(&reflog->entries, i);

40
		git_reflog_entry__free(entry);
41 42 43
	}

	git_vector_free(&reflog->entries);
44 45
	git__free(reflog->ref_name);
	git__free(reflog);
46 47
}

48
int git_reflog_read(git_reflog **reflog, git_repository *repo,  const char *name)
49
{
50 51
	git_refdb *refdb;
	int error;
52

53
	assert(reflog && repo && name);
54

55
	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
56
		return error;
57

58
	return git_refdb_reflog_read(reflog, refdb, name);
59 60
}

61 62
int git_reflog_write(git_reflog *reflog)
{
63
	git_refdb *db;
64

65
	assert(reflog && reflog->db);
66

67 68
	db = reflog->db;
	return db->backend->reflog_write(db->backend, reflog);
69 70
}

71
int git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_signature *committer, const char *msg)
72
{
73
	const git_reflog_entry *previous;
74
	git_reflog_entry *entry;
75

76
	assert(reflog && new_oid && committer);
77

78
	entry = git__calloc(1, sizeof(git_reflog_entry));
79
	GIT_ERROR_CHECK_ALLOC(entry);
80

81
	if ((git_signature_dup(&entry->committer, committer)) < 0)
82
		goto cleanup;
83

84
	if (msg != NULL) {
85
		size_t i, msglen = strlen(msg);
86

87 88
		if ((entry->msg = git__strndup(msg, msglen)) == NULL)
			goto cleanup;
89

90 91 92 93 94 95 96
		/*
		 * Replace all newlines with spaces, except for
		 * the final trailing newline.
		 */
		for (i = 0; i < msglen; i++)
			if (entry->msg[i] == '\n')
				entry->msg[i] = ' ';
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
	}

	previous = git_reflog_entry_byindex(reflog, 0);

	if (previous == NULL)
		git_oid_fromstr(&entry->oid_old, GIT_OID_HEX_ZERO);
	else
		git_oid_cpy(&entry->oid_old, &previous->oid_cur);

	git_oid_cpy(&entry->oid_cur, new_oid);

	if (git_vector_insert(&reflog->entries, entry) < 0)
		goto cleanup;

	return 0;

cleanup:
	git_reflog_entry__free(entry);
	return -1;
116 117
}

118
int git_reflog_rename(git_repository *repo, const char *old_name, const char *new_name)
119
{
120 121
	git_refdb *refdb;
	int error;
122

123
	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
124
		return -1;
125

126
	return refdb->backend->reflog_rename(refdb->backend, old_name, new_name);
127 128
}

129
int git_reflog_delete(git_repository *repo, const char *name)
130
{
131
	git_refdb *refdb;
132
	int error;
133

134 135
	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
		return -1;
136

137
	return refdb->backend->reflog_delete(refdb->backend, name);
138 139
}

140
size_t git_reflog_entrycount(git_reflog *reflog)
141 142
{
	assert(reflog);
143
	return reflog->entries.length;
144 145
}

146
const git_reflog_entry * git_reflog_entry_byindex(const git_reflog *reflog, size_t idx)
147
{
148
	assert(reflog);
149

150
	if (idx >= reflog->entries.length)
151 152
		return NULL;

153 154
	return git_vector_get(
		&reflog->entries, reflog_inverse_index(idx, reflog->entries.length));
155 156
}

157
const git_oid * git_reflog_entry_id_old(const git_reflog_entry *entry)
158 159
{
	assert(entry);
160
	return &entry->oid_old;
161 162
}

163
const git_oid * git_reflog_entry_id_new(const git_reflog_entry *entry)
164 165
{
	assert(entry);
166
	return &entry->oid_cur;
167 168
}

169
const git_signature * git_reflog_entry_committer(const git_reflog_entry *entry)
170 171 172 173 174
{
	assert(entry);
	return entry->committer;
}

175
const char * git_reflog_entry_message(const git_reflog_entry *entry)
176 177 178 179
{
	assert(entry);
	return entry->msg;
}
180

181
int git_reflog_drop(git_reflog *reflog, size_t idx, int rewrite_previous_entry)
182
{
183 184
	size_t entrycount;
	git_reflog_entry *entry, *previous;
185

186
	entrycount = git_reflog_entrycount(reflog);
187

188 189 190
	entry = (git_reflog_entry *)git_reflog_entry_byindex(reflog, idx);

	if (entry == NULL) {
191
		git_error_set(GIT_ERROR_REFERENCE, "no reflog entry at index %"PRIuZ, idx);
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
		return GIT_ENOTFOUND;
	}

	git_reflog_entry__free(entry);

	if (git_vector_remove(
			&reflog->entries, reflog_inverse_index(idx, entrycount)) < 0)
		return -1;

	if (!rewrite_previous_entry)
		return 0;

	/* No need to rewrite anything when removing the most recent entry */
	if (idx == 0)
		return 0;

	/* Have the latest entry just been dropped? */
	if (entrycount == 1)
		return 0;

	entry = (git_reflog_entry *)git_reflog_entry_byindex(reflog, idx - 1);

	/* If the oldest entry has just been removed... */
	if (idx == entrycount - 1) {
		/* ...clear the oid_old member of the "new" oldest entry */
		if (git_oid_fromstr(&entry->oid_old, GIT_OID_HEX_ZERO) < 0)
			return -1;

		return 0;
	}

	previous = (git_reflog_entry *)git_reflog_entry_byindex(reflog, idx);
	git_oid_cpy(&entry->oid_old, &previous->oid_cur);

	return 0;
227
}