src/reflog.c

   1 /*
   2  * Copyright (C) the libgit2 contributors. All rights reserved.
   3  *
   4  * This file is part of libgit2, distributed under the GNU GPL v2 with
   5  * a Linking Exception. For full terms see the included COPYING file.
   6  */
   7
   8 #include "reflog.h"
   9 #include "repository.h"
  10 #include "filebuf.h"
  11 #include "signature.h"
  12 #include "refdb.h"
  13
  14 #include <git2/sys/refdb_backend.h>
  15
  16 git_reflog_entry *git_reflog_entry__alloc(void)
  17 {
  18         return git__calloc(1, sizeof(git_reflog_entry));
  19 }
  20
  21 void git_reflog_entry__free(git_reflog_entry *entry)
  22 {
  23         git_signature_free(entry->committer);
  24
  25         git__free(entry->msg);
  26         git__free(entry);
  27 }
  28
  29 void git_reflog_free(git_reflog *reflog)
  30 {
  31         size_t i;
  32         git_reflog_entry *entry;
  33
  34         if (reflog == NULL)
  35                 return;
  36
  37         if (reflog->db)
  38                 GIT_REFCOUNT_DEC(reflog->db, git_refdb__free);
  39
  40         for (i=0; i < reflog->entries.length; i++) {
  41                 entry = git_vector_get(&reflog->entries, i);
  42
  43                 git_reflog_entry__free(entry);
  44         }
  45
  46         git_vector_free(&reflog->entries);
  47         git__free(reflog->ref_name);
  48         git__free(reflog);
  49 }
  50
  51 int git_reflog_read(git_reflog **reflog, git_repository *repo,  const char *name)
  52 {
  53         git_refdb *refdb;
  54         int error;
  55
  56         assert(reflog && repo && name);
  57
  58         if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
  59                 return error;
  60
  61         return git_refdb_reflog_read(reflog, refdb, name);
  62 }
  63
  64 int git_reflog_write(git_reflog *reflog)
  65 {
  66         git_refdb *db;
  67
  68         assert(reflog && reflog->db);
  69
  70         db = reflog->db;
  71         return db->backend->reflog_write(db->backend, reflog);
  72 }
  73
  74 int git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_signature *committer, const char *msg)
  75 {
  76         git_reflog_entry *entry;
  77         const git_reflog_entry *previous;
  78         const char *newline;
  79
  80         assert(reflog && new_oid && committer);
  81
  82         entry = git__calloc(1, sizeof(git_reflog_entry));
  83         GITERR_CHECK_ALLOC(entry);
  84
  85         if ((git_signature_dup(&entry->committer, committer)) < 0)
  86                 goto cleanup;
  87
  88         if (msg != NULL) {
  89                 if ((entry->msg = git__strdup(msg)) == NULL)
  90                         goto cleanup;
  91
  92                 newline = strchr(msg, '\n');
  93
  94                 if (newline) {
  95                         if (newline[1] != '\0') {
  96                                 giterr_set(GITERR_INVALID, "Reflog message cannot contain newline");
  97                                 goto cleanup;
  98                         }
  99
 100                         entry->msg[newline - msg] = '\0';
 101                 }
 102         }
 103
 104         previous = git_reflog_entry_byindex(reflog, 0);
 105
 106         if (previous == NULL)
 107                 git_oid_fromstr(&entry->oid_old, GIT_OID_HEX_ZERO);
 108         else
 109                 git_oid_cpy(&entry->oid_old, &previous->oid_cur);
 110
 111         git_oid_cpy(&entry->oid_cur, new_oid);
 112
 113         if (git_vector_insert(&reflog->entries, entry) < 0)
 114                 goto cleanup;
 115
 116         return 0;
 117
 118 cleanup:
 119         git_reflog_entry__free(entry);
 120         return -1;
 121 }
 122
 123 int git_reflog_rename(git_repository *repo, const char *old_name, const char *new_name)
 124 {
 125         git_refdb *refdb;
 126         int error;
 127
 128         if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
 129                 return -1;
 130
 131         return refdb->backend->reflog_rename(refdb->backend, old_name, new_name);
 132 }
 133
 134 int git_reflog_delete(git_repository *repo, const char *name)
 135 {
 136         git_refdb *refdb;
 137         int error;
 138
 139         if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
 140                 return -1;
 141
 142         return refdb->backend->reflog_delete(refdb->backend, name);
 143 }
 144
 145 size_t git_reflog_entrycount(git_reflog *reflog)
 146 {
 147         assert(reflog);
 148         return reflog->entries.length;
 149 }
 150
 151 const git_reflog_entry * git_reflog_entry_byindex(const git_reflog *reflog, size_t idx)
 152 {
 153         assert(reflog);
 154
 155         if (idx >= reflog->entries.length)
 156                 return NULL;
 157
 158         return git_vector_get(
 159                 &reflog->entries, reflog_inverse_index(idx, reflog->entries.length));
 160 }
 161
 162 const git_oid * git_reflog_entry_id_old(const git_reflog_entry *entry)
 163 {
 164         assert(entry);
 165         return &entry->oid_old;
 166 }
 167
 168 const git_oid * git_reflog_entry_id_new(const git_reflog_entry *entry)
 169 {
 170         assert(entry);
 171         return &entry->oid_cur;
 172 }
 173
 174 const git_signature * git_reflog_entry_committer(const git_reflog_entry *entry)
 175 {
 176         assert(entry);
 177         return entry->committer;
 178 }
 179
 180 const char * git_reflog_entry_message(const git_reflog_entry *entry)
 181 {
 182         assert(entry);
 183         return entry->msg;
 184 }
 185
 186 int git_reflog_drop(git_reflog *reflog, size_t idx, int rewrite_previous_entry)
 187 {
 188         size_t entrycount;
 189         git_reflog_entry *entry, *previous;
 190
 191         entrycount = git_reflog_entrycount(reflog);
 192
 193         entry = (git_reflog_entry *)git_reflog_entry_byindex(reflog, idx);
 194
 195         if (entry == NULL) {
 196                 giterr_set(GITERR_REFERENCE, "No reflog entry at index %"PRIuZ, idx);
 197                 return GIT_ENOTFOUND;
 198         }
 199
 200         git_reflog_entry__free(entry);
 201
 202         if (git_vector_remove(
 203                         &reflog->entries, reflog_inverse_index(idx, entrycount)) < 0)
 204                 return -1;
 205
 206         if (!rewrite_previous_entry)
 207                 return 0;
 208
 209         /* No need to rewrite anything when removing the most recent entry */
 210         if (idx == 0)
 211                 return 0;
 212
 213         /* Have the latest entry just been dropped? */
 214         if (entrycount == 1)
 215                 return 0;
 216
 217         entry = (git_reflog_entry *)git_reflog_entry_byindex(reflog, idx - 1);
 218
 219         /* If the oldest entry has just been removed... */
 220         if (idx == entrycount - 1) {
 221                 /* ...clear the oid_old member of the "new" oldest entry */
 222                 if (git_oid_fromstr(&entry->oid_old, GIT_OID_HEX_ZERO) < 0)
 223                         return -1;
 224
 225                 return 0;
 226         }
 227
 228         previous = (git_reflog_entry *)git_reflog_entry_byindex(reflog, idx);
 229         git_oid_cpy(&entry->oid_old, &previous->oid_cur);
 230
 231         return 0;
 232 }