Skip to content

G
git2
Commit b55fd885 by Vicent Martí
Options

Merge pull request #941 from arrbee/diff-separate-iterators 

Create a diff patch object as a replacement for iterators
parents 5942bd18 bae957b9
Showing with 1143 additions and 993 deletions
include/git2/diff.h
......@@ -122,7 +122,7 @@ typedef enum {
*/
typedef struct {
git_oid oid;
char *path;
const char *path;
git_off_t size;
unsigned int flags;
uint16_t mode;
......@@ -154,7 +154,7 @@ typedef struct {
*/
typedef int (*git_diff_file_fn)(
void *cb_data,
git_diff_delta *delta,
const git_diff_delta *delta,
float progress);
/**
......@@ -172,8 +172,8 @@ typedef struct {
*/
typedef int (*git_diff_hunk_fn)(
void *cb_data,
git_diff_delta *delta,
git_diff_range *range,
const git_diff_delta *delta,
const git_diff_range *range,
const char *header,
size_t header_len);
......@@ -213,16 +213,20 @@ enum {
*/
typedef int (*git_diff_data_fn)(
void *cb_data,
git_diff_delta *delta,
git_diff_range *range,
const git_diff_delta *delta,
const git_diff_range *range,
char line_origin, /**< GIT_DIFF_LINE_... value from above */
const char *content,
size_t content_len);
/**
* The diff iterator object is used to scan a diff list.
* The diff patch is used to store all the text diffs for a delta.
*
* You can easily loop over the content of patches and get information about
* them.
*/
typedef struct git_diff_iterator git_diff_iterator;
typedef struct git_diff_patch git_diff_patch;
/** @name Diff List Generator Functions
*
......@@ -349,7 +353,7 @@ GIT_EXTERN(int) git_diff_merge(
/**@{*/
/**
* Iterate over a diff list issuing callbacks.
* Loop over all deltas in a diff list issuing callbacks.
*
* This will iterate through all of the files described in a diff. You
* should provide a file callback to learn about each file.
......@@ -381,188 +385,191 @@ GIT_EXTERN(int) git_diff_foreach(
git_diff_data_fn line_cb);
/**
* Create a diff iterator object that can be used to traverse a diff.
* Iterate over a diff generating text output like "git diff --name-status".
*
* This iterator can be used instead of `git_diff_foreach` in situations
* where callback functions are awkward to use. Because of the way that
* diffs are calculated internally, using an iterator will use somewhat
* more memory than `git_diff_foreach` would.
* Returning a non-zero value from the callbacks will terminate the
* iteration and cause this return `GIT_EUSER`.
*
* @param iterator Output parameter of newly created iterator.
* @param diff Diff over which you wish to iterate.
* @return 0 on success, < 0 on error
* @param diff A git_diff_list generated by one of the above functions.
* @param cb_data Reference pointer that will be passed to your callback.
* @param print_cb Callback to make per line of diff text.
* @return 0 on success, GIT_EUSER on non-zero callback, or error code
*/
GIT_EXTERN(int) git_diff_iterator_new(
git_diff_iterator **iterator,
git_diff_list *diff);
GIT_EXTERN(int) git_diff_print_compact(
git_diff_list *diff,
void *cb_data,
git_diff_data_fn print_cb);
/**
* Release the iterator object.
* Look up the single character abbreviation for a delta status code.
*
* Call this when you are done using the iterator.
* When you call `git_diff_print_compact` it prints single letter codes into
* the output such as 'A' for added, 'D' for deleted, 'M' for modified, etc.
* It is sometimes convenient to convert a git_delta_t value into these
* letters for your own purposes. This function does just that. By the
* way, unmodified will return a space (i.e. ' ').
*
* @param iterator The diff iterator to be freed.
* @param delta_t The git_delta_t value to look up
* @return The single character label for that code
*/
GIT_EXTERN(void) git_diff_iterator_free(git_diff_iterator *iterator);
GIT_EXTERN(char) git_diff_status_char(git_delta_t status);
/**
* Return progress value for traversing the diff.
*
* This returns a value between 0.0 and 1.0 that represents the progress
* through the diff iterator. The value is monotonically increasing and
* will advance gradually as you progress through the iteration.
* Iterate over a diff generating text output like "git diff".
*
* @param iterator The diff iterator
* @return Value between 0.0 and 1.0
*/
GIT_EXTERN(float) git_diff_iterator_progress(git_diff_iterator *iterator);
/**
* Return the number of hunks in the current file
* This is a super easy way to generate a patch from a diff.
*
* This will return the number of diff hunks in the current file. If the
* diff has not been performed yet, this may result in loading the file and
* performing the diff.
* Returning a non-zero value from the callbacks will terminate the
* iteration and cause this return `GIT_EUSER`.
*
* @param iterator The iterator object
* @return The number of hunks in the current file or <0 on loading failure
* @param diff A git_diff_list generated by one of the above functions.
* @param cb_data Reference pointer that will be passed to your callbacks.
* @param print_cb Callback function to output lines of the diff. This
* same function will be called for file headers, hunk
* headers, and diff lines. Fortunately, you can probably
* use various GIT_DIFF_LINE constants to determine what
* text you are given.
* @return 0 on success, GIT_EUSER on non-zero callback, or error code
*/
GIT_EXTERN(int) git_diff_iterator_num_hunks_in_file(git_diff_iterator *iterator);
GIT_EXTERN(int) git_diff_print_patch(
git_diff_list *diff,
void *cb_data,
git_diff_data_fn print_cb);
/**
* Return the number of lines in the hunk currently being examined.
*
* This will return the number of lines in the current hunk. If the diff
* has not been performed yet, this may result in loading the file and
* performing the diff.
* Query how many diff records are there in a diff list.
*
* @param iterator The iterator object
* @return The number of lines in the current hunk (context, added, and
* removed all added together) or <0 on loading failure
* @param diff A git_diff_list generated by one of the above functions
* @return Count of number of deltas in the list
*/
GIT_EXTERN(int) git_diff_iterator_num_lines_in_hunk(git_diff_iterator *iterator);
GIT_EXTERN(size_t) git_diff_num_deltas(git_diff_list *diff);
/**
* Return the delta information for the next file in the diff.
* Query how many diff deltas are there in a diff list filtered by type.
*
* This will return a pointer to the next git_diff_delta` to be processed or
* NULL if the iterator is at the end of the diff, then advance. This
* returns the value `GIT_ITEROVER` after processing the last file.
* This works just like `git_diff_entrycount()` with an extra parameter
* that is a `git_delta_t` and returns just the count of how many deltas
* match that particular type.
*
* @param delta Output parameter for the next delta object
* @param iterator The iterator object
* @return 0 on success, GIT_ITEROVER when done, other value < 0 on error
* @param diff A git_diff_list generated by one of the above functions
* @param type A git_delta_t value to filter the count
* @return Count of number of deltas matching delta_t type
*/
GIT_EXTERN(int) git_diff_iterator_next_file(
git_diff_delta **delta,
git_diff_iterator *iterator);
GIT_EXTERN(size_t) git_diff_num_deltas_of_type(
git_diff_list *diff,
git_delta_t type);
/**
* Return the hunk information for the next hunk in the current file.
* Return the diff delta and patch for an entry in the diff list.
*
* The `git_diff_patch` is a newly created object contains the text diffs
* for the delta. You have to call `git_diff_patch_free()` when you are
* done with it. You can use the patch object to loop over all the hunks
* and lines in the diff of the one delta.
*
* It is recommended that you not call this if the file is a binary
* file, but it is allowed to do so.
* For an unchanged file or a binary file, no `git_diff_patch` will be
* created, the output will be set to NULL, and the `binary` flag will be
* set true in the `git_diff_delta` structure.
*
* The `header` text output will contain the standard hunk header that
* would appear in diff output. The header string will be NUL terminated.
* The `git_diff_delta` pointer points to internal data and you do not have
* to release it when you are done with it. It will go away when the
* `git_diff_list` and `git_diff_patch` go away.
*
* WARNING! Call this function for the first time on a file is when the
* actual text diff will be computed (it cannot be computed incrementally)
* so the first call for a new file is expensive (at least in relative
* terms - in reality, it is still pretty darn fast).
* It is okay to pass NULL for either of the output parameters; if you pass
* NULL for the `git_diff_patch`, then the text diff will not be calculated.
*
* @param range Output pointer to range of lines covered by the hunk;
* This range object is owned by the library and should not be freed.
* @param header Output pointer to the text of the hunk header
* This string is owned by the library and should not be freed.
* @param header_len Output pointer to store the length of the header text
* @param iterator The iterator object
* @return 0 on success, GIT_ITEROVER when done with current file, other
* value < 0 on error
* @param patch Output parameter for the delta patch object
* @param delta Output parameter for the delta object
* @param diff Diff list object
* @param idx Index into diff list
* @return 0 on success, other value < 0 on error
*/
GIT_EXTERN(int) git_diff_iterator_next_hunk(
git_diff_range **range,
const char **header,
size_t *header_len,
git_diff_iterator *iterator);
GIT_EXTERN(int) git_diff_get_patch(
git_diff_patch **patch,
const git_diff_delta **delta,
git_diff_list *diff,
size_t idx);
/**
* Return the next line of the current hunk of diffs.
*
* The `line_origin` output will tell you what type of line this is
* (e.g. was it added or removed or is it just context for the diff).
*
* The `content` will be a pointer to the file data that goes in the
* line. IT WILL NOT BE NUL TERMINATED. You have to use the `content_len`
* value and only process that many bytes of data from the content string.
*
* @param line_origin Output pointer to store a GIT_DIFF_LINE value for this
* next chunk of data. The value is a single character, not a buffer.
* @param content Output pointer to store the content of the diff; this
* string is owned by the library and should not be freed.
* @param content_len Output pointer to store the length of the content.
* @param iterator The iterator object
* @return 0 on success, GIT_ITEROVER when done with current line, other
* value < 0 on error
* Free a git_diff_patch object.
*/
GIT_EXTERN(int) git_diff_iterator_next_line(
char *line_origin, /**< GIT_DIFF_LINE_... value from above */
const char **content,
size_t *content_len,
git_diff_iterator *iterator);
GIT_EXTERN(void) git_diff_patch_free(
git_diff_patch *patch);
/**
* Iterate over a diff generating text output like "git diff --name-status".
*
* Returning a non-zero value from the callbacks will terminate the
* iteration and cause this return `GIT_EUSER`.
*
* @param diff A git_diff_list generated by one of the above functions.
* @param cb_data Reference pointer that will be passed to your callback.
* @param print_cb Callback to make per line of diff text.
* @return 0 on success, GIT_EUSER on non-zero callback, or error code
* Get the delta associated with a patch
*/
GIT_EXTERN(int) git_diff_print_compact(
git_diff_list *diff,
void *cb_data,
git_diff_data_fn print_cb);
GIT_EXTERN(const git_diff_delta *) git_diff_patch_delta(
git_diff_patch *patch);
/**
* Iterate over a diff generating text output like "git diff".
* Get the number of hunks in a patch
*/
GIT_EXTERN(size_t) git_diff_patch_num_hunks(
git_diff_patch *patch);
/**
* Get the information about a hunk in a patch
*
* This is a super easy way to generate a patch from a diff.
* Given a patch and a hunk index into the patch, this returns detailed
* information about that hunk. Any of the output pointers can be passed
* as NULL if you don't care about that particular piece of information.
*
* Returning a non-zero value from the callbacks will terminate the
* iteration and cause this return `GIT_EUSER`.
* @param range Output pointer to git_diff_range of hunk
* @param header Output pointer to header string for hunk. Unlike the
* content pointer for each line, this will be NUL-terminated
* @param header_len Output value of characters in header string
* @param lines_in_hunk Output count of total lines in this hunk
* @param patch Input pointer to patch object
* @param hunk_idx Input index of hunk to get information about
* @return 0 on success, GIT_ENOTFOUND if hunk_idx out of range, <0 on error
*/
GIT_EXTERN(int) git_diff_patch_get_hunk(
const git_diff_range **range,
const char **header,
size_t *header_len,
size_t *lines_in_hunk,
git_diff_patch *patch,
size_t hunk_idx);
/**
* Get the number of lines in a hunk.
*
* @param diff A git_diff_list generated by one of the above functions.
* @param cb_data Reference pointer that will be passed to your callbacks.
* @param print_cb Callback function to output lines of the diff. This
* same function will be called for file headers, hunk
* headers, and diff lines. Fortunately, you can probably
* use various GIT_DIFF_LINE constants to determine what
* text you are given.
* @return 0 on success, GIT_EUSER on non-zero callback, or error code
* @param patch The git_diff_patch object
* @param hunk_idx Index of the hunk
* @return Number of lines in hunk or -1 if invalid hunk index
*/
GIT_EXTERN(int) git_diff_print_patch(
git_diff_list *diff,
void *cb_data,
git_diff_data_fn print_cb);
GIT_EXTERN(int) git_diff_patch_num_lines_in_hunk(
git_diff_patch *patch,
size_t hunk_idx);
/**
* Query how many diff records are there in a diff list.
* Get data about a line in a hunk of a patch.
*
* You can optionally pass in a `git_delta_t` value if you want a count
* of just entries that match that delta type, or pass -1 for all delta
* records.
* Given a patch, a hunk index, and a line index in the hunk, this
* will return a lot of details about that line. If you pass a hunk
* index larger than the number of hunks or a line index larger than
* the number of lines in the hunk, this will return -1.
*
* @param diff A git_diff_list generated by one of the above functions
* @param delta_t A git_delta_t value to filter the count, or -1 for all records
* @return Count of number of deltas matching delta_t type
* @param line_origin A GIT_DIFF_LINE constant from above
* @param content Pointer to content of diff line, not NUL-terminated
* @param content_len Number of characters in content
* @param old_lineno Line number in old file or -1 if line is added
* @param new_lineno Line number in new file or -1 if line is deleted
* @param patch The patch to look in
* @param hunk_idx The index of the hunk
* @param line_of_index The index of the line in the hunk
* @return 0 on success, <0 on failure
*/
GIT_EXTERN(int) git_diff_entrycount(
git_diff_list *diff,
int delta_t);
GIT_EXTERN(int) git_diff_patch_get_line_in_hunk(
char *line_origin,
const char **content,
size_t *content_len,
int *old_lineno,
int *new_lineno,
git_diff_patch *patch,
size_t hunk_idx,
size_t line_of_hunk);
/**@}*/
......@@ -588,7 +595,7 @@ GIT_EXTERN(int) git_diff_entrycount(
GIT_EXTERN(int) git_diff_blobs(
git_blob *old_blob,
git_blob *new_blob,
git_diff_options *options,
const git_diff_options *options,
void *cb_data,
git_diff_file_fn file_cb,
git_diff_hunk_fn hunk_cb,
......
src/checkout.c
......@@ -126,7 +126,7 @@ static int blob_content_to_link(git_blob *blob, const char *path, bool can_symli
static int checkout_blob(
git_repository *repo,
git_oid *blob_oid,
const git_oid *blob_oid,
const char *path,
mode_t filemode,
bool can_symlink,
......@@ -150,7 +150,7 @@ static int checkout_blob(
static int checkout_diff_fn(
void *cb_data,
git_diff_delta *delta,
const git_diff_delta *delta,
float progress)
{
struct checkout_diff_data *data;
......
src/diff.c
......@@ -5,8 +5,6 @@
* a Linking Exception. For full terms see the included COPYING file.
*/
#include "common.h"
#include "git2/diff.h"
#include "git2/oid.h"
#include "diff.h"
#include "fileops.h"
#include "config.h"
......@@ -268,9 +266,17 @@ static int diff_delta__from_two(
delta->old_file.mode = old_mode;
delta->old_file.flags |= GIT_DIFF_FILE_VALID_OID;
git_oid_cpy(&delta->new_file.oid, new_oid ? new_oid : &new_entry->oid);
git_oid_cpy(&delta->new_file.oid, &new_entry->oid);
delta->new_file.size = new_entry->file_size;
delta->new_file.mode = new_mode;
if (new_oid) {
if ((diff->opts.flags & GIT_DIFF_REVERSE) != 0)
git_oid_cpy(&delta->old_file.oid, new_oid);
else
git_oid_cpy(&delta->new_file.oid, new_oid);
}
if (new_oid || !git_oid_iszero(&new_entry->oid))
delta->new_file.flags |= GIT_DIFF_FILE_VALID_OID;
......@@ -425,6 +431,11 @@ void git_diff_list_free(git_diff_list *diff)
GIT_REFCOUNT_DEC(diff, diff_list_free);
}
void git_diff_list_addref(git_diff_list *diff)
{
GIT_REFCOUNT_INC(diff);
}
static int oid_for_workdir_item(
git_repository *repo,
const git_index_entry *item,
......@@ -519,17 +530,17 @@ static int maybe_modified(
omode == nmode)
status = GIT_DELTA_UNMODIFIED;
/* if modes match and we have an unknown OID and a workdir iterator,
* then check deeper for matching
/* if we have an unknown OID and a workdir iterator, then check some
* circumstances that can accelerate things or need special handling
*/
else if (omode == nmode &&
git_oid_iszero(&nitem->oid) &&
else if (git_oid_iszero(&nitem->oid) &&
new_iter->type == GIT_ITERATOR_WORKDIR)
{
/* TODO: add check against index file st_mtime to avoid racy-git */
/* if they files look exactly alike, then we'll assume the same */
if (oitem->file_size == nitem->file_size &&
/* if the stat data looks exactly alike, then assume the same */
if (omode == nmode &&
oitem->file_size == nitem->file_size &&
(!(diff->diffcaps & GIT_DIFFCAPS_TRUST_CTIME) ||
(oitem->ctime.seconds == nitem->ctime.seconds)) &&
oitem->mtime.seconds == nitem->mtime.seconds &&
......@@ -554,16 +565,15 @@ static int maybe_modified(
status = GIT_DELTA_UNMODIFIED;
}
}
}
/* TODO: check git attributes so we will not have to read the file
* in if it is marked binary.
/* if we got here and decided that the files are modified, but we
* haven't calculated the OID of the new item, then calculate it now
*/
else if (oid_for_workdir_item(diff->repo, nitem, &noid) < 0)
if (status == GIT_DELTA_MODIFIED && git_oid_iszero(&nitem->oid)) {
if (oid_for_workdir_item(diff->repo, nitem, &noid) < 0)
return -1;
else if (git_oid_cmp(&oitem->oid, &noid) == 0 &&
omode == nmode)
else if (omode == nmode && git_oid_equal(&oitem->oid, &noid))
status = GIT_DELTA_UNMODIFIED;
/* store calculated oid so we don't have to recalc later */
......@@ -797,6 +807,28 @@ on_error:
return -1;
}
bool git_diff_delta__should_skip(
const git_diff_options *opts, const git_diff_delta *delta)
{
uint32_t flags = opts ? opts->flags : 0;
if (delta->status == GIT_DELTA_UNMODIFIED &&
(flags & GIT_DIFF_INCLUDE_UNMODIFIED) == 0)
return true;
if (delta->status == GIT_DELTA_IGNORED &&
(flags & GIT_DIFF_INCLUDE_IGNORED) == 0)
return true;
if (delta->status == GIT_DELTA_UNTRACKED &&
(flags & GIT_DIFF_INCLUDE_UNTRACKED) == 0)
return true;
return false;
}
int git_diff_merge(
git_diff_list *onto,
const git_diff_list *from)
......@@ -833,6 +865,14 @@ int git_diff_merge(
j++;
}
/* the ignore rules for the target may not match the source
* or the result of a merged delta could be skippable...
*/
if (git_diff_delta__should_skip(&onto->opts, delta)) {
git__free(delta);
continue;
}
if ((error = !delta ? -1 : git_vector_insert(&onto_new, delta)) < 0)
break;
}
......
src/diff.h
......@@ -7,6 +7,9 @@
#ifndef INCLUDE_diff_h__
#define INCLUDE_diff_h__
#include "git2/diff.h"
#include "git2/oid.h"
#include <stdio.h>
#include "vector.h"
#include "buffer.h"
......@@ -25,14 +28,17 @@ enum {
GIT_DIFFCAPS_USE_DEV = (1 << 4), /* use st_dev? */
};
#define MAX_DIFF_FILESIZE 0x20000000
typedef struct {
git_refcount rc;
git_diff_delta delta;
} git_diff_delta_refcounted;
struct git_diff_list {
git_refcount rc;
git_repository *repo;
git_diff_options opts;
git_vector pathspec;
git_vector deltas; /* vector of git_diff_file_delta */
git_vector deltas; /* vector of git_diff_delta_refcounted */
git_pool pool;
git_iterator_type_t old_src;
git_iterator_type_t new_src;
......@@ -42,27 +48,10 @@ struct git_diff_list {
extern void git_diff__cleanup_modes(
uint32_t diffcaps, uint32_t *omode, uint32_t *nmode);
/**
* Return the maximum possible number of files in the diff.
*
* NOTE: This number has to be treated as an upper bound on the number of
* files that have changed if the diff is with the working directory.
*
* Why?! For efficiency, we defer loading the file contents as long as
* possible, so if a file has been "touched" in the working directory and
* then reverted to the original content, it may get stored in the diff list
* as MODIFIED along with a flag that the status should be reconfirmed when
* it is actually loaded into memory. When that load happens, it could get
* flipped to UNMODIFIED. If unmodified files are being skipped, then the
* iterator will skip that file and this number may be too high.
*
* This behavior is true of `git_diff_foreach` as well, but the only
* implication there is that the `progress` value would not advance evenly.
*
* @param iterator The iterator object
* @return The maximum number of files to be iterated over
*/
int git_diff_iterator__max_files(git_diff_iterator *iterator);
extern void git_diff_list_addref(git_diff_list *diff);
extern bool git_diff_delta__should_skip(
const git_diff_options *opts, const git_diff_delta *delta);
#endif
src/diff_output.c
......@@ -5,58 +5,13 @@
* a Linking Exception. For full terms see the included COPYING file.
*/
#include "common.h"
#include "git2/diff.h"
#include "git2/attr.h"
#include "git2/blob.h"
#include "git2/oid.h"
#include "xdiff/xdiff.h"
#include "diff_output.h"
#include <ctype.h>
#include "diff.h"
#include "map.h"
#include "fileops.h"
#include "filter.h"
/*
* A diff_delta_context represents all of the information that goes into
* processing the diff of an observed file change. In the case of the
* git_diff_foreach() call it is an emphemeral structure that is filled
* in to execute each diff. In the case of a git_diff_iterator, it holds
* most of the information for the diff in progress.
*
* As each delta is processed, it goes through 3 phases: prep, load, exec.
*
* - In the prep phase, we just set the delta and quickly check the file
* attributes to see if it should be treated as binary.
* - In the load phase, we actually load the file content into memory.
* At this point, if we had deferred calculating OIDs, we might have to
* correct the delta to be UNMODIFIED.
* - In the exec phase, we actually run the diff and execute the callbacks.
* For foreach, this is just a pass-through to the user's callbacks. For
* iterators, we record the hunks and data spans into memory.
*/
typedef struct {
git_repository *repo;
git_diff_options *opts;
xdemitconf_t xdiff_config;
xpparam_t xdiff_params;
git_diff_delta *delta;
uint32_t prepped : 1;
uint32_t loaded : 1;
uint32_t diffable : 1;
uint32_t diffed : 1;
git_iterator_type_t old_src;
git_iterator_type_t new_src;
git_blob *old_blob;
git_blob *new_blob;
git_map old_data;
git_map new_data;
void *cb_data;
git_diff_hunk_fn per_hunk;
git_diff_data_fn per_line;
int cb_error;
git_diff_range range;
} diff_delta_context;
static int read_next_int(const char **str, int *value)
{
const char *scan = *str;
......@@ -96,55 +51,8 @@ static int parse_hunk_header(git_diff_range *range, const char *header)
return 0;
}
static int format_hunk_header(char *header, size_t len, git_diff_range *range)
{
if (range->old_lines != 1) {
if (range->new_lines != 1)
return p_snprintf(
header, len, "@@ -%d,%d +%d,%d @@",
range->old_start, range->old_lines,
range->new_start, range->new_lines);
else
return p_snprintf(
header, len, "@@ -%d,%d +%d @@",
range->old_start, range->old_lines, range->new_start);
} else {
if (range->new_lines != 1)
return p_snprintf(
header, len, "@@ -%d +%d,%d @@",
range->old_start, range->new_start, range->new_lines);
else
return p_snprintf(
header, len, "@@ -%d +%d @@",
range->old_start, range->new_start);
}
}
static bool diff_delta_is_ambiguous(git_diff_delta *delta)
{
return (git_oid_iszero(&delta->new_file.oid) &&
(delta->new_file.flags & GIT_DIFF_FILE_VALID_OID) == 0 &&
delta->status == GIT_DELTA_MODIFIED);
}
static bool diff_delta_should_skip(git_diff_options *opts, git_diff_delta *delta)
{
if (delta->status == GIT_DELTA_UNMODIFIED &&
(opts->flags & GIT_DIFF_INCLUDE_UNMODIFIED) == 0)
return true;
if (delta->status == GIT_DELTA_IGNORED &&
(opts->flags & GIT_DIFF_INCLUDE_IGNORED) == 0)
return true;
if (delta->status == GIT_DELTA_UNTRACKED &&
(opts->flags & GIT_DIFF_INCLUDE_UNTRACKED) == 0)
return true;
return false;
}
#define BINARY_DIFF_FLAGS (GIT_DIFF_FILE_BINARY|GIT_DIFF_FILE_NOT_BINARY)
#define KNOWN_BINARY_FLAGS (GIT_DIFF_FILE_BINARY|GIT_DIFF_FILE_NOT_BINARY)
#define NOT_BINARY_FLAGS (GIT_DIFF_FILE_NOT_BINARY|GIT_DIFF_FILE_NO_DATA)
static int update_file_is_binary_by_attr(
git_repository *repo, git_diff_file *file)
......@@ -173,8 +81,6 @@ static void update_delta_is_binary(git_diff_delta *delta)
(delta->new_file.flags & GIT_DIFF_FILE_BINARY) != 0)
delta->binary = 1;
#define NOT_BINARY_FLAGS (GIT_DIFF_FILE_NOT_BINARY|GIT_DIFF_FILE_NO_DATA)
else if ((delta->old_file.flags & NOT_BINARY_FLAGS) != 0 &&
(delta->new_file.flags & NOT_BINARY_FLAGS) != 0)
delta->binary = 0;
......@@ -182,10 +88,11 @@ static void update_delta_is_binary(git_diff_delta *delta)
/* otherwise leave delta->binary value untouched */
}
static int diff_delta_is_binary_by_attr(diff_delta_context *ctxt)
static int diff_delta_is_binary_by_attr(
diff_context *ctxt, git_diff_patch *patch)
{
int error = 0, mirror_new;
git_diff_delta *delta = ctxt->delta;
git_diff_delta *delta = patch->delta;
delta->binary = -1;
......@@ -200,7 +107,7 @@ static int diff_delta_is_binary_by_attr(diff_delta_context *ctxt)
}
/* check if user is forcing us to text diff these files */
if (ctxt->opts->flags & GIT_DIFF_FORCE_TEXT) {
if (ctxt->opts && (ctxt->opts->flags & GIT_DIFF_FORCE_TEXT) != 0) {
delta->old_file.flags |= GIT_DIFF_FILE_NOT_BINARY;
delta->new_file.flags |= GIT_DIFF_FILE_NOT_BINARY;
delta->binary = 0;
......@@ -214,7 +121,7 @@ static int diff_delta_is_binary_by_attr(diff_delta_context *ctxt)
mirror_new = (delta->new_file.path == delta->old_file.path ||
strcmp(delta->new_file.path, delta->old_file.path) == 0);
if (mirror_new)
delta->new_file.flags |= (delta->old_file.flags & BINARY_DIFF_FLAGS);
delta->new_file.flags |= (delta->old_file.flags & KNOWN_BINARY_FLAGS);
else
error = update_file_is_binary_by_attr(ctxt->repo, &delta->new_file);
......@@ -224,11 +131,13 @@ static int diff_delta_is_binary_by_attr(diff_delta_context *ctxt)
}
static int diff_delta_is_binary_by_content(
diff_delta_context *ctxt, git_diff_file *file, git_map *map)
diff_context *ctxt, git_diff_delta *delta, git_diff_file *file, git_map *map)
{
git_buf search;
if ((file->flags & BINARY_DIFF_FLAGS) == 0) {
GIT_UNUSED(ctxt);
if ((file->flags & KNOWN_BINARY_FLAGS) == 0) {
search.ptr = map->data;
search.size = min(map->len, 4000);
......@@ -238,17 +147,17 @@ static int diff_delta_is_binary_by_content(
file->flags |= GIT_DIFF_FILE_NOT_BINARY;
}
update_delta_is_binary(ctxt->delta);
update_delta_is_binary(delta);
return 0;
}
static int diff_delta_is_binary_by_size(
diff_delta_context *ctxt, git_diff_file *file)
diff_context *ctxt, git_diff_delta *delta, git_diff_file *file)
{
git_off_t threshold = MAX_DIFF_FILESIZE;
if ((file->flags & BINARY_DIFF_FLAGS) != 0)
if ((file->flags & KNOWN_BINARY_FLAGS) != 0)
return 0;
if (ctxt && ctxt->opts) {
......@@ -262,13 +171,13 @@ static int diff_delta_is_binary_by_size(
if (file->size > threshold)
file->flags |= GIT_DIFF_FILE_BINARY;
update_delta_is_binary(ctxt->delta);
update_delta_is_binary(delta);
return 0;
}
static void setup_xdiff_options(
git_diff_options *opts, xdemitconf_t *cfg, xpparam_t *param)
const git_diff_options *opts, xdemitconf_t *cfg, xpparam_t *param)
{
memset(cfg, 0, sizeof(xdemitconf_t));
memset(param, 0, sizeof(xpparam_t));
......@@ -289,8 +198,10 @@ static void setup_xdiff_options(
param->flags |= XDF_IGNORE_WHITESPACE_AT_EOL;
}
static int get_blob_content(
diff_delta_context *ctxt,
diff_context *ctxt,
git_diff_delta *delta,
git_diff_file *file,
git_map *map,
git_blob **blob)
......@@ -318,9 +229,9 @@ static int get_blob_content(
}
/* if blob is too large to diff, mark as binary */
if ((error = diff_delta_is_binary_by_size(ctxt, file)) < 0)
if ((error = diff_delta_is_binary_by_size(ctxt, delta, file)) < 0)
return error;
if (ctxt->delta->binary == 1)
if (delta->binary == 1)
return 0;
if (odb_obj != NULL) {
......@@ -336,11 +247,12 @@ static int get_blob_content(
map->data = (void *)git_blob_rawcontent(*blob);
map->len = git_blob_rawsize(*blob);
return diff_delta_is_binary_by_content(ctxt, file, map);
return diff_delta_is_binary_by_content(ctxt, delta, file, map);
}
static int get_workdir_content(
diff_delta_context *ctxt,
diff_context *ctxt,
git_diff_delta *delta,
git_diff_file *file,
git_map *map)
{
......@@ -386,8 +298,8 @@ static int get_workdir_content(
if (!file->size)
file->size = git_futils_filesize(fd);
if ((error = diff_delta_is_binary_by_size(ctxt, file)) < 0 ||
ctxt->delta->binary == 1)
if ((error = diff_delta_is_binary_by_size(ctxt, delta, file)) < 0 ||
delta->binary == 1)
goto close_and_cleanup;
error = git_filters_load(
......@@ -428,7 +340,7 @@ close_and_cleanup:
}
if (!error)
error = diff_delta_is_binary_by_content(ctxt, file, map);
error = diff_delta_is_binary_by_content(ctxt, delta, file, map);
cleanup:
git_buf_free(&path);
......@@ -454,78 +366,101 @@ static void release_content(git_diff_file *file, git_map *map, git_blob *blob)
}
}
static void diff_delta_init_context(
diff_delta_context *ctxt,
static void diff_context_init(
diff_context *ctxt,
git_diff_list *diff,
git_repository *repo,
git_diff_options *opts,
git_iterator_type_t old_src,
git_iterator_type_t new_src)
const git_diff_options *opts,
void *data,
git_diff_file_fn file_cb,
git_diff_hunk_fn hunk_cb,
git_diff_data_fn data_cb)
{
memset(ctxt, 0, sizeof(diff_delta_context));
memset(ctxt, 0, sizeof(diff_context));
ctxt->repo = repo;
ctxt->diff = diff;
ctxt->opts = opts;
ctxt->old_src = old_src;
ctxt->new_src = new_src;
ctxt->file_cb = file_cb;
ctxt->hunk_cb = hunk_cb;
ctxt->data_cb = data_cb;
ctxt->cb_data = data;
ctxt->cb_error = 0;
setup_xdiff_options(opts, &ctxt->xdiff_config, &ctxt->xdiff_params);
setup_xdiff_options(ctxt->opts, &ctxt->xdiff_config, &ctxt->xdiff_params);
}
static void diff_delta_init_context_from_diff_list(
diff_delta_context *ctxt,
git_diff_list *diff)
static int diff_delta_file_callback(
diff_context *ctxt, git_diff_delta *delta, size_t idx)
{
diff_delta_init_context(
ctxt, diff->repo, &diff->opts, diff->old_src, diff->new_src);
float progress;
if (!ctxt->file_cb)
return 0;
progress = ctxt->diff ? ((float)idx / ctxt->diff->deltas.length) : 1.0f;
if (ctxt->file_cb(ctxt->cb_data, delta, progress) != 0)
ctxt->cb_error = GIT_EUSER;
return ctxt->cb_error;
}
static void diff_delta_unload(diff_delta_context *ctxt)
static void diff_patch_init(
diff_context *ctxt, git_diff_patch *patch)
{
ctxt->diffed = 0;
memset(patch, 0, sizeof(git_diff_patch));
if (ctxt->loaded) {
release_content(&ctxt->delta->old_file, &ctxt->old_data, ctxt->old_blob);
release_content(&ctxt->delta->new_file, &ctxt->new_data, ctxt->new_blob);
ctxt->loaded = 0;
}
patch->diff = ctxt->diff;
patch->ctxt = ctxt;
ctxt->delta = NULL;
ctxt->prepped = 0;
if (patch->diff) {
patch->old_src = patch->diff->old_src;
patch->new_src = patch->diff->new_src;
} else {
patch->old_src = patch->new_src = GIT_ITERATOR_TREE;
}
}
static int diff_delta_prep(diff_delta_context *ctxt)
static git_diff_patch *diff_patch_alloc(
diff_context *ctxt, git_diff_delta *delta)
{
int error;
git_diff_patch *patch = git__malloc(sizeof(git_diff_patch));
if (!patch)
return NULL;
if (ctxt->prepped || !ctxt->delta)
return 0;
diff_patch_init(ctxt, patch);
error = diff_delta_is_binary_by_attr(ctxt);
git_diff_list_addref(patch->diff);
ctxt->prepped = !error;
GIT_REFCOUNT_INC(patch);
return error;
patch->delta = delta;
patch->flags = GIT_DIFF_PATCH_ALLOCATED;
return patch;
}
static int diff_delta_load(diff_delta_context *ctxt)
static int diff_patch_load(
diff_context *ctxt, git_diff_patch *patch)
{
int error = 0;
git_diff_delta *delta = ctxt->delta;
git_diff_delta *delta = patch->delta;
bool check_if_unmodified = false;
if (ctxt->loaded || !ctxt->delta)
if ((patch->flags & GIT_DIFF_PATCH_LOADED) != 0)
return 0;
if (!ctxt->prepped && (error = diff_delta_prep(ctxt)) < 0)
goto cleanup;
error = diff_delta_is_binary_by_attr(ctxt, patch);
ctxt->old_data.data = "";
ctxt->old_data.len = 0;
ctxt->old_blob = NULL;
patch->old_data.data = "";
patch->old_data.len = 0;
patch->old_blob = NULL;
ctxt->new_data.data = "";
ctxt->new_data.len = 0;
ctxt->new_blob = NULL;
patch->new_data.data = "";
patch->new_data.len = 0;
patch->new_blob = NULL;
if (delta->binary == 1)
goto cleanup;
......@@ -557,36 +492,38 @@ static int diff_delta_load(diff_delta_context *ctxt)
*/
if ((delta->old_file.flags & GIT_DIFF_FILE_NO_DATA) == 0 &&
ctxt->old_src == GIT_ITERATOR_WORKDIR) {
patch->old_src == GIT_ITERATOR_WORKDIR) {
if ((error = get_workdir_content(
ctxt, &delta->old_file, &ctxt->old_data)) < 0)
ctxt, delta, &delta->old_file, &patch->old_data)) < 0)
goto cleanup;
if (delta->binary == 1)
goto cleanup;
}
if ((delta->new_file.flags & GIT_DIFF_FILE_NO_DATA) == 0 &&
ctxt->new_src == GIT_ITERATOR_WORKDIR) {
patch->new_src == GIT_ITERATOR_WORKDIR) {
if ((error = get_workdir_content(
ctxt, &delta->new_file, &ctxt->new_data)) < 0)
ctxt, delta, &delta->new_file, &patch->new_data)) < 0)
goto cleanup;
if (delta->binary == 1)
goto cleanup;
}
if ((delta->old_file.flags & GIT_DIFF_FILE_NO_DATA) == 0 &&
ctxt->old_src != GIT_ITERATOR_WORKDIR) {
patch->old_src != GIT_ITERATOR_WORKDIR) {
if ((error = get_blob_content(
ctxt, &delta->old_file, &ctxt->old_data, &ctxt->old_blob)) < 0)
ctxt, delta, &delta->old_file,
&patch->old_data, &patch->old_blob)) < 0)
goto cleanup;
if (delta->binary == 1)
goto cleanup;
}
if ((delta->new_file.flags & GIT_DIFF_FILE_NO_DATA) == 0 &&
ctxt->new_src != GIT_ITERATOR_WORKDIR) {
patch->new_src != GIT_ITERATOR_WORKDIR) {
if ((error = get_blob_content(
ctxt, &delta->new_file, &ctxt->new_data, &ctxt->new_blob)) < 0)
ctxt, delta, &delta->new_file,
&patch->new_data, &patch->new_blob)) < 0)
goto cleanup;
if (delta->binary == 1)
goto cleanup;
......@@ -606,33 +543,34 @@ static int diff_delta_load(diff_delta_context *ctxt)
}
cleanup:
/* last change to update binary flag */
if (delta->binary == -1)
update_delta_is_binary(delta);
ctxt->loaded = !error;
if (!error) {
patch->flags |= GIT_DIFF_PATCH_LOADED;
/* flag if we would want to diff the contents of these files */
if (ctxt->loaded)
ctxt->diffable =
(delta->binary != 1 &&
if (delta->binary != 1 &&
delta->status != GIT_DELTA_UNMODIFIED &&
(ctxt->old_data.len || ctxt->new_data.len) &&
git_oid_cmp(&delta->old_file.oid, &delta->new_file.oid));
(patch->old_data.len || patch->new_data.len) &&
!git_oid_equal(&delta->old_file.oid, &delta->new_file.oid))
patch->flags |= GIT_DIFF_PATCH_DIFFABLE;
}
return error;
}
static int diff_delta_cb(void *priv, mmbuffer_t *bufs, int len)
static int diff_patch_cb(void *priv, mmbuffer_t *bufs, int len)
{
diff_delta_context *ctxt = priv;
git_diff_patch *patch = priv;
diff_context *ctxt = patch->ctxt;
if (len == 1) {
if ((ctxt->cb_error = parse_hunk_header(&ctxt->range, bufs[0].ptr)) < 0)
ctxt->cb_error = parse_hunk_header(&ctxt->cb_range, bufs[0].ptr);
if (ctxt->cb_error < 0)
return ctxt->cb_error;
if (ctxt->per_hunk != NULL &&
ctxt->per_hunk(ctxt->cb_data, ctxt->delta, &ctxt->range,
if (ctxt->hunk_cb != NULL &&
ctxt->hunk_cb(ctxt->cb_data, patch->delta, &ctxt->cb_range,
bufs[0].ptr, bufs[0].size))
ctxt->cb_error = GIT_EUSER;
}
......@@ -644,9 +582,9 @@ static int diff_delta_cb(void *priv, mmbuffer_t *bufs, int len)
(*bufs[0].ptr == '-') ? GIT_DIFF_LINE_DELETION :
GIT_DIFF_LINE_CONTEXT;
if (ctxt->per_line != NULL &&
ctxt->per_line(ctxt->cb_data, ctxt->delta, &ctxt->range, origin,
bufs[1].ptr, bufs[1].size))
if (ctxt->data_cb != NULL &&
ctxt->data_cb(ctxt->cb_data, patch->delta, &ctxt->cb_range,
origin, bufs[1].ptr, bufs[1].size))
ctxt->cb_error = GIT_EUSER;
}
......@@ -661,105 +599,276 @@ static int diff_delta_cb(void *priv, mmbuffer_t *bufs, int len)
(*bufs[0].ptr == '-') ? GIT_DIFF_LINE_ADD_EOFNL :
GIT_DIFF_LINE_CONTEXT;
if (ctxt->per_line != NULL &&
ctxt->per_line(ctxt->cb_data, ctxt->delta, &ctxt->range, origin,
bufs[2].ptr, bufs[2].size))
if (ctxt->data_cb != NULL &&
ctxt->data_cb(ctxt->cb_data, patch->delta, &ctxt->cb_range,
origin, bufs[2].ptr, bufs[2].size))
ctxt->cb_error = GIT_EUSER;
}
return ctxt->cb_error;
}
static int diff_delta_exec(
diff_delta_context *ctxt,
void *cb_data,
git_diff_hunk_fn per_hunk,
git_diff_data_fn per_line)
static int diff_patch_generate(
diff_context *ctxt, git_diff_patch *patch)
{
int error = 0;
xdemitcb_t xdiff_callback;
mmfile_t old_xdiff_data, new_xdiff_data;
if (ctxt->diffed || !ctxt->delta)
if ((patch->flags & GIT_DIFF_PATCH_DIFFED) != 0)
return 0;
if (!ctxt->loaded && (error = diff_delta_load(ctxt)) < 0)
goto cleanup;
if ((patch->flags & GIT_DIFF_PATCH_LOADED) == 0)
if ((error = diff_patch_load(ctxt, patch)) < 0)
return error;
if (!ctxt->diffable)
if ((patch->flags & GIT_DIFF_PATCH_DIFFABLE) == 0)
return 0;
ctxt->cb_data = cb_data;
ctxt->per_hunk = per_hunk;
ctxt->per_line = per_line;
ctxt->cb_error = 0;
if (ctxt)
patch->ctxt = ctxt;
memset(&xdiff_callback, 0, sizeof(xdiff_callback));
xdiff_callback.outf = diff_delta_cb;
xdiff_callback.priv = ctxt;
xdiff_callback.outf = diff_patch_cb;
xdiff_callback.priv = patch;
old_xdiff_data.ptr = ctxt->old_data.data;
old_xdiff_data.size = ctxt->old_data.len;
new_xdiff_data.ptr = ctxt->new_data.data;
new_xdiff_data.size = ctxt->new_data.len;
old_xdiff_data.ptr = patch->old_data.data;
old_xdiff_data.size = patch->old_data.len;
new_xdiff_data.ptr = patch->new_data.data;
new_xdiff_data.size = patch->new_data.len;
xdl_diff(&old_xdiff_data, &new_xdiff_data,
&ctxt->xdiff_params, &ctxt->xdiff_config, &xdiff_callback);
error = ctxt->cb_error;
cleanup:
ctxt->diffed = !error;
if (!error)
patch->flags |= GIT_DIFF_PATCH_DIFFED;
return error;
}
static void diff_patch_unload(git_diff_patch *patch)
{
if ((patch->flags & GIT_DIFF_PATCH_DIFFED) != 0) {
patch->flags = (patch->flags & ~GIT_DIFF_PATCH_DIFFED);
patch->hunks_size = 0;
patch->lines_size = 0;
}
if ((patch->flags & GIT_DIFF_PATCH_LOADED) != 0) {
patch->flags = (patch->flags & ~GIT_DIFF_PATCH_LOADED);
release_content(
&patch->delta->old_file, &patch->old_data, patch->old_blob);
release_content(
&patch->delta->new_file, &patch->new_data, patch->new_blob);
}
}
static void diff_patch_free(git_diff_patch *patch)
{
diff_patch_unload(patch);
git__free(patch->lines);
patch->lines = NULL;
patch->lines_asize = 0;
git__free(patch->hunks);
patch->hunks = NULL;
patch->hunks_asize = 0;
if (!(patch->flags & GIT_DIFF_PATCH_ALLOCATED))
return;
patch->flags = 0;
git_diff_list_free(patch->diff); /* decrements refcount */
git__free(patch);
}
#define MAX_HUNK_STEP 128
#define MIN_HUNK_STEP 8
#define MAX_LINE_STEP 256
#define MIN_LINE_STEP 8
static int diff_patch_hunk_cb(
void *cb_data,
const git_diff_delta *delta,
const git_diff_range *range,
const char *header,
size_t header_len)
{
git_diff_patch *patch = cb_data;
diff_patch_hunk *hunk;
GIT_UNUSED(delta);
if (patch->hunks_size >= patch->hunks_asize) {
size_t new_size;
diff_patch_hunk *new_hunks;
if (patch->hunks_asize > MAX_HUNK_STEP)
new_size = patch->hunks_asize + MAX_HUNK_STEP;
else
new_size = patch->hunks_asize * 2;
if (new_size < MIN_HUNK_STEP)
new_size = MIN_HUNK_STEP;
new_hunks = git__realloc(
patch->hunks, new_size * sizeof(diff_patch_hunk));
if (!new_hunks)
return -1;
patch->hunks = new_hunks;
patch->hunks_asize = new_size;
}
hunk = &patch->hunks[patch->hunks_size++];
memcpy(&hunk->range, range, sizeof(hunk->range));
assert(header_len + 1 < sizeof(hunk->header));
memcpy(&hunk->header, header, header_len);
hunk->header[header_len] = '\0';
hunk->header_len = header_len;
hunk->line_start = patch->lines_size;
hunk->line_count = 0;
return 0;
}
static int diff_patch_line_cb(
void *cb_data,
const git_diff_delta *delta,
const git_diff_range *range,
char line_origin,
const char *content,
size_t content_len)
{
git_diff_patch *patch = cb_data;
diff_patch_hunk *hunk;
diff_patch_line *last, *line;
GIT_UNUSED(delta);
GIT_UNUSED(range);
assert(patch->hunks_size > 0);
assert(patch->hunks != NULL);
hunk = &patch->hunks[patch->hunks_size - 1];
if (patch->lines_size >= patch->lines_asize) {
size_t new_size;
diff_patch_line *new_lines;
if (patch->lines_asize > MAX_LINE_STEP)
new_size = patch->lines_asize + MAX_LINE_STEP;
else
new_size = patch->lines_asize * 2;
if (new_size < MIN_LINE_STEP)
new_size = MIN_LINE_STEP;
new_lines = git__realloc(
patch->lines, new_size * sizeof(diff_patch_line));
if (!new_lines)
return -1;
patch->lines = new_lines;
patch->lines_asize = new_size;
}
last = (patch->lines_size > 0) ?
&patch->lines[patch->lines_size - 1] : NULL;
line = &patch->lines[patch->lines_size++];
line->ptr = content;
line->len = content_len;
line->origin = line_origin;
/* do some bookkeeping so we can provide old/new line numbers */
for (line->lines = 0; content_len > 0; --content_len) {
if (*content++ == '\n')
++line->lines;
}
if (!last) {
line->oldno = hunk->range.old_start;
line->newno = hunk->range.new_start;
} else {
switch (last->origin) {
case GIT_DIFF_LINE_ADDITION:
line->oldno = last->oldno;
line->newno = last->newno + last->lines;
break;
case GIT_DIFF_LINE_DELETION:
line->oldno = last->oldno + last->lines;
line->newno = last->newno;
break;
default:
line->oldno = last->oldno + last->lines;
line->newno = last->newno + last->lines;
break;
}
}
hunk->line_count++;
return 0;
}
int git_diff_foreach(
git_diff_list *diff,
void *data,
void *cb_data,
git_diff_file_fn file_cb,
git_diff_hunk_fn hunk_cb,
git_diff_data_fn line_cb)
git_diff_data_fn data_cb)
{
int error = 0;
diff_delta_context ctxt;
diff_context ctxt;
size_t idx;
git_diff_patch patch;
diff_delta_init_context_from_diff_list(&ctxt, diff);
diff_context_init(
&ctxt, diff, diff->repo, &diff->opts,
cb_data, file_cb, hunk_cb, data_cb);
git_vector_foreach(&diff->deltas, idx, ctxt.delta) {
if (diff_delta_is_ambiguous(ctxt.delta))
if ((error = diff_delta_load(&ctxt)) < 0)
goto cleanup;
diff_patch_init(&ctxt, &patch);
if (diff_delta_should_skip(ctxt.opts, ctxt.delta))
git_vector_foreach(&diff->deltas, idx, patch.delta) {
/* check flags against patch status */
if (git_diff_delta__should_skip(ctxt.opts, patch.delta))
continue;
if ((error = diff_delta_load(&ctxt)) < 0)
goto cleanup;
if (!(error = diff_patch_load(&ctxt, &patch))) {
if (file_cb != NULL &&
file_cb(data, ctxt.delta, (float)idx / diff->deltas.length) != 0)
{
error = GIT_EUSER;
goto cleanup;
}
/* invoke file callback */
error = diff_delta_file_callback(&ctxt, patch.delta, idx);
error = diff_delta_exec(&ctxt, data, hunk_cb, line_cb);
/* generate diffs and invoke hunk and line callbacks */
if (!error)
error = diff_patch_generate(&ctxt, &patch);
cleanup:
diff_delta_unload(&ctxt);
diff_patch_unload(&patch);
}
if (error < 0)
break;
}
if (error == GIT_EUSER)
giterr_clear();
giterr_clear(); /* don't let error message leak */
return error;
}
typedef struct {
git_diff_list *diff;
git_diff_data_fn print_cb;
......@@ -778,14 +887,11 @@ static char pick_suffix(int mode)
return ' ';
}
static int print_compact(void *data, git_diff_delta *delta, float progress)
char git_diff_status_char(git_delta_t status)
{
diff_print_info *pi = data;
char code, old_suffix, new_suffix;
GIT_UNUSED(progress);
char code;
switch (delta->status) {
switch (status) {
case GIT_DELTA_ADDED: code = 'A'; break;
case GIT_DELTA_DELETED: code = 'D'; break;
case GIT_DELTA_MODIFIED: code = 'M'; break;
......@@ -793,10 +899,21 @@ static int print_compact(void *data, git_diff_delta *delta, float progress)
case GIT_DELTA_COPIED: code = 'C'; break;
case GIT_DELTA_IGNORED: code = 'I'; break;
case GIT_DELTA_UNTRACKED: code = '?'; break;
default: code = 0;
default: code = ' '; break;
}
if (!code)
return code;
}
static int print_compact(
void *data, const git_diff_delta *delta, float progress)
{
diff_print_info *pi = data;
char old_suffix, new_suffix, code = git_diff_status_char(delta->status);
GIT_UNUSED(progress);
if (code == ' ')
return 0;
old_suffix = pick_suffix(delta->old_file.mode);
......@@ -851,8 +968,7 @@ int git_diff_print_compact(
return error;
}
static int print_oid_range(diff_print_info *pi, git_diff_delta *delta)
static int print_oid_range(diff_print_info *pi, const git_diff_delta *delta)
{
char start_oid[8], end_oid[8];
......@@ -882,7 +998,8 @@ static int print_oid_range(diff_print_info *pi, git_diff_delta *delta)
return 0;
}
static int print_patch_file(void *data, git_diff_delta *delta, float progress)
static int print_patch_file(
void *data, const git_diff_delta *delta, float progress)
{
diff_print_info *pi = data;
const char *oldpfx = pi->diff->opts.old_prefix;
......@@ -949,8 +1066,8 @@ static int print_patch_file(void *data, git_diff_delta *delta, float progress)
static int print_patch_hunk(
void *data,
git_diff_delta *d,
git_diff_range *r,
const git_diff_delta *d,
const git_diff_range *r,
const char *header,
size_t header_len)
{
......@@ -972,8 +1089,8 @@ static int print_patch_hunk(
static int print_patch_line(
void *data,
git_diff_delta *delta,
git_diff_range *range,
const git_diff_delta *delta,
const git_diff_range *range,
char line_origin, /* GIT_DIFF_LINE value from above */
const char *content,
size_t content_len)
......@@ -1024,30 +1141,6 @@ int git_diff_print_patch(
return error;
}
int git_diff_entrycount(git_diff_list *diff, int delta_t)
{
int count = 0;
unsigned int i;
git_diff_delta *delta;
assert(diff);
git_vector_foreach(&diff->deltas, i, delta) {
if (diff_delta_should_skip(&diff->opts, delta))
continue;
if (delta_t < 0 || delta->status == (git_delta_t)delta_t)
count++;
}
/* It is possible that this has overcounted the number of diffs because
* there may be entries that are marked as MODIFIED due to differences
* in stat() output that will turn out to be the same once we calculate
* the actual SHA of the data on disk.
*/
return count;
}
static void set_data_from_blob(
git_blob *blob, git_map *map, git_diff_file *file)
......@@ -1056,6 +1149,7 @@ static void set_data_from_blob(
map->data = (char *)git_blob_rawcontent(blob);
file->size = map->len = git_blob_rawsize(blob);
git_oid_cpy(&file->oid, git_object_id((const git_object *)blob));
file->mode = 0644;
} else {
map->data = "";
file->size = map->len = 0;
......@@ -1066,433 +1160,254 @@ static void set_data_from_blob(
int git_diff_blobs(
git_blob *old_blob,
git_blob *new_blob,
git_diff_options *options,
const git_diff_options *options,
void *cb_data,
git_diff_file_fn file_cb,
git_diff_hunk_fn hunk_cb,
git_diff_data_fn line_cb)
git_diff_data_fn data_cb)
{
int error;
diff_delta_context ctxt;
git_diff_delta delta;
git_blob *new, *old;
git_repository *repo;
new = new_blob;
old = old_blob;
diff_context ctxt;
git_diff_delta delta;
git_diff_patch patch;
if (options && (options->flags & GIT_DIFF_REVERSE)) {
git_blob *swap = old;
old = new;
new = swap;
git_blob *swap = old_blob;
old_blob = new_blob;
new_blob = swap;
}
if (new)
repo = git_object_owner((git_object *)new);
else if (old)
repo = git_object_owner((git_object *)old);
if (new_blob)
repo = git_object_owner((git_object *)new_blob);
else if (old_blob)
repo = git_object_owner((git_object *)old_blob);
else
repo = NULL;
diff_delta_init_context(
&ctxt, repo, options, GIT_ITERATOR_TREE, GIT_ITERATOR_TREE);
diff_context_init(
&ctxt, NULL, repo, options,
cb_data, file_cb, hunk_cb, data_cb);
diff_patch_init(&ctxt, &patch);
/* populate a "fake" delta record */
/* create a fake delta record and simulate diff_patch_load */
memset(&delta, 0, sizeof(delta));
delta.binary = -1;
set_data_from_blob(old, &ctxt.old_data, &delta.old_file);
set_data_from_blob(new, &ctxt.new_data, &delta.new_file);
set_data_from_blob(old_blob, &patch.old_data, &delta.old_file);
set_data_from_blob(new_blob, &patch.new_data, &delta.new_file);
delta.status = new ?
(old ? GIT_DELTA_MODIFIED : GIT_DELTA_ADDED) :
(old ? GIT_DELTA_DELETED : GIT_DELTA_UNTRACKED);
delta.status = new_blob ?
(old_blob ? GIT_DELTA_MODIFIED : GIT_DELTA_ADDED) :
(old_blob ? GIT_DELTA_DELETED : GIT_DELTA_UNTRACKED);
if (git_oid_cmp(&delta.new_file.oid, &delta.old_file.oid) == 0)
delta.status = GIT_DELTA_UNMODIFIED;
ctxt.delta = &delta;
patch.delta = &delta;
if ((error = diff_delta_prep(&ctxt)) < 0)
goto cleanup;
if (delta.binary == -1) {
if ((error = diff_delta_is_binary_by_content(
&ctxt, &delta.old_file, &ctxt.old_data)) < 0 ||
&ctxt, &delta, &delta.old_file, &patch.old_data)) < 0 ||
(error = diff_delta_is_binary_by_content(
&ctxt, &delta.new_file, &ctxt.new_data)) < 0)
&ctxt, &delta, &delta.new_file, &patch.new_data)) < 0)
goto cleanup;
}
ctxt.loaded = 1;
ctxt.diffable = (delta.binary != 1 && delta.status != GIT_DELTA_UNMODIFIED);
patch.flags |= GIT_DIFF_PATCH_LOADED;
if (delta.binary != 1 && delta.status != GIT_DELTA_UNMODIFIED)
patch.flags |= GIT_DIFF_PATCH_DIFFABLE;
/* do diffs */
if (file_cb != NULL && file_cb(cb_data, &delta, 1)) {
error = GIT_EUSER;
goto cleanup;
}
error = diff_delta_exec(&ctxt, cb_data, hunk_cb, line_cb);
if (!(error = diff_delta_file_callback(&ctxt, patch.delta, 1)))
error = diff_patch_generate(&ctxt, &patch);
cleanup:
diff_patch_unload(&patch);
if (error == GIT_EUSER)
giterr_clear();
diff_delta_unload(&ctxt);
return error;
}
typedef struct diffiter_line diffiter_line;
struct diffiter_line {
diffiter_line *next;
char origin;
const char *ptr;
size_t len;
};
typedef struct diffiter_hunk diffiter_hunk;
struct diffiter_hunk {
diffiter_hunk *next;
git_diff_range range;
diffiter_line *line_head;
size_t line_count;
};
struct git_diff_iterator {
git_diff_list *diff;
diff_delta_context ctxt;
size_t file_index;
size_t next_index;
git_pool hunks;
size_t hunk_count;
diffiter_hunk *hunk_head;
diffiter_hunk *hunk_curr;
char hunk_header[128];
git_pool lines;
diffiter_line *line_curr;
};
typedef struct {
git_diff_iterator *iter;
diffiter_hunk *last_hunk;
diffiter_line *last_line;
} diffiter_cb_info;
static int diffiter_hunk_cb(
void *cb_data,
git_diff_delta *delta,
git_diff_range *range,
const char *header,
size_t header_len)
size_t git_diff_num_deltas(git_diff_list *diff)
{
diffiter_cb_info *info = cb_data;
git_diff_iterator *iter = info->iter;
diffiter_hunk *hunk;
GIT_UNUSED(delta);
GIT_UNUSED(header);
GIT_UNUSED(header_len);
if ((hunk = git_pool_mallocz(&iter->hunks, 1)) == NULL) {
iter->ctxt.cb_error = -1;
return -1;
}
if (info->last_hunk)
info->last_hunk->next = hunk;
info->last_hunk = hunk;
info->last_line = NULL;
memcpy(&hunk->range, range, sizeof(hunk->range));
iter->hunk_count++;
/* adding first hunk to list */
if (iter->hunk_head == NULL) {
iter->hunk_head = hunk;
iter->hunk_curr = NULL;
}
return 0;
assert(diff);
return (size_t)diff->deltas.length;
}
static int diffiter_line_cb(
void *cb_data,
git_diff_delta *delta,
git_diff_range *range,
char line_origin,
const char *content,
size_t content_len)
size_t git_diff_num_deltas_of_type(git_diff_list *diff, git_delta_t type)
{
diffiter_cb_info *info = cb_data;
git_diff_iterator *iter = info->iter;
diffiter_line *line;
size_t i, count = 0;
git_diff_delta *delta;
GIT_UNUSED(delta);
GIT_UNUSED(range);
assert(diff);
if ((line = git_pool_mallocz(&iter->lines, 1)) == NULL) {
iter->ctxt.cb_error = -1;
return -1;
git_vector_foreach(&diff->deltas, i, delta) {
count += (delta->status == type);
}
if (info->last_line)
info->last_line->next = line;
info->last_line = line;
line->origin = line_origin;
line->ptr = content;
line->len = content_len;
info->last_hunk->line_count++;
if (info->last_hunk->line_head == NULL)
info->last_hunk->line_head = line;
return 0;
return count;
}
static int diffiter_do_diff_file(git_diff_iterator *iter)
int git_diff_get_patch(
git_diff_patch **patch_ptr,
const git_diff_delta **delta_ptr,
git_diff_list *diff,
size_t idx)
{
int error;
diffiter_cb_info info;
if (iter->ctxt.diffed || !iter->ctxt.delta)
return 0;
memset(&info, 0, sizeof(info));
info.iter = iter;
error = diff_delta_exec(
&iter->ctxt, &info, diffiter_hunk_cb, diffiter_line_cb);
if (error == GIT_EUSER)
error = iter->ctxt.cb_error;
return error;
}
diff_context ctxt;
git_diff_delta *delta;
git_diff_patch *patch;
static void diffiter_do_unload_file(git_diff_iterator *iter)
{
if (iter->ctxt.loaded) {
diff_delta_unload(&iter->ctxt);
if (patch_ptr)
*patch_ptr = NULL;
git_pool_clear(&iter->lines);
git_pool_clear(&iter->hunks);
delta = git_vector_get(&diff->deltas, idx);
if (!delta) {
if (delta_ptr)
*delta_ptr = NULL;
giterr_set(GITERR_INVALID, "Index out of range for delta in diff");
return GIT_ENOTFOUND;
}
iter->ctxt.delta = NULL;
iter->hunk_curr = iter->hunk_head = NULL;
iter->hunk_count = 0;
iter->line_curr = NULL;
}
int git_diff_iterator_new(
git_diff_iterator **iterator_ptr,
git_diff_list *diff)
{
git_diff_iterator *iter;
assert(diff && iterator_ptr);
if (delta_ptr)
*delta_ptr = delta;
*iterator_ptr = NULL;
iter = git__malloc(sizeof(git_diff_iterator));
GITERR_CHECK_ALLOC(iter);
memset(iter, 0, sizeof(*iter));
iter->diff = diff;
GIT_REFCOUNT_INC(iter->diff);
if (!patch_ptr && delta->binary != -1)
return 0;
diff_delta_init_context_from_diff_list(&iter->ctxt, diff);
diff_context_init(
&ctxt, diff, diff->repo, &diff->opts,
NULL, NULL, diff_patch_hunk_cb, diff_patch_line_cb);
if (git_pool_init(&iter->hunks, sizeof(diffiter_hunk), 0) < 0 ||
git_pool_init(&iter->lines, sizeof(diffiter_line), 0) < 0)
goto fail;
if (git_diff_delta__should_skip(ctxt.opts, delta))
return 0;
*iterator_ptr = iter;
patch = diff_patch_alloc(&ctxt, delta);
if (!patch)
return -1;
return 0;
if (!(error = diff_patch_load(&ctxt, patch))) {
ctxt.cb_data = patch;
fail:
git_diff_iterator_free(iter);
error = diff_patch_generate(&ctxt, patch);
return -1;
}
if (error == GIT_EUSER)
error = ctxt.cb_error;
}
void git_diff_iterator_free(git_diff_iterator *iter)
{
diffiter_do_unload_file(iter);
git_diff_list_free(iter->diff); /* decrement ref count */
git__free(iter);
}
if (error)
git_diff_patch_free(patch);
else if (patch_ptr)
*patch_ptr = patch;
float git_diff_iterator_progress(git_diff_iterator *iter)
{
return (float)iter->next_index / (float)iter->diff->deltas.length;
return error;
}
int git_diff_iterator__max_files(git_diff_iterator *iter)
void git_diff_patch_free(git_diff_patch *patch)
{
return (int)iter->diff->deltas.length;
if (patch)
GIT_REFCOUNT_DEC(patch, diff_patch_free);
}
int git_diff_iterator_num_hunks_in_file(git_diff_iterator *iter)
const git_diff_delta *git_diff_patch_delta(git_diff_patch *patch)
{
int error = diffiter_do_diff_file(iter);
return (error != 0) ? error : (int)iter->hunk_count;
assert(patch);
return patch->delta;
}
int git_diff_iterator_num_lines_in_hunk(git_diff_iterator *iter)
size_t git_diff_patch_num_hunks(git_diff_patch *patch)
{
int error = diffiter_do_diff_file(iter);
if (error)
return error;
if (iter->hunk_curr)
return (int)iter->hunk_curr->line_count;
if (iter->hunk_head)
return (int)iter->hunk_head->line_count;
return 0;
assert(patch);
return patch->hunks_size;
}
int git_diff_iterator_next_file(
git_diff_delta **delta_ptr,
git_diff_iterator *iter)
{
int error = 0;
assert(iter);
iter->file_index = iter->next_index;
diffiter_do_unload_file(iter);
while (!error) {
iter->ctxt.delta = git_vector_get(&iter->diff->deltas, iter->file_index);
if (!iter->ctxt.delta) {
error = GIT_ITEROVER;
break;
}
if (diff_delta_is_ambiguous(iter->ctxt.delta) &&
(error = diff_delta_load(&iter->ctxt)) < 0)
break;
if (!diff_delta_should_skip(iter->ctxt.opts, iter->ctxt.delta))
break;
iter->file_index++;
}
if (!error) {
iter->next_index = iter->file_index + 1;
error = diff_delta_prep(&iter->ctxt);
}
if (iter->ctxt.delta == NULL) {
iter->hunk_curr = iter->hunk_head = NULL;
iter->line_curr = NULL;
}
if (delta_ptr != NULL)
*delta_ptr = !error ? iter->ctxt.delta : NULL;
return error;
}
int git_diff_iterator_next_hunk(
git_diff_range **range_ptr,
int git_diff_patch_get_hunk(
const git_diff_range **range,
const char **header,
size_t *header_len,
git_diff_iterator *iter)
size_t *lines_in_hunk,
git_diff_patch *patch,
size_t hunk_idx)
{
int error = diffiter_do_diff_file(iter);
git_diff_range *range;
diff_patch_hunk *hunk;
if (error)
return error;
assert(patch);
if (iter->hunk_curr == NULL) {
if (iter->hunk_head == NULL)
goto no_more_hunks;
iter->hunk_curr = iter->hunk_head;
} else {
if (iter->hunk_curr->next == NULL)
goto no_more_hunks;
iter->hunk_curr = iter->hunk_curr->next;
if (hunk_idx >= patch->hunks_size) {
if (range) *range = NULL;
if (header) *header = NULL;
if (header_len) *header_len = 0;
if (lines_in_hunk) *lines_in_hunk = 0;
return GIT_ENOTFOUND;
}
range = &iter->hunk_curr->range;
if (range_ptr)
*range_ptr = range;
if (header) {
int out = format_hunk_header(
iter->hunk_header, sizeof(iter->hunk_header), range);
hunk = &patch->hunks[hunk_idx];
/* TODO: append function name to header */
if (range) *range = &hunk->range;
if (header) *header = hunk->header;
if (header_len) *header_len = hunk->header_len;
if (lines_in_hunk) *lines_in_hunk = hunk->line_count;
*(iter->hunk_header + out++) = '\n';
return 0;
}
*header = iter->hunk_header;
int git_diff_patch_num_lines_in_hunk(
git_diff_patch *patch,
size_t hunk_idx)
{
assert(patch);
if (header_len)
*header_len = (size_t)out;
}
if (hunk_idx >= patch->hunks_size)
return GIT_ENOTFOUND;
else
return patch->hunks[hunk_idx].line_count;
}
iter->line_curr = iter->hunk_curr->line_head;
int git_diff_patch_get_line_in_hunk(
char *line_origin,
const char **content,
size_t *content_len,
int *old_lineno,
int *new_lineno,
git_diff_patch *patch,
size_t hunk_idx,
size_t line_of_hunk)
{
diff_patch_hunk *hunk;
diff_patch_line *line;
return error;
assert(patch);
no_more_hunks:
if (range_ptr) *range_ptr = NULL;
if (header) *header = NULL;
if (header_len) *header_len = 0;
iter->line_curr = NULL;
if (hunk_idx >= patch->hunks_size)
goto notfound;
hunk = &patch->hunks[hunk_idx];
return GIT_ITEROVER;
}
if (line_of_hunk >= hunk->line_count)
goto notfound;
int git_diff_iterator_next_line(
char *line_origin, /**< GIT_DIFF_LINE_... value from above */
const char **content_ptr,
size_t *content_len,
git_diff_iterator *iter)
{
int error = diffiter_do_diff_file(iter);
line = &patch->lines[hunk->line_start + line_of_hunk];
if (error)
return error;
if (line_origin) *line_origin = line->origin;
if (content) *content = line->ptr;
if (content_len) *content_len = line->len;
if (old_lineno) *old_lineno = line->oldno;
if (new_lineno) *new_lineno = line->newno;
/* if the user has not called next_hunk yet, call it implicitly (OK?) */
if (iter->hunk_curr == NULL) {
error = git_diff_iterator_next_hunk(NULL, NULL, NULL, iter);
if (error)
return error;
}
return 0;
if (iter->line_curr == NULL) {
notfound:
if (line_origin) *line_origin = GIT_DIFF_LINE_CONTEXT;
if (content_ptr) *content_ptr = NULL;
if (content) *content = NULL;
if (content_len) *content_len = 0;
return GIT_ITEROVER;
}
if (line_origin)
*line_origin = iter->line_curr->origin;
if (content_ptr)
*content_ptr = iter->line_curr->ptr;
if (content_len)
*content_len = iter->line_curr->len;
iter->line_curr = iter->line_curr->next;
if (old_lineno) *old_lineno = -1;
if (new_lineno) *new_lineno = -1;
return error;
return GIT_ENOTFOUND;
}
src/diff_output.h 0 → 100644
/*
* Copyright (C) 2009-2012 the libgit2 contributors
*
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
#ifndef INCLUDE_diff_output_h__
#define INCLUDE_diff_output_h__
#include "git2/blob.h"
#include "diff.h"
#include "map.h"
#include "xdiff/xdiff.h"
#define MAX_DIFF_FILESIZE 0x20000000
enum {
GIT_DIFF_PATCH_ALLOCATED = (1 << 0),
GIT_DIFF_PATCH_PREPPED = (1 << 1),
GIT_DIFF_PATCH_LOADED = (1 << 2),
GIT_DIFF_PATCH_DIFFABLE = (1 << 3),
GIT_DIFF_PATCH_DIFFED = (1 << 4),
};
/* context for performing diffs */
typedef struct {
git_repository *repo;
git_diff_list *diff;
const git_diff_options *opts;
git_diff_file_fn file_cb;
git_diff_hunk_fn hunk_cb;
git_diff_data_fn data_cb;
void *cb_data;
int cb_error;
git_diff_range cb_range;
xdemitconf_t xdiff_config;
xpparam_t xdiff_params;
} diff_context;
/* cached information about a single span in a diff */
typedef struct diff_patch_line diff_patch_line;
struct diff_patch_line {
const char *ptr;
size_t len;
int lines, oldno, newno;
char origin;
};
/* cached information about a hunk in a diff */
typedef struct diff_patch_hunk diff_patch_hunk;
struct diff_patch_hunk {
git_diff_range range;
char header[128];
size_t header_len;
size_t line_start;
size_t line_count;
};
struct git_diff_patch {
git_refcount rc;
git_diff_list *diff; /* for refcount purposes, maybe NULL for blob diffs */
git_diff_delta *delta;
diff_context *ctxt; /* only valid while generating patch */
git_iterator_type_t old_src;
git_iterator_type_t new_src;
git_blob *old_blob;
git_blob *new_blob;
git_map old_data;
git_map new_data;
uint32_t flags;
diff_patch_hunk *hunks;
size_t hunks_asize, hunks_size;
diff_patch_line *lines;
size_t lines_asize, lines_size;
};
/* context for performing diff on a single delta */
typedef struct {
git_diff_patch *patch;
uint32_t prepped : 1;
uint32_t loaded : 1;
uint32_t diffable : 1;
uint32_t diffed : 1;
} diff_delta_context;
#endif
src/submodule.c
......@@ -1457,7 +1457,7 @@ static int submodule_wd_status(unsigned int *status, git_submodule *sm)
error = git_diff_index_to_tree(sm_repo, &opt, sm_head, &diff);
if (!error) {
if (git_diff_entrycount(diff, -1) > 0)
if (git_diff_num_deltas(diff) > 0)
*status |= GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED;
git_diff_list_free(diff);
......@@ -1474,12 +1474,13 @@ static int submodule_wd_status(unsigned int *status, git_submodule *sm)
error = git_diff_workdir_to_index(sm_repo, &opt, &diff);
if (!error) {
int untracked = git_diff_entrycount(diff, GIT_DELTA_UNTRACKED);
int untracked =
git_diff_num_deltas_of_type(diff, GIT_DELTA_UNTRACKED);
if (untracked > 0)
*status |= GIT_SUBMODULE_STATUS_WD_UNTRACKED;
if (git_diff_entrycount(diff, -1) - untracked > 0)
if ((git_diff_num_deltas(diff) - untracked) > 0)
*status |= GIT_SUBMODULE_STATUS_WD_WD_MODIFIED;
git_diff_list_free(diff);
......
tests-clar/diff/diff_helpers.c
......@@ -23,7 +23,7 @@ git_tree *resolve_commit_oid_to_tree(
int diff_file_fn(
void *cb_data,
git_diff_delta *delta,
const git_diff_delta *delta,
float progress)
{
diff_expects *e = cb_data;
......@@ -48,8 +48,8 @@ int diff_file_fn(
int diff_hunk_fn(
void *cb_data,
git_diff_delta *delta,
git_diff_range *range,
const git_diff_delta *delta,
const git_diff_range *range,
const char *header,
size_t header_len)
{
......@@ -67,8 +67,8 @@ int diff_hunk_fn(
int diff_line_fn(
void *cb_data,
git_diff_delta *delta,
git_diff_range *range,
const git_diff_delta *delta,
const git_diff_range *range,
char line_origin,
const char *content,
size_t content_len)
......@@ -112,64 +112,71 @@ int diff_foreach_via_iterator(
git_diff_hunk_fn hunk_cb,
git_diff_data_fn line_cb)
{
int error;
git_diff_iterator *iter;
git_diff_delta *delta;
size_t d, num_d = git_diff_num_deltas(diff);
if ((error = git_diff_iterator_new(&iter, diff)) < 0)
return error;
for (d = 0; d < num_d; ++d) {
git_diff_patch *patch;
const git_diff_delta *delta;
size_t h, num_h;
while (!(error = git_diff_iterator_next_file(&delta, iter))) {
git_diff_range *range;
const char *hdr;
size_t hdr_len;
float progress = git_diff_iterator_progress(iter);
cl_git_pass(git_diff_get_patch(&patch, &delta, diff, d));
cl_assert(delta);
/* call file_cb for this file */
if (file_cb != NULL && file_cb(data, delta, progress) != 0)
if (file_cb != NULL && file_cb(data, delta, (float)d / num_d) != 0) {
git_diff_patch_free(patch);
goto abort;
}
if (!hunk_cb && !line_cb)
/* if there are no changes, then the patch will be NULL */
if (!patch) {
cl_assert(delta->status == GIT_DELTA_UNMODIFIED || delta->binary == 1);
continue;
}
while (!(error = git_diff_iterator_next_hunk(
&range, &hdr, &hdr_len, iter))) {
char origin;
const char *line;
size_t line_len;
if (!hunk_cb && !line_cb) {
git_diff_patch_free(patch);
continue;
}
if (hunk_cb && hunk_cb(data, delta, range, hdr, hdr_len) != 0)
goto abort;
num_h = git_diff_patch_num_hunks(patch);
if (!line_cb)
continue;
for (h = 0; h < num_h; h++) {
const git_diff_range *range;
const char *hdr;
size_t hdr_len, l, num_l;
while (!(error = git_diff_iterator_next_line(
&origin, &line, &line_len, iter))) {
cl_git_pass(git_diff_patch_get_hunk(
&range, &hdr, &hdr_len, &num_l, patch, h));
if (line_cb(data, delta, range, origin, line, line_len) != 0)
if (hunk_cb && hunk_cb(data, delta, range, hdr, hdr_len) != 0) {
git_diff_patch_free(patch);
goto abort;
}
if (error && error != GIT_ITEROVER)
goto done;
}
for (l = 0; l < num_l; ++l) {
char origin;
const char *line;
size_t line_len;
int old_lineno, new_lineno;
if (error && error != GIT_ITEROVER)
goto done;
}
cl_git_pass(git_diff_patch_get_line_in_hunk(
&origin, &line, &line_len, &old_lineno, &new_lineno,
patch, h, l));
done:
git_diff_iterator_free(iter);
if (line_cb(data, delta, range, origin, line, line_len) != 0) {
git_diff_patch_free(patch);
goto abort;
}
}
}
if (error == GIT_ITEROVER)
error = 0;
git_diff_patch_free(patch);
}
return error;
return 0;
abort:
git_diff_iterator_free(iter);
giterr_clear();
return GIT_EUSER;
}
tests-clar/diff/diff_helpers.h
......@@ -27,20 +27,20 @@ typedef struct {
extern int diff_file_fn(
void *cb_data,
git_diff_delta *delta,
const git_diff_delta *delta,
float progress);
extern int diff_hunk_fn(
void *cb_data,
git_diff_delta *delta,
git_diff_range *range,
const git_diff_delta *delta,
const git_diff_range *range,
const char *header,
size_t header_len);
extern int diff_line_fn(
void *cb_data,
git_diff_delta *delta,
git_diff_range *range,
const git_diff_delta *delta,
const git_diff_range *range,
char line_origin,
const char *content,
size_t content_len);
......
tests-clar/diff/diffiter.c
......@@ -14,11 +14,16 @@ void test_diff_diffiter__create(void)
{
git_repository *repo = cl_git_sandbox_init("attr");
git_diff_list *diff;
git_diff_iterator *iter;
size_t d, num_d;
cl_git_pass(git_diff_workdir_to_index(repo, NULL, &diff));
cl_git_pass(git_diff_iterator_new(&iter, diff));
git_diff_iterator_free(iter);
num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) {
const git_diff_delta *delta;
cl_git_pass(git_diff_get_patch(NULL, &delta, diff, d));
}
git_diff_list_free(diff);
}
......@@ -26,24 +31,22 @@ void test_diff_diffiter__iterate_files(void)
{
git_repository *repo = cl_git_sandbox_init("attr");
git_diff_list *diff;
git_diff_iterator *iter;
git_diff_delta *delta;
int error, count = 0;
size_t d, num_d;
int count = 0;
cl_git_pass(git_diff_workdir_to_index(repo, NULL, &diff));
cl_git_pass(git_diff_iterator_new(&iter, diff));
while ((error = git_diff_iterator_next_file(&delta, iter)) != GIT_ITEROVER) {
cl_assert_equal_i(0, error);
num_d = git_diff_num_deltas(diff);
cl_assert_equal_i(6, num_d);
for (d = 0; d < num_d; ++d) {
const git_diff_delta *delta;
cl_git_pass(git_diff_get_patch(NULL, &delta, diff, d));
cl_assert(delta != NULL);
count++;
}
cl_assert_equal_i(GIT_ITEROVER, error);
cl_assert(delta == NULL);
cl_assert_equal_i(6, count);
git_diff_iterator_free(iter);
git_diff_list_free(diff);
}
......@@ -51,24 +54,22 @@ void test_diff_diffiter__iterate_files_2(void)
{
git_repository *repo = cl_git_sandbox_init("status");
git_diff_list *diff;
git_diff_iterator *iter;
git_diff_delta *delta;
int error, count = 0;
size_t d, num_d;
int count = 0;
cl_git_pass(git_diff_workdir_to_index(repo, NULL, &diff));
cl_git_pass(git_diff_iterator_new(&iter, diff));
while ((error = git_diff_iterator_next_file(&delta, iter)) != GIT_ITEROVER) {
cl_assert_equal_i(0, error);
num_d = git_diff_num_deltas(diff);
cl_assert_equal_i(8, num_d);
for (d = 0; d < num_d; ++d) {
const git_diff_delta *delta;
cl_git_pass(git_diff_get_patch(NULL, &delta, diff, d));
cl_assert(delta != NULL);
count++;
}
cl_assert_equal_i(GIT_ITEROVER, error);
cl_assert(delta == NULL);
cl_assert_equal_i(8, count);
git_diff_iterator_free(iter);
git_diff_list_free(diff);
}
......@@ -77,12 +78,8 @@ void test_diff_diffiter__iterate_files_and_hunks(void)
git_repository *repo = cl_git_sandbox_init("status");
git_diff_options opts = {0};
git_diff_list *diff = NULL;
git_diff_iterator *iter;
git_diff_delta *delta;
git_diff_range *range;
const char *header;
size_t header_len;
int error, file_count = 0, hunk_count = 0;
size_t d, num_d;
int file_count = 0, hunk_count = 0;
opts.context_lines = 3;
opts.interhunk_lines = 1;
......@@ -90,28 +87,42 @@ void test_diff_diffiter__iterate_files_and_hunks(void)
cl_git_pass(git_diff_workdir_to_index(repo, &opts, &diff));
cl_git_pass(git_diff_iterator_new(&iter, diff));
num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) {
git_diff_patch *patch;
const git_diff_delta *delta;
size_t h, num_h;
cl_git_pass(git_diff_get_patch(&patch, &delta, diff, d));
while ((error = git_diff_iterator_next_file(&delta, iter)) != GIT_ITEROVER) {
cl_assert_equal_i(0, error);
cl_assert(delta);
cl_assert(patch);
file_count++;
while ((error = git_diff_iterator_next_hunk(
&range, &header, &header_len, iter)) != GIT_ITEROVER) {
cl_assert_equal_i(0, error);
num_h = git_diff_patch_num_hunks(patch);
for (h = 0; h < num_h; h++) {
const git_diff_range *range;
const char *header;
size_t header_len, num_l;
cl_git_pass(git_diff_patch_get_hunk(
&range, &header, &header_len, &num_l, patch, h));
cl_assert(range);
cl_assert(header);
hunk_count++;
}
git_diff_patch_free(patch);
}
cl_assert_equal_i(GIT_ITEROVER, error);
cl_assert(delta == NULL);
cl_assert_equal_i(13, file_count);
cl_assert_equal_i(8, hunk_count);
git_diff_iterator_free(iter);
git_diff_list_free(diff);
}
......@@ -120,45 +131,42 @@ void test_diff_diffiter__max_size_threshold(void)
git_repository *repo = cl_git_sandbox_init("status");
git_diff_options opts = {0};
git_diff_list *diff = NULL;
git_diff_iterator *iter;
git_diff_delta *delta;
int error, file_count = 0, binary_count = 0, hunk_count = 0;
int file_count = 0, binary_count = 0, hunk_count = 0;
size_t d, num_d;
opts.context_lines = 3;
opts.interhunk_lines = 1;
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
cl_git_pass(git_diff_workdir_to_index(repo, &opts, &diff));
cl_git_pass(git_diff_iterator_new(&iter, diff));
num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) {
git_diff_patch *patch;
const git_diff_delta *delta;
while ((error = git_diff_iterator_next_file(&delta, iter)) != GIT_ITEROVER) {
cl_assert_equal_i(0, error);
cl_git_pass(git_diff_get_patch(&patch, &delta, diff, d));
cl_assert(delta);
cl_assert(patch);
file_count++;
hunk_count += git_diff_iterator_num_hunks_in_file(iter);
hunk_count += git_diff_patch_num_hunks(patch);
assert(delta->binary == 0 || delta->binary == 1);
binary_count += delta->binary;
}
cl_assert_equal_i(GIT_ITEROVER, error);
cl_assert(delta == NULL);
git_diff_patch_free(patch);
}
cl_assert_equal_i(13, file_count);
cl_assert_equal_i(0, binary_count);
cl_assert_equal_i(8, hunk_count);
git_diff_iterator_free(iter);
git_diff_list_free(diff);
/* try again with low file size threshold */
file_count = 0;
binary_count = 0;
hunk_count = 0;
file_count = binary_count = hunk_count = 0;
opts.context_lines = 3;
opts.interhunk_lines = 1;
......@@ -166,36 +174,171 @@ void test_diff_diffiter__max_size_threshold(void)
opts.max_size = 50; /* treat anything over 50 bytes as binary! */
cl_git_pass(git_diff_workdir_to_index(repo, &opts, &diff));
cl_git_pass(git_diff_iterator_new(&iter, diff));
num_d = git_diff_num_deltas(diff);
while ((error = git_diff_iterator_next_file(&delta, iter)) != GIT_ITEROVER) {
cl_assert_equal_i(0, error);
cl_assert(delta);
for (d = 0; d < num_d; ++d) {
git_diff_patch *patch;
const git_diff_delta *delta;
file_count++;
cl_git_pass(git_diff_get_patch(&patch, &delta, diff, d));
hunk_count += git_diff_iterator_num_hunks_in_file(iter);
file_count++;
hunk_count += git_diff_patch_num_hunks(patch);
assert(delta->binary == 0 || delta->binary == 1);
binary_count += delta->binary;
}
cl_assert_equal_i(GIT_ITEROVER, error);
cl_assert(delta == NULL);
git_diff_patch_free(patch);
}
cl_assert_equal_i(13, file_count);
/* Three files are over the 50 byte threshold:
* - staged_changes_file_deleted
* - staged_changes_modified_file
* - staged_new_file_modified_file
*/
cl_assert_equal_i(3, binary_count);
cl_assert_equal_i(5, hunk_count);
git_diff_iterator_free(iter);
git_diff_list_free(diff);
}
void test_diff_diffiter__iterate_all(void)
{
git_repository *repo = cl_git_sandbox_init("status");
git_diff_options opts = {0};
git_diff_list *diff = NULL;
diff_expects exp = {0};
size_t d, num_d;
opts.context_lines = 3;
opts.interhunk_lines = 1;
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
cl_git_pass(git_diff_workdir_to_index(repo, &opts, &diff));
num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) {
git_diff_patch *patch;
const git_diff_delta *delta;
size_t h, num_h;
cl_git_pass(git_diff_get_patch(&patch, &delta, diff, d));
cl_assert(patch && delta);
exp.files++;
num_h = git_diff_patch_num_hunks(patch);
for (h = 0; h < num_h; h++) {
const git_diff_range *range;
const char *header;
size_t header_len, l, num_l;
cl_git_pass(git_diff_patch_get_hunk(
&range, &header, &header_len, &num_l, patch, h));
cl_assert(range && header);
exp.hunks++;
for (l = 0; l < num_l; ++l) {
char origin;
const char *content;
size_t content_len;
cl_git_pass(git_diff_patch_get_line_in_hunk(
&origin, &content, &content_len, NULL, NULL, patch, h, l));
cl_assert(content);
exp.lines++;
}
}
git_diff_patch_free(patch);
}
cl_assert_equal_i(13, exp.files);
cl_assert_equal_i(8, exp.hunks);
cl_assert_equal_i(14, exp.lines);
git_diff_list_free(diff);
}
static void iterate_over_patch(git_diff_patch *patch, diff_expects *exp)
{
size_t h, num_h = git_diff_patch_num_hunks(patch), num_l;
exp->files++;
exp->hunks += num_h;
/* let's iterate in reverse, just because we can! */
for (h = 1, num_l = 0; h <= num_h; ++h)
num_l += git_diff_patch_num_lines_in_hunk(patch, num_h - h);
exp->lines += num_l;
}
#define PATCH_CACHE 5
void test_diff_diffiter__iterate_randomly_while_saving_state(void)
{
git_repository *repo = cl_git_sandbox_init("status");
git_diff_options opts = {0};
git_diff_list *diff = NULL;
diff_expects exp = {0};
git_diff_patch *patches[PATCH_CACHE];
size_t p, d, num_d;
memset(patches, 0, sizeof(patches));
opts.context_lines = 3;
opts.interhunk_lines = 1;
opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
cl_git_pass(git_diff_workdir_to_index(repo, &opts, &diff));
num_d = git_diff_num_deltas(diff);
/* To make sure that references counts work for diff and patch objects,
* this generates patches and randomly caches them. Only when the patch
* is removed from the cache are hunks and lines counted. At the end,
* there are still patches in the cache, so free the diff and try to
* process remaining patches after the diff is freed.
*/
srand(121212);
p = rand() % PATCH_CACHE;
for (d = 0; d < num_d; ++d) {
/* take old patch */
git_diff_patch *patch = patches[p];
patches[p] = NULL;
/* cache new patch */
cl_git_pass(git_diff_get_patch(&patches[p], NULL, diff, d));
cl_assert(patches[p] != NULL);
/* process old patch if non-NULL */
if (patch != NULL) {
iterate_over_patch(patch, &exp);
git_diff_patch_free(patch);
}
p = rand() % PATCH_CACHE;
}
/* free diff list now - refcounts should keep things safe */
git_diff_list_free(diff);
/* process remaining unprocessed patches */
for (p = 0; p < PATCH_CACHE; p++) {
git_diff_patch *patch = patches[p];
if (patch != NULL) {
iterate_over_patch(patch, &exp);
git_diff_patch_free(patch);
}
}
/* hopefully it all still added up right */
cl_assert_equal_i(13, exp.files);
cl_assert_equal_i(8, exp.hunks);
cl_assert_equal_i(14, exp.lines);
}
tests-clar/diff/index.c
......@@ -93,7 +93,7 @@ void test_diff_index__0(void)
static int diff_stop_after_2_files(
void *cb_data,
git_diff_delta *delta,
const git_diff_delta *delta,
float progress)
{
diff_expects *e = cb_data;
......
tests-clar/diff/patch.c
......@@ -23,8 +23,8 @@ void test_diff_patch__cleanup(void)
static int check_removal_cb(
void *cb_data,
git_diff_delta *delta,
git_diff_range *range,
const git_diff_delta *delta,
const git_diff_range *range,
char line_origin,
const char *formatted_output,
size_t output_len)
......
tests-clar/diff/tree.c
......@@ -264,10 +264,12 @@ void test_diff_tree__larger_hunks(void)
git_tree *a, *b;
git_diff_options opts = {0};
git_diff_list *diff = NULL;
git_diff_iterator *iter = NULL;
git_diff_delta *delta;
diff_expects exp;
int error, num_files = 0;
size_t d, num_d, h, num_h, l, num_l, header_len, line_len;
const git_diff_delta *delta;
git_diff_patch *patch;
const git_diff_range *range;
const char *header, *line;
char origin;
g_repo = cl_git_sandbox_init("diff");
......@@ -277,61 +279,38 @@ void test_diff_tree__larger_hunks(void)
opts.context_lines = 1;
opts.interhunk_lines = 0;
memset(&exp, 0, sizeof(exp));
cl_git_pass(git_diff_tree_to_tree(g_repo, &opts, a, b, &diff));
cl_git_pass(git_diff_iterator_new(&iter, diff));
/* this should be exact */
cl_assert(git_diff_iterator_progress(iter) == 0.0f);
/* You wouldn't actually structure an iterator loop this way, but
* I have here for testing purposes of the return value
*/
while (!(error = git_diff_iterator_next_file(&delta, iter))) {
git_diff_range *range;
const char *header;
size_t header_len;
int actual_hunks = 0, num_hunks;
float expected_progress;
num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) {
cl_git_pass(git_diff_get_patch(&patch, &delta, diff, d));
cl_assert(patch && delta);
num_files++;
num_h = git_diff_patch_num_hunks(patch);
for (h = 0; h < num_h; h++) {
cl_git_pass(git_diff_patch_get_hunk(
&range, &header, &header_len, &num_l, patch, h));
expected_progress = (float)num_files / 2.0f;
cl_assert(expected_progress == git_diff_iterator_progress(iter));
num_hunks = git_diff_iterator_num_hunks_in_file(iter);
while (!(error = git_diff_iterator_next_hunk(
&range, &header, &header_len, iter)))
{
int actual_lines = 0;
int num_lines = git_diff_iterator_num_lines_in_hunk(iter);
char origin;
const char *line;
size_t line_len;
for (l = 0; l < num_l; ++l) {
cl_git_pass(git_diff_patch_get_line_in_hunk(
&origin, &line, &line_len, NULL, NULL, patch, h, l));
cl_assert(line);
}
while (!(error = git_diff_iterator_next_line(
&origin, &line, &line_len, iter)))
{
actual_lines++;
cl_git_fail(git_diff_patch_get_line_in_hunk(
&origin, &line, &line_len, NULL, NULL, patch, h, num_l));
}
cl_assert_equal_i(GIT_ITEROVER, error);
cl_assert_equal_i(actual_lines, num_lines);
cl_git_fail(git_diff_patch_get_hunk(
&range, &header, &header_len, &num_l, patch, num_h));
actual_hunks++;
git_diff_patch_free(patch);
}
cl_assert_equal_i(GIT_ITEROVER, error);
cl_assert_equal_i(actual_hunks, num_hunks);
}
cl_git_fail(git_diff_get_patch(&patch, &delta, diff, num_d));
cl_assert_equal_i(GIT_ITEROVER, error);
cl_assert_equal_i(2, num_files);
cl_assert(git_diff_iterator_progress(iter) == 1.0f);
cl_assert_equal_i(2, num_d);
git_diff_iterator_free(iter);
git_diff_list_free(diff);
diff = NULL;
......
tests-clar/diff/workdir.c
......@@ -678,7 +678,7 @@ void test_diff_workdir__larger_hunks(void)
const char *b_commit = "7a9e0b02e63179929fed24f0a3e0f19168114d10";
git_tree *a, *b;
git_diff_options opts = {0};
int i, error;
size_t i, d, num_d, h, num_h, l, num_l, header_len, line_len;
g_repo = cl_git_sandbox_init("diff");
......@@ -690,9 +690,10 @@ void test_diff_workdir__larger_hunks(void)
for (i = 0; i <= 2; ++i) {
git_diff_list *diff = NULL;
git_diff_iterator *iter = NULL;
git_diff_delta *delta;
int num_files = 0;
git_diff_patch *patch;
const git_diff_range *range;
const char *header, *line;
char origin;
/* okay, this is a bit silly, but oh well */
switch (i) {
......@@ -707,54 +708,36 @@ void test_diff_workdir__larger_hunks(void)
break;
}
cl_git_pass(git_diff_iterator_new(&iter, diff));
cl_assert(git_diff_iterator_progress(iter) == 0.0f);
while (!(error = git_diff_iterator_next_file(&delta, iter))) {
git_diff_range *range;
const char *header;
size_t header_len;
int actual_hunks = 0, num_hunks;
float expected_progress;
num_d = git_diff_num_deltas(diff);
cl_assert_equal_i(2, (int)num_d);
num_files++;
for (d = 0; d < num_d; ++d) {
cl_git_pass(git_diff_get_patch(&patch, NULL, diff, d));
cl_assert(patch);
expected_progress = (float)num_files / 2.0f;
cl_assert(expected_progress == git_diff_iterator_progress(iter));
num_h = git_diff_patch_num_hunks(patch);
for (h = 0; h < num_h; h++) {
cl_git_pass(git_diff_patch_get_hunk(
&range, &header, &header_len, &num_l, patch, h));
num_hunks = git_diff_iterator_num_hunks_in_file(iter);
while (!(error = git_diff_iterator_next_hunk(
&range, &header, &header_len, iter)))
{
int actual_lines = 0;
int num_lines = git_diff_iterator_num_lines_in_hunk(iter);
char origin;
const char *line;
size_t line_len;
while (!(error = git_diff_iterator_next_line(
&origin, &line, &line_len, iter)))
{
actual_lines++;
for (l = 0; l < num_l; ++l) {
cl_git_pass(git_diff_patch_get_line_in_hunk(
&origin, &line, &line_len, NULL, NULL, patch, h, l));
cl_assert(line);
}
cl_assert_equal_i(GIT_ITEROVER, error);
cl_assert_equal_i(actual_lines, num_lines);
actual_hunks++;
/* confirm fail after the last item */
cl_git_fail(git_diff_patch_get_line_in_hunk(
&origin, &line, &line_len, NULL, NULL, patch, h, num_l));
}
cl_assert_equal_i(GIT_ITEROVER, error);
cl_assert_equal_i(actual_hunks, num_hunks);
}
/* confirm fail after the last item */
cl_git_fail(git_diff_patch_get_hunk(
&range, &header, &header_len, &num_l, patch, num_h));
cl_assert_equal_i(GIT_ITEROVER, error);
cl_assert_equal_i(2, num_files);
cl_assert(git_diff_iterator_progress(iter) == 1.0f);
git_diff_patch_free(patch);
}
git_diff_iterator_free(iter);
git_diff_list_free(diff);
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment