Alien-SVN
view release on metacpan or search on metacpan
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
/* ### Should diff labels print paths in local style? Is there
already a standard for this? In any case, this code depends on
a particular style, so not calling svn_dirent_local_style() on the
paths below.*/
if (new_path[0] == '\0')
new_path = ".";
if (new_path1[0] == '\0')
new_path1 = new_path;
else if (svn_path_is_url(new_path1))
new_path1 = apr_psprintf(result_pool, "%s\t(%s)", new_path, new_path1);
else if (new_path1[0] == '/')
new_path1 = apr_psprintf(result_pool, "%s\t(...%s)", new_path, new_path1);
else
new_path1 = apr_psprintf(result_pool, "%s\t(.../%s)", new_path, new_path1);
if (new_path2[0] == '\0')
new_path2 = new_path;
else if (svn_path_is_url(new_path2))
new_path1 = apr_psprintf(result_pool, "%s\t(%s)", new_path, new_path2);
else if (new_path2[0] == '/')
new_path2 = apr_psprintf(result_pool, "%s\t(...%s)", new_path, new_path2);
else
new_path2 = apr_psprintf(result_pool, "%s\t(.../%s)", new_path, new_path2);
*index_path = new_path;
*orig_path_1 = new_path1;
*orig_path_2 = new_path2;
return SVN_NO_ERROR;
}
/* Generate a label for the diff output for file PATH at revision REVNUM.
If REVNUM is invalid then it is assumed to be the current working
copy. Assumes the paths are already in the desired style (local
vs internal). Allocate the label in POOL. */
static const char *
diff_label(const char *path,
svn_revnum_t revnum,
apr_pool_t *pool)
{
const char *label;
if (revnum != SVN_INVALID_REVNUM)
label = apr_psprintf(pool, _("%s\t(revision %ld)"), path, revnum);
else
label = apr_psprintf(pool, _("%s\t(working copy)"), path);
return label;
}
/* Print a git diff header for an addition within a diff between PATH1 and
* PATH2 to the stream OS using HEADER_ENCODING.
* All allocations are done in RESULT_POOL. */
static svn_error_t *
print_git_diff_header_added(svn_stream_t *os, const char *header_encoding,
const char *path1, const char *path2,
apr_pool_t *result_pool)
{
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"diff --git a/%s b/%s%s",
path1, path2, APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"new file mode 10644" APR_EOL_STR));
return SVN_NO_ERROR;
}
/* Print a git diff header for a deletion within a diff between PATH1 and
* PATH2 to the stream OS using HEADER_ENCODING.
* All allocations are done in RESULT_POOL. */
static svn_error_t *
print_git_diff_header_deleted(svn_stream_t *os, const char *header_encoding,
const char *path1, const char *path2,
apr_pool_t *result_pool)
{
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"diff --git a/%s b/%s%s",
path1, path2, APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"deleted file mode 10644"
APR_EOL_STR));
return SVN_NO_ERROR;
}
/* Print a git diff header for a copy from COPYFROM_PATH to PATH to the stream
* OS using HEADER_ENCODING. All allocations are done in RESULT_POOL. */
static svn_error_t *
print_git_diff_header_copied(svn_stream_t *os, const char *header_encoding,
const char *copyfrom_path,
svn_revnum_t copyfrom_rev,
const char *path,
apr_pool_t *result_pool)
{
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"diff --git a/%s b/%s%s",
copyfrom_path, path, APR_EOL_STR));
if (copyfrom_rev != SVN_INVALID_REVNUM)
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"copy from %s@%ld%s", copyfrom_path,
copyfrom_rev, APR_EOL_STR));
else
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"copy from %s%s", copyfrom_path,
APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"copy to %s%s", path, APR_EOL_STR));
return SVN_NO_ERROR;
}
/* Print a git diff header for a rename from COPYFROM_PATH to PATH to the
* stream OS using HEADER_ENCODING. All allocations are done in RESULT_POOL. */
static svn_error_t *
print_git_diff_header_renamed(svn_stream_t *os, const char *header_encoding,
const char *copyfrom_path, const char *path,
apr_pool_t *result_pool)
{
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"diff --git a/%s b/%s%s",
copyfrom_path, path, APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"rename from %s%s", copyfrom_path,
APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"rename to %s%s", path, APR_EOL_STR));
return SVN_NO_ERROR;
}
/* Print a git diff header for a modification within a diff between PATH1 and
* PATH2 to the stream OS using HEADER_ENCODING.
* All allocations are done in RESULT_POOL. */
static svn_error_t *
print_git_diff_header_modified(svn_stream_t *os, const char *header_encoding,
const char *path1, const char *path2,
apr_pool_t *result_pool)
{
SVN_ERR(svn_stream_printf_from_utf8(os, header_encoding, result_pool,
"diff --git a/%s b/%s%s",
path1, path2, APR_EOL_STR));
return SVN_NO_ERROR;
}
/* Print a git diff header showing the OPERATION to the stream OS using
* HEADER_ENCODING. Return suitable diff labels for the git diff in *LABEL1
* and *LABEL2. REPOS_RELPATH1 and REPOS_RELPATH2 are relative to reposroot.
* are the paths passed to the original diff command. REV1 and REV2 are
* revisions being diffed. COPYFROM_PATH and COPYFROM_REV indicate where the
* diffed item was copied from.
* Use SCRATCH_POOL for temporary allocations. */
static svn_error_t *
print_git_diff_header(svn_stream_t *os,
const char **label1, const char **label2,
svn_diff_operation_kind_t operation,
const char *repos_relpath1,
const char *repos_relpath2,
svn_revnum_t rev1,
svn_revnum_t rev2,
const char *copyfrom_path,
svn_revnum_t copyfrom_rev,
const char *header_encoding,
apr_pool_t *scratch_pool)
{
if (operation == svn_diff_op_deleted)
{
SVN_ERR(print_git_diff_header_deleted(os, header_encoding,
repos_relpath1, repos_relpath2,
scratch_pool));
*label1 = diff_label(apr_psprintf(scratch_pool, "a/%s", repos_relpath1),
rev1, scratch_pool);
*label2 = diff_label("/dev/null", rev2, scratch_pool);
}
else if (operation == svn_diff_op_copied)
{
SVN_ERR(print_git_diff_header_copied(os, header_encoding,
copyfrom_path, copyfrom_rev,
repos_relpath2,
scratch_pool));
*label1 = diff_label(apr_psprintf(scratch_pool, "a/%s", copyfrom_path),
rev1, scratch_pool);
*label2 = diff_label(apr_psprintf(scratch_pool, "b/%s", repos_relpath2),
rev2, scratch_pool);
}
else if (operation == svn_diff_op_added)
{
SVN_ERR(print_git_diff_header_added(os, header_encoding,
repos_relpath1, repos_relpath2,
scratch_pool));
*label1 = diff_label("/dev/null", rev1, scratch_pool);
*label2 = diff_label(apr_psprintf(scratch_pool, "b/%s", repos_relpath2),
rev2, scratch_pool);
}
else if (operation == svn_diff_op_modified)
{
SVN_ERR(print_git_diff_header_modified(os, header_encoding,
repos_relpath1, repos_relpath2,
scratch_pool));
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
### FIXME needs proper docstring
If USE_GIT_DIFF_FORMAT is TRUE, pring git diff headers, which always
show paths relative to the repository root. RA_SESSION and WC_CTX are
needed to normalize paths relative the repository root, and are ignored
if USE_GIT_DIFF_FORMAT is FALSE.
ANCHOR is the local path where the diff editor is anchored. */
static svn_error_t *
display_prop_diffs(const apr_array_header_t *propchanges,
apr_hash_t *original_props,
const char *diff_relpath,
const char *anchor,
const char *orig_path1,
const char *orig_path2,
svn_revnum_t rev1,
svn_revnum_t rev2,
const char *encoding,
svn_stream_t *outstream,
const char *relative_to_dir,
svn_boolean_t show_diff_header,
svn_boolean_t use_git_diff_format,
svn_ra_session_t *ra_session,
svn_wc_context_t *wc_ctx,
apr_pool_t *scratch_pool)
{
const char *repos_relpath1 = NULL;
const char *repos_relpath2 = NULL;
const char *index_path = diff_relpath;
const char *adjusted_path1 = orig_path1;
const char *adjusted_path2 = orig_path2;
if (use_git_diff_format)
{
SVN_ERR(make_repos_relpath(&repos_relpath1, diff_relpath, orig_path1,
ra_session, wc_ctx, anchor,
scratch_pool, scratch_pool));
SVN_ERR(make_repos_relpath(&repos_relpath2, diff_relpath, orig_path2,
ra_session, wc_ctx, anchor,
scratch_pool, scratch_pool));
}
/* If we're creating a diff on the wc root, path would be empty. */
SVN_ERR(adjust_paths_for_diff_labels(&index_path, &adjusted_path1,
&adjusted_path2,
relative_to_dir, anchor,
scratch_pool, scratch_pool));
if (show_diff_header)
{
const char *label1;
const char *label2;
label1 = diff_label(adjusted_path1, rev1, scratch_pool);
label2 = diff_label(adjusted_path2, rev2, scratch_pool);
/* ### Should we show the paths in platform specific format,
* ### diff_content_changed() does not! */
SVN_ERR(svn_stream_printf_from_utf8(outstream, encoding, scratch_pool,
"Index: %s" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
if (use_git_diff_format)
SVN_ERR(print_git_diff_header(outstream, &label1, &label2,
svn_diff_op_modified,
repos_relpath1, repos_relpath2,
rev1, rev2, NULL,
SVN_INVALID_REVNUM,
encoding, scratch_pool));
/* --- label1
* +++ label2 */
SVN_ERR(svn_diff__unidiff_write_header(
outstream, encoding, label1, label2, scratch_pool));
}
SVN_ERR(svn_stream_printf_from_utf8(outstream, encoding, scratch_pool,
_("%sProperty changes on: %s%s"),
APR_EOL_STR,
use_git_diff_format
? repos_relpath1
: index_path,
APR_EOL_STR));
SVN_ERR(svn_stream_printf_from_utf8(outstream, encoding, scratch_pool,
SVN_DIFF__UNDER_STRING APR_EOL_STR));
SVN_ERR(svn_diff__display_prop_diffs(
outstream, encoding, propchanges, original_props,
TRUE /* pretty_print_mergeinfo */, scratch_pool));
return SVN_NO_ERROR;
}
/*-----------------------------------------------------------------*/
/*** Callbacks for 'svn diff', invoked by the repos-diff editor. ***/
struct diff_cmd_baton {
/* If non-null, the external diff command to invoke. */
const char *diff_cmd;
/* This is allocated in this struct's pool or a higher-up pool. */
union {
/* If 'diff_cmd' is null, then this is the parsed options to
pass to the internal libsvn_diff implementation. */
svn_diff_file_options_t *for_internal;
/* Else if 'diff_cmd' is non-null, then... */
struct {
/* ...this is an argument array for the external command, and */
const char **argv;
/* ...this is the length of argv. */
int argc;
} for_external;
} options;
apr_pool_t *pool;
svn_stream_t *outstream;
svn_stream_t *errstream;
const char *header_encoding;
/* The original targets passed to the diff command. We may need
these to construct distinctive diff labels when comparing the
same relative path in the same revision, under different anchors
(for example, when comparing a trunk against a branch). */
const char *orig_path_1;
const char *orig_path_2;
/* These are the numeric representations of the revisions passed to
svn_client_diff6(), either may be SVN_INVALID_REVNUM. We need these
because some of the svn_wc_diff_callbacks4_t don't get revision
arguments.
### Perhaps we should change the callback signatures and eliminate
### these?
*/
svn_revnum_t revnum1;
svn_revnum_t revnum2;
/* Set this if you want diff output even for binary files. */
svn_boolean_t force_binary;
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
}
/* Show differences between TMPFILE1 and TMPFILE2. DIFF_RELPATH, REV1, and
REV2 are used in the headers to indicate the file and revisions. If either
MIMETYPE1 or MIMETYPE2 indicate binary content, don't show a diff,
but instead print a warning message.
If FORCE_DIFF is TRUE, always write a diff, even for empty diffs.
Set *WROTE_HEADER to TRUE if a diff header was written */
static svn_error_t *
diff_content_changed(svn_boolean_t *wrote_header,
const char *diff_relpath,
const char *tmpfile1,
const char *tmpfile2,
svn_revnum_t rev1,
svn_revnum_t rev2,
const char *mimetype1,
const char *mimetype2,
svn_diff_operation_kind_t operation,
svn_boolean_t force_diff,
const char *copyfrom_path,
svn_revnum_t copyfrom_rev,
struct diff_cmd_baton *diff_cmd_baton,
apr_pool_t *scratch_pool)
{
int exitcode;
const char *rel_to_dir = diff_cmd_baton->relative_to_dir;
svn_stream_t *errstream = diff_cmd_baton->errstream;
svn_stream_t *outstream = diff_cmd_baton->outstream;
const char *label1, *label2;
svn_boolean_t mt1_binary = FALSE, mt2_binary = FALSE;
const char *index_path = diff_relpath;
const char *path1 = diff_cmd_baton->orig_path_1;
const char *path2 = diff_cmd_baton->orig_path_2;
/* If only property differences are shown, there's nothing to do. */
if (diff_cmd_baton->properties_only)
return SVN_NO_ERROR;
/* Generate the diff headers. */
SVN_ERR(adjust_paths_for_diff_labels(&index_path, &path1, &path2,
rel_to_dir, diff_cmd_baton->anchor,
scratch_pool, scratch_pool));
label1 = diff_label(path1, rev1, scratch_pool);
label2 = diff_label(path2, rev2, scratch_pool);
/* Possible easy-out: if either mime-type is binary and force was not
specified, don't attempt to generate a viewable diff at all.
Print a warning and exit. */
if (mimetype1)
mt1_binary = svn_mime_type_is_binary(mimetype1);
if (mimetype2)
mt2_binary = svn_mime_type_is_binary(mimetype2);
if (! diff_cmd_baton->force_binary && (mt1_binary || mt2_binary))
{
/* Print out the diff header. */
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"Index: %s" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
/* ### Print git diff headers. */
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
_("Cannot display: file marked as a binary type.%s"),
APR_EOL_STR));
if (mt1_binary && !mt2_binary)
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"svn:mime-type = %s" APR_EOL_STR, mimetype1));
else if (mt2_binary && !mt1_binary)
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"svn:mime-type = %s" APR_EOL_STR, mimetype2));
else if (mt1_binary && mt2_binary)
{
if (strcmp(mimetype1, mimetype2) == 0)
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"svn:mime-type = %s" APR_EOL_STR,
mimetype1));
else
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"svn:mime-type = (%s, %s)" APR_EOL_STR,
mimetype1, mimetype2));
}
/* Exit early. */
return SVN_NO_ERROR;
}
if (diff_cmd_baton->diff_cmd)
{
apr_file_t *outfile;
apr_file_t *errfile;
const char *outfilename;
const char *errfilename;
svn_stream_t *stream;
/* Print out the diff header. */
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"Index: %s" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
/* ### Do we want to add git diff headers here too? I'd say no. The
* ### 'Index' and '===' line is something subversion has added. The rest
* ### is up to the external diff application. We may be dealing with
* ### a non-git compatible diff application.*/
/* We deal in streams, but svn_io_run_diff2() deals in file handles,
so we may need to make temporary files and then copy the contents
to our stream. */
outfile = svn_stream__aprfile(outstream);
if (outfile)
outfilename = NULL;
else
SVN_ERR(svn_io_open_unique_file3(&outfile, &outfilename, NULL,
svn_io_file_del_on_pool_cleanup,
scratch_pool, scratch_pool));
errfile = svn_stream__aprfile(errstream);
if (errfile)
errfilename = NULL;
else
SVN_ERR(svn_io_open_unique_file3(&errfile, &errfilename, NULL,
svn_io_file_del_on_pool_cleanup,
scratch_pool, scratch_pool));
SVN_ERR(svn_io_run_diff2(".",
diff_cmd_baton->options.for_external.argv,
diff_cmd_baton->options.for_external.argc,
label1, label2,
tmpfile1, tmpfile2,
&exitcode, outfile, errfile,
diff_cmd_baton->diff_cmd, scratch_pool));
/* Now, open and copy our files to our output streams. */
if (outfilename)
{
SVN_ERR(svn_io_file_close(outfile, scratch_pool));
SVN_ERR(svn_stream_open_readonly(&stream, outfilename,
scratch_pool, scratch_pool));
SVN_ERR(svn_stream_copy3(stream, svn_stream_disown(outstream,
scratch_pool),
NULL, NULL, scratch_pool));
}
if (errfilename)
{
SVN_ERR(svn_io_file_close(errfile, scratch_pool));
SVN_ERR(svn_stream_open_readonly(&stream, errfilename,
scratch_pool, scratch_pool));
SVN_ERR(svn_stream_copy3(stream, svn_stream_disown(errstream,
scratch_pool),
NULL, NULL, scratch_pool));
}
/* We have a printed a diff for this path, mark it as visited. */
*wrote_header = TRUE;
}
else /* use libsvn_diff to generate the diff */
{
svn_diff_t *diff;
SVN_ERR(svn_diff_file_diff_2(&diff, tmpfile1, tmpfile2,
diff_cmd_baton->options.for_internal,
scratch_pool));
if (force_diff
|| diff_cmd_baton->use_git_diff_format
|| svn_diff_contains_diffs(diff))
{
/* Print out the diff header. */
SVN_ERR(svn_stream_printf_from_utf8(outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"Index: %s" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
if (diff_cmd_baton->use_git_diff_format)
{
const char *repos_relpath1;
const char *repos_relpath2;
SVN_ERR(make_repos_relpath(&repos_relpath1, diff_relpath,
diff_cmd_baton->orig_path_1,
diff_cmd_baton->ra_session,
diff_cmd_baton->wc_ctx,
diff_cmd_baton->anchor,
scratch_pool, scratch_pool));
SVN_ERR(make_repos_relpath(&repos_relpath2, diff_relpath,
diff_cmd_baton->orig_path_2,
diff_cmd_baton->ra_session,
diff_cmd_baton->wc_ctx,
diff_cmd_baton->anchor,
scratch_pool, scratch_pool));
SVN_ERR(print_git_diff_header(outstream, &label1, &label2,
operation,
repos_relpath1, repos_relpath2,
rev1, rev2,
copyfrom_path,
copyfrom_rev,
diff_cmd_baton->header_encoding,
scratch_pool));
}
/* Output the actual diff */
if (force_diff || svn_diff_contains_diffs(diff))
SVN_ERR(svn_diff_file_output_unified3(outstream, diff,
tmpfile1, tmpfile2, label1, label2,
diff_cmd_baton->header_encoding, rel_to_dir,
diff_cmd_baton->options.for_internal->show_c_function,
scratch_pool));
/* We have a printed a diff for this path, mark it as visited. */
*wrote_header = TRUE;
}
}
/* ### todo: someday we'll need to worry about whether we're going
to need to write a diff plug-in mechanism that makes use of the
two paths, instead of just blindly running SVN_CLIENT_DIFF. */
return SVN_NO_ERROR;
}
static svn_error_t *
diff_file_opened(svn_boolean_t *tree_conflicted,
svn_boolean_t *skip,
const char *diff_relpath,
svn_revnum_t rev,
void *diff_baton,
apr_pool_t *scratch_pool)
{
return SVN_NO_ERROR;
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
const char *tmpfile2,
svn_revnum_t rev1,
svn_revnum_t rev2,
const char *mimetype1,
const char *mimetype2,
const char *copyfrom_path,
svn_revnum_t copyfrom_revision,
const apr_array_header_t *prop_changes,
apr_hash_t *original_props,
void *diff_baton,
apr_pool_t *scratch_pool)
{
struct diff_cmd_baton *diff_cmd_baton = diff_baton;
svn_boolean_t wrote_header = FALSE;
/* During repos->wc diff of a copy revision numbers obtained
* from the working copy are always SVN_INVALID_REVNUM. */
if (diff_cmd_baton->repos_wc_diff_target_is_copy)
{
if (rev1 == SVN_INVALID_REVNUM &&
diff_cmd_baton->revnum1 != SVN_INVALID_REVNUM)
rev1 = diff_cmd_baton->revnum1;
if (rev2 == SVN_INVALID_REVNUM &&
diff_cmd_baton->revnum2 != SVN_INVALID_REVNUM)
rev2 = diff_cmd_baton->revnum2;
}
if (diff_cmd_baton->no_copyfrom_on_add
&& (copyfrom_path || SVN_IS_VALID_REVNUM(copyfrom_revision)))
{
apr_hash_t *empty_hash = apr_hash_make(scratch_pool);
apr_array_header_t *new_changes;
/* Rebase changes on having no left source. */
if (!diff_cmd_baton->empty_file)
SVN_ERR(svn_io_open_unique_file3(NULL, &diff_cmd_baton->empty_file,
NULL, svn_io_file_del_on_pool_cleanup,
diff_cmd_baton->pool, scratch_pool));
SVN_ERR(svn_prop_diffs(&new_changes,
svn_prop__patch(original_props, prop_changes,
scratch_pool),
empty_hash,
scratch_pool));
tmpfile1 = diff_cmd_baton->empty_file;
prop_changes = new_changes;
original_props = empty_hash;
copyfrom_revision = SVN_INVALID_REVNUM;
}
if (diff_cmd_baton->no_diff_added)
{
const char *index_path = diff_relpath;
if (diff_cmd_baton->anchor)
index_path = svn_dirent_join(diff_cmd_baton->anchor, diff_relpath,
scratch_pool);
SVN_ERR(svn_stream_printf_from_utf8(diff_cmd_baton->outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"Index: %s (added)" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
wrote_header = TRUE;
}
else if (tmpfile1 && copyfrom_path)
SVN_ERR(diff_content_changed(&wrote_header, diff_relpath,
tmpfile1, tmpfile2, rev1, rev2,
mimetype1, mimetype2,
svn_diff_op_copied,
TRUE /* force diff output */,
copyfrom_path,
copyfrom_revision, diff_cmd_baton,
scratch_pool));
else if (tmpfile1)
SVN_ERR(diff_content_changed(&wrote_header, diff_relpath,
tmpfile1, tmpfile2, rev1, rev2,
mimetype1, mimetype2,
svn_diff_op_added,
TRUE /* force diff output */,
NULL, SVN_INVALID_REVNUM,
diff_cmd_baton, scratch_pool));
if (prop_changes->nelts > 0)
SVN_ERR(diff_props_changed(diff_relpath, rev1, rev2,
FALSE, prop_changes,
original_props, ! wrote_header,
diff_cmd_baton, scratch_pool));
return SVN_NO_ERROR;
}
/* An svn_wc_diff_callbacks4_t function. */
static svn_error_t *
diff_file_deleted(svn_wc_notify_state_t *state,
svn_boolean_t *tree_conflicted,
const char *diff_relpath,
const char *tmpfile1,
const char *tmpfile2,
const char *mimetype1,
const char *mimetype2,
apr_hash_t *original_props,
void *diff_baton,
apr_pool_t *scratch_pool)
{
struct diff_cmd_baton *diff_cmd_baton = diff_baton;
if (diff_cmd_baton->no_diff_deleted)
{
const char *index_path = diff_relpath;
if (diff_cmd_baton->anchor)
index_path = svn_dirent_join(diff_cmd_baton->anchor, diff_relpath,
scratch_pool);
SVN_ERR(svn_stream_printf_from_utf8(diff_cmd_baton->outstream,
diff_cmd_baton->header_encoding, scratch_pool,
"Index: %s (deleted)" APR_EOL_STR
SVN_DIFF__EQUAL_STRING APR_EOL_STR,
index_path));
}
else
{
svn_boolean_t wrote_header = FALSE;
if (tmpfile1)
SVN_ERR(diff_content_changed(&wrote_header, diff_relpath,
tmpfile1, tmpfile2,
diff_cmd_baton->revnum1,
diff_cmd_baton->revnum2,
mimetype1, mimetype2,
svn_diff_op_deleted, FALSE,
NULL, SVN_INVALID_REVNUM,
diff_cmd_baton,
scratch_pool));
/* Should we also report the properties as deleted? */
}
/* We don't list all the deleted properties. */
return SVN_NO_ERROR;
}
/* An svn_wc_diff_callbacks4_t function. */
static svn_error_t *
diff_dir_added(svn_wc_notify_state_t *state,
svn_boolean_t *tree_conflicted,
svn_boolean_t *skip,
svn_boolean_t *skip_children,
const char *diff_relpath,
svn_revnum_t rev,
const char *copyfrom_path,
svn_revnum_t copyfrom_revision,
void *diff_baton,
apr_pool_t *scratch_pool)
{
/* Do nothing. */
return SVN_NO_ERROR;
}
/* An svn_wc_diff_callbacks4_t function. */
static svn_error_t *
diff_dir_deleted(svn_wc_notify_state_t *state,
svn_boolean_t *tree_conflicted,
const char *diff_relpath,
void *diff_baton,
apr_pool_t *scratch_pool)
{
/* Do nothing. */
return SVN_NO_ERROR;
}
/* An svn_wc_diff_callbacks4_t function. */
static svn_error_t *
src/subversion/subversion/libsvn_client/diff.c view on Meta::CPAN
if (kind == svn_node_dir)
target = "";
else
target = svn_dirent_basename(path_or_url1, NULL);
SVN_ERR(svn_client__get_diff_summarize_callbacks(
&callbacks, &callback_baton, target, FALSE,
summarize_func, summarize_baton, pool));
SVN_ERR(svn_client__arbitrary_nodes_diff(abspath1, abspath2,
depth,
callbacks,
callback_baton,
ctx, pool));
}
else
SVN_ERR(diff_summarize_wc_wc(summarize_func, summarize_baton,
path_or_url1, revision1,
path_or_url2, revision2,
depth, ignore_ancestry,
changelists, ctx, pool));
}
}
return SVN_NO_ERROR;
}
/* Initialize DIFF_CMD_BATON.diff_cmd and DIFF_CMD_BATON.options,
* according to OPTIONS and CONFIG. CONFIG and OPTIONS may be null.
* Allocate the fields in POOL, which should be at least as long-lived
* as the pool DIFF_CMD_BATON itself is allocated in.
*/
static svn_error_t *
set_up_diff_cmd_and_options(struct diff_cmd_baton *diff_cmd_baton,
const apr_array_header_t *options,
apr_hash_t *config, apr_pool_t *pool)
{
const char *diff_cmd = NULL;
/* See if there is a diff command and/or diff arguments. */
if (config)
{
svn_config_t *cfg = svn_hash_gets(config, SVN_CONFIG_CATEGORY_CONFIG);
svn_config_get(cfg, &diff_cmd, SVN_CONFIG_SECTION_HELPERS,
SVN_CONFIG_OPTION_DIFF_CMD, NULL);
if (options == NULL)
{
const char *diff_extensions;
svn_config_get(cfg, &diff_extensions, SVN_CONFIG_SECTION_HELPERS,
SVN_CONFIG_OPTION_DIFF_EXTENSIONS, NULL);
if (diff_extensions)
options = svn_cstring_split(diff_extensions, " \t\n\r", TRUE, pool);
}
}
if (options == NULL)
options = apr_array_make(pool, 0, sizeof(const char *));
if (diff_cmd)
SVN_ERR(svn_path_cstring_to_utf8(&diff_cmd_baton->diff_cmd, diff_cmd,
pool));
else
diff_cmd_baton->diff_cmd = NULL;
/* If there was a command, arrange options to pass to it. */
if (diff_cmd_baton->diff_cmd)
{
const char **argv = NULL;
int argc = options->nelts;
if (argc)
{
int i;
argv = apr_palloc(pool, argc * sizeof(char *));
for (i = 0; i < argc; i++)
SVN_ERR(svn_utf_cstring_to_utf8(&argv[i],
APR_ARRAY_IDX(options, i, const char *), pool));
}
diff_cmd_baton->options.for_external.argv = argv;
diff_cmd_baton->options.for_external.argc = argc;
}
else /* No command, so arrange options for internal invocation instead. */
{
diff_cmd_baton->options.for_internal
= svn_diff_file_options_create(pool);
SVN_ERR(svn_diff_file_options_parse
(diff_cmd_baton->options.for_internal, options, pool));
}
return SVN_NO_ERROR;
}
/*----------------------------------------------------------------------- */
/*** Public Interfaces. ***/
/* Display context diffs between two PATH/REVISION pairs. Each of
these inputs will be one of the following:
- a repository URL at a given revision.
- a working copy path, ignoring local mods.
- a working copy path, including local mods.
We can establish a matrix that shows the nine possible types of
diffs we expect to support.
` . DST || URL:rev | WC:base | WC:working |
` . || | | |
SRC ` . || | | |
============++============+============+============+
URL:rev || (*) | (*) | (*) |
|| | | |
|| | | |
|| | | |
------------++------------+------------+------------+
WC:base || (*) | |
|| | New svn_wc_diff which |
|| | is smart enough to |
|| | handle two WC paths |
------------++------------+ and their related +
WC:working || (*) | text-bases and working |
|| | files. This operation |
|| | is entirely local. |
|| | |
------------++------------+------------+------------+
* These cases require server communication.
*/
svn_error_t *
svn_client_diff6(const apr_array_header_t *options,
const char *path_or_url1,
const svn_opt_revision_t *revision1,
const char *path_or_url2,
const svn_opt_revision_t *revision2,
const char *relative_to_dir,
svn_depth_t depth,
( run in 0.765 second using v1.01-cache-2.11-cpan-e93a5daba3e )