src/diff.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 "diff.h"
   9
  10 #include "git2/version.h"
  11 #include "diff_generate.h"
  12 #include "patch.h"
  13 #include "commit.h"
  14 #include "index.h"
  15
  16 struct patch_id_args {
  17         git_hash_ctx ctx;
  18         git_oid result;
  19         int first_file;
  20 };
  21
  22 GIT_INLINE(const char *) diff_delta__path(const git_diff_delta *delta)
  23 {
  24         const char *str = delta->old_file.path;
  25
  26         if (!str ||
  27                 delta->status == GIT_DELTA_ADDED ||
  28                 delta->status == GIT_DELTA_RENAMED ||
  29                 delta->status == GIT_DELTA_COPIED)
  30                 str = delta->new_file.path;
  31
  32         return str;
  33 }
  34
  35 const char *git_diff_delta__path(const git_diff_delta *delta)
  36 {
  37         return diff_delta__path(delta);
  38 }
  39
  40 int git_diff_delta__cmp(const void *a, const void *b)
  41 {
  42         const git_diff_delta *da = a, *db = b;
  43         int val = strcmp(diff_delta__path(da), diff_delta__path(db));
  44         return val ? val : ((int)da->status - (int)db->status);
  45 }
  46
  47 int git_diff_delta__casecmp(const void *a, const void *b)
  48 {
  49         const git_diff_delta *da = a, *db = b;
  50         int val = strcasecmp(diff_delta__path(da), diff_delta__path(db));
  51         return val ? val : ((int)da->status - (int)db->status);
  52 }
  53
  54 int git_diff__entry_cmp(const void *a, const void *b)
  55 {
  56         const git_index_entry *entry_a = a;
  57         const git_index_entry *entry_b = b;
  58
  59         return strcmp(entry_a->path, entry_b->path);
  60 }
  61
  62 int git_diff__entry_icmp(const void *a, const void *b)
  63 {
  64         const git_index_entry *entry_a = a;
  65         const git_index_entry *entry_b = b;
  66
  67         return strcasecmp(entry_a->path, entry_b->path);
  68 }
  69
  70 void git_diff_free(git_diff *diff)
  71 {
  72         if (!diff)
  73                 return;
  74
  75         GIT_REFCOUNT_DEC(diff, diff->free_fn);
  76 }
  77
  78 void git_diff_addref(git_diff *diff)
  79 {
  80         GIT_REFCOUNT_INC(diff);
  81 }
  82
  83 size_t git_diff_num_deltas(const git_diff *diff)
  84 {
  85         assert(diff);
  86         return diff->deltas.length;
  87 }
  88
  89 size_t git_diff_num_deltas_of_type(const git_diff *diff, git_delta_t type)
  90 {
  91         size_t i, count = 0;
  92         const git_diff_delta *delta;
  93
  94         assert(diff);
  95
  96         git_vector_foreach(&diff->deltas, i, delta) {
  97                 count += (delta->status == type);
  98         }
  99
 100         return count;
 101 }
 102
 103 const git_diff_delta *git_diff_get_delta(const git_diff *diff, size_t idx)
 104 {
 105         assert(diff);
 106         return git_vector_get(&diff->deltas, idx);
 107 }
 108
 109 int git_diff_is_sorted_icase(const git_diff *diff)
 110 {
 111         return (diff->opts.flags & GIT_DIFF_IGNORE_CASE) != 0;
 112 }
 113
 114 int git_diff_get_perfdata(git_diff_perfdata *out, const git_diff *diff)
 115 {
 116         assert(out);
 117         GIT_ERROR_CHECK_VERSION(out, GIT_DIFF_PERFDATA_VERSION, "git_diff_perfdata");
 118         out->stat_calls = diff->perf.stat_calls;
 119         out->oid_calculations = diff->perf.oid_calculations;
 120         return 0;
 121 }
 122
 123 int git_diff_foreach(
 124         git_diff *diff,
 125         git_diff_file_cb file_cb,
 126         git_diff_binary_cb binary_cb,
 127         git_diff_hunk_cb hunk_cb,
 128         git_diff_line_cb data_cb,
 129         void *payload)
 130 {
 131         int error = 0;
 132         git_diff_delta *delta;
 133         size_t idx;
 134
 135         assert(diff);
 136
 137         git_vector_foreach(&diff->deltas, idx, delta) {
 138                 git_patch *patch;
 139
 140                 /* check flags against patch status */
 141                 if (git_diff_delta__should_skip(&diff->opts, delta))
 142                         continue;
 143
 144                 if ((error = git_patch_from_diff(&patch, diff, idx)) != 0)
 145                         break;
 146
 147                 error = git_patch__invoke_callbacks(patch, file_cb, binary_cb,
 148                                                     hunk_cb, data_cb, payload);
 149                 git_patch_free(patch);
 150
 151                 if (error)
 152                         break;
 153         }
 154
 155         return error;
 156 }
 157
 158 int git_diff_format_email__append_header_tobuf(
 159         git_buf *out,
 160         const git_oid *id,
 161         const git_signature *author,
 162         const char *summary,
 163         const char *body,
 164         size_t patch_no,
 165         size_t total_patches,
 166         bool exclude_patchno_marker)
 167 {
 168         char idstr[GIT_OID_HEXSZ + 1];
 169         char date_str[GIT_DATE_RFC2822_SZ];
 170         int error = 0;
 171
 172         git_oid_fmt(idstr, id);
 173         idstr[GIT_OID_HEXSZ] = '\0';
 174
 175         if ((error = git__date_rfc2822_fmt(date_str, sizeof(date_str),
 176                 &author->when)) < 0)
 177                 return error;
 178
 179         error = git_buf_printf(out,
 180                                 "From %s Mon Sep 17 00:00:00 2001\n" \
 181                                 "From: %s <%s>\n" \
 182                                 "Date: %s\n" \
 183                                 "Subject: ",
 184                                 idstr,
 185                                 author->name, author->email,
 186                                 date_str);
 187
 188         if (error < 0)
 189                 return error;
 190
 191         if (!exclude_patchno_marker) {
 192                 if (total_patches == 1) {
 193                         error = git_buf_puts(out, "[PATCH] ");
 194                 } else {
 195                         error = git_buf_printf(out, "[PATCH %"PRIuZ"/%"PRIuZ"] ",
 196                                 patch_no, total_patches);
 197                 }
 198
 199                 if (error < 0)
 200                         return error;
 201         }
 202
 203         error = git_buf_printf(out, "%s\n\n", summary);
 204
 205         if (body) {
 206                 git_buf_puts(out, body);
 207
 208                 if (out->ptr[out->size - 1] != '\n')
 209                         git_buf_putc(out, '\n');
 210         }
 211
 212         return error;
 213 }
 214
 215 int git_diff_format_email__append_patches_tobuf(
 216         git_buf *out,
 217         git_diff *diff)
 218 {
 219         size_t i, deltas;
 220         int error = 0;
 221
 222         deltas = git_diff_num_deltas(diff);
 223
 224         for (i = 0; i < deltas; ++i) {
 225                 git_patch *patch = NULL;
 226
 227                 if ((error = git_patch_from_diff(&patch, diff, i)) >= 0)
 228                         error = git_patch_to_buf(out, patch);
 229
 230                 git_patch_free(patch);
 231
 232                 if (error < 0)
 233                         break;
 234         }
 235
 236         return error;
 237 }
 238
 239 int git_diff_format_email(
 240         git_buf *out,
 241         git_diff *diff,
 242         const git_diff_format_email_options *opts)
 243 {
 244         git_diff_stats *stats = NULL;
 245         char *summary = NULL, *loc = NULL;
 246         bool ignore_marker;
 247         unsigned int format_flags = 0;
 248         size_t allocsize;
 249         int error;
 250
 251         assert(out && diff && opts);
 252         assert(opts->summary && opts->id && opts->author);
 253
 254         GIT_ERROR_CHECK_VERSION(opts,
 255                 GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION,
 256                 "git_format_email_options");
 257
 258         ignore_marker = (opts->flags &
 259                 GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER) != 0;
 260
 261         if (!ignore_marker) {
 262                 if (opts->patch_no > opts->total_patches) {
 263                         git_error_set(GIT_ERROR_INVALID,
 264                                 "patch %"PRIuZ" out of range. max %"PRIuZ,
 265                                 opts->patch_no, opts->total_patches);
 266                         return -1;
 267                 }
 268
 269                 if (opts->patch_no == 0) {
 270                         git_error_set(GIT_ERROR_INVALID,
 271                                 "invalid patch no %"PRIuZ". should be >0", opts->patch_no);
 272                         return -1;
 273                 }
 274         }
 275
 276         /* the summary we receive may not be clean.
 277          * it could potentially contain new line characters
 278          * or not be set, sanitize, */
 279         if ((loc = strpbrk(opts->summary, "\r\n")) != NULL) {
 280                 size_t offset = 0;
 281
 282                 if ((offset = (loc - opts->summary)) == 0) {
 283                         git_error_set(GIT_ERROR_INVALID, "summary is empty");
 284                         error = -1;
 285                         goto on_error;
 286                 }
 287
 288                 GIT_ERROR_CHECK_ALLOC_ADD(&allocsize, offset, 1);
 289                 summary = git__calloc(allocsize, sizeof(char));
 290                 GIT_ERROR_CHECK_ALLOC(summary);
 291
 292                 strncpy(summary, opts->summary, offset);
 293         }
 294
 295         error = git_diff_format_email__append_header_tobuf(out,
 296                 opts->id, opts->author, summary == NULL ? opts->summary : summary,
 297                 opts->body, opts->patch_no, opts->total_patches, ignore_marker);
 298
 299         if (error < 0)
 300                 goto on_error;
 301
 302         format_flags = GIT_DIFF_STATS_FULL | GIT_DIFF_STATS_INCLUDE_SUMMARY;
 303
 304         if ((error = git_buf_puts(out, "---\n")) < 0 ||
 305                 (error = git_diff_get_stats(&stats, diff)) < 0 ||
 306                 (error = git_diff_stats_to_buf(out, stats, format_flags, 0)) < 0 ||
 307                 (error = git_buf_putc(out, '\n')) < 0 ||
 308                 (error = git_diff_format_email__append_patches_tobuf(out, diff)) < 0)
 309                         goto on_error;
 310
 311         error = git_buf_puts(out, "--\nlibgit2 " LIBGIT2_VERSION "\n\n");
 312
 313 on_error:
 314         git__free(summary);
 315         git_diff_stats_free(stats);
 316
 317         return error;
 318 }
 319
 320 int git_diff_commit_as_email(
 321         git_buf *out,
 322         git_repository *repo,
 323         git_commit *commit,
 324         size_t patch_no,
 325         size_t total_patches,
 326         git_diff_format_email_flags_t flags,
 327         const git_diff_options *diff_opts)
 328 {
 329         git_diff *diff = NULL;
 330         git_diff_format_email_options opts =
 331                 GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
 332         int error;
 333
 334         assert (out && repo && commit);
 335
 336         opts.flags = flags;
 337         opts.patch_no = patch_no;
 338         opts.total_patches = total_patches;
 339         opts.id = git_commit_id(commit);
 340         opts.summary = git_commit_summary(commit);
 341         opts.body = git_commit_body(commit);
 342         opts.author = git_commit_author(commit);
 343
 344         if ((error = git_diff__commit(&diff, repo, commit, diff_opts)) < 0)
 345                 return error;
 346
 347         error = git_diff_format_email(out, diff, &opts);
 348
 349         git_diff_free(diff);
 350         return error;
 351 }
 352
 353 int git_diff_init_options(git_diff_options *opts, unsigned int version)
 354 {
 355         GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 356                 opts, version, git_diff_options, GIT_DIFF_OPTIONS_INIT);
 357         return 0;
 358 }
 359
 360 int git_diff_find_init_options(
 361         git_diff_find_options *opts, unsigned int version)
 362 {
 363         GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 364                 opts, version, git_diff_find_options, GIT_DIFF_FIND_OPTIONS_INIT);
 365         return 0;
 366 }
 367
 368 int git_diff_format_email_init_options(
 369         git_diff_format_email_options *opts, unsigned int version)
 370 {
 371         GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 372                 opts, version, git_diff_format_email_options,
 373                 GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT);
 374         return 0;
 375 }
 376
 377 static int flush_hunk(git_oid *result, git_hash_ctx *ctx)
 378 {
 379         git_oid hash;
 380         unsigned short carry = 0;
 381         int error, i;
 382
 383         if ((error = git_hash_final(&hash, ctx)) < 0 ||
 384             (error = git_hash_init(ctx)) < 0)
 385                 return error;
 386
 387         for (i = 0; i < GIT_OID_RAWSZ; i++) {
 388                 carry += result->id[i] + hash.id[i];
 389                 result->id[i] = (unsigned char)carry;
 390                 carry >>= 8;
 391         }
 392
 393         return 0;
 394 }
 395
 396 static void strip_spaces(git_buf *buf)
 397 {
 398         char *src = buf->ptr, *dst = buf->ptr;
 399         char c;
 400         size_t len = 0;
 401
 402         while ((c = *src++) != '\0') {
 403                 if (!git__isspace(c)) {
 404                         *dst++ = c;
 405                         len++;
 406                 }
 407         }
 408
 409         git_buf_truncate(buf, len);
 410 }
 411
 412 static int file_cb(
 413         const git_diff_delta *delta,
 414         float progress,
 415         void *payload)
 416 {
 417         struct patch_id_args *args = (struct patch_id_args *) payload;
 418         git_buf buf = GIT_BUF_INIT;
 419         int error;
 420
 421         GIT_UNUSED(progress);
 422
 423         if (!args->first_file &&
 424             (error = flush_hunk(&args->result, &args->ctx)) < 0)
 425                 goto out;
 426         args->first_file = 0;
 427
 428         if ((error = git_buf_printf(&buf,
 429                                     "diff--gita/%sb/%s---a/%s+++b/%s",
 430                                     delta->old_file.path,
 431                                     delta->new_file.path,
 432                                     delta->old_file.path,
 433                                     delta->new_file.path)) < 0)
 434                 goto out;
 435
 436         strip_spaces(&buf);
 437
 438         if ((error = git_hash_update(&args->ctx, buf.ptr, buf.size)) < 0)
 439                 goto out;
 440
 441 out:
 442         git_buf_dispose(&buf);
 443         return error;
 444 }
 445
 446 static int line_cb(
 447         const git_diff_delta *delta,
 448         const git_diff_hunk *hunk,
 449         const git_diff_line *line,
 450         void *payload)
 451 {
 452         struct patch_id_args *args = (struct patch_id_args *) payload;
 453         git_buf buf = GIT_BUF_INIT;
 454         int error;
 455
 456         GIT_UNUSED(delta);
 457         GIT_UNUSED(hunk);
 458
 459         switch (line->origin) {
 460             case GIT_DIFF_LINE_ADDITION:
 461                 git_buf_putc(&buf, '+');
 462                 break;
 463             case GIT_DIFF_LINE_DELETION:
 464                 git_buf_putc(&buf, '-');
 465                 break;
 466             case GIT_DIFF_LINE_CONTEXT:
 467                 break;
 468             default:
 469                 git_error_set(GIT_ERROR_PATCH, "invalid line origin for patch");
 470                 return -1;
 471         }
 472
 473         git_buf_put(&buf, line->content, line->content_len);
 474         strip_spaces(&buf);
 475
 476         if ((error = git_hash_update(&args->ctx, buf.ptr, buf.size)) < 0)
 477                 goto out;
 478
 479 out:
 480         git_buf_dispose(&buf);
 481         return error;
 482 }
 483
 484 int git_diff_patchid_init_options(git_diff_patchid_options *opts, unsigned int version)
 485 {
 486         GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 487                 opts, version, git_diff_patchid_options, GIT_DIFF_PATCHID_OPTIONS_INIT);
 488         return 0;
 489 }
 490
 491 int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opts)
 492 {
 493         struct patch_id_args args;
 494         int error;
 495
 496         GIT_ERROR_CHECK_VERSION(
 497                 opts, GIT_DIFF_PATCHID_OPTIONS_VERSION, "git_diff_patchid_options");
 498
 499         memset(&args, 0, sizeof(args));
 500         args.first_file = 1;
 501         if ((error = git_hash_ctx_init(&args.ctx)) < 0)
 502                 goto out;
 503
 504         if ((error = git_diff_foreach(diff, file_cb, NULL, NULL, line_cb, &args)) < 0)
 505                 goto out;
 506
 507         if ((error = (flush_hunk(&args.result, &args.ctx))) < 0)
 508                 goto out;
 509
 510         git_oid_cpy(out, &args.result);
 511
 512 out:
 513         git_hash_ctx_cleanup(&args.ctx);
 514         return error;
 515 }