static svn_error_t *
window_handler(svn_txdelta_window_t *window, void *baton)
{
struct delta_baton *dbaton = baton;
struct file_rev_baton *frb = dbaton->file_rev_baton;
struct blame_chain *chain;
/* Call the wrapped handler first. */
SVN_ERR(dbaton->wrapped_handler(window, dbaton->wrapped_baton));
/* We patiently wait for the NULL window marking the end. */
if (window)
return SVN_NO_ERROR;
/* Close the source file used for the delta.
It is important to do this early, since otherwise, they will be deleted
before all handles are closed, which leads to failures on some platforms
when new tempfiles are to be created. */
if (dbaton->source_stream)
SVN_ERR(svn_stream_close(dbaton->source_stream));
/* If we are including merged revisions, we need to add each rev to the
merged chain. */
if (frb->include_merged_revisions)
chain = frb->merged_chain;
else
chain = frb->chain;
/* Process this file. */
SVN_ERR(add_file_blame(frb->last_filename,
dbaton->filename, chain, frb->rev,
frb->diff_options, frb->currpool));
/* If we are including merged revisions, and the current revision is not a
merged one, we need to add its blame info to the chain for the original
line of history. */
if (frb->include_merged_revisions && ! frb->merged_revision)
{
apr_pool_t *tmppool;
SVN_ERR(add_file_blame(frb->last_original_filename,
dbaton->filename, frb->chain, frb->rev,
frb->diff_options, frb->currpool));
/* This filename could be around for a while, potentially, so
use the longer lifetime pool, and switch it with the previous one*/
svn_pool_clear(frb->prevfilepool);
tmppool = frb->filepool;
frb->filepool = frb->prevfilepool;
frb->prevfilepool = tmppool;
frb->last_original_filename = apr_pstrdup(frb->filepool,
dbaton->filename);
}
/* Prepare for next revision. */
/* Remember the file name so we can diff it with the next revision. */
frb->last_filename = dbaton->filename;
/* Switch pools. */
{
apr_pool_t *tmp_pool = frb->lastpool;
frb->lastpool = frb->currpool;
frb->currpool = tmp_pool;
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_blame5(const char *target,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *start,
const svn_opt_revision_t *end,
const svn_diff_file_options_t *diff_options,
svn_boolean_t ignore_mime_type,
svn_boolean_t include_merged_revisions,
svn_client_blame_receiver3_t receiver,
void *receiver_baton,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
struct file_rev_baton frb;
svn_ra_session_t *ra_session;
svn_revnum_t start_revnum, end_revnum;
struct blame *walk, *walk_merged = NULL;
apr_pool_t *iterpool;
svn_stream_t *last_stream;
svn_stream_t *stream;
const char *target_abspath_or_url;
if (start->kind == svn_opt_revision_unspecified
|| end->kind == svn_opt_revision_unspecified)
return svn_error_create
(SVN_ERR_CLIENT_BAD_REVISION, NULL, NULL);
if (svn_path_is_url(target))
target_abspath_or_url = target;
else
SVN_ERR(svn_dirent_get_absolute(&target_abspath_or_url, target, pool));
/* Get an RA plugin for this filesystem object. */
SVN_ERR(svn_client__ra_session_from_path(&ra_session, &end_revnum, NULL,
target, NULL, peg_revision, end,
ctx, pool));
SVN_ERR(svn_client__get_revision_number(&start_revnum, NULL, ctx->wc_ctx,
target_abspath_or_url, ra_session,
start, pool));
if (end_revnum < start_revnum)
return svn_error_create
(SVN_ERR_CLIENT_BAD_REVISION, NULL,
_("Start revision must precede end revision"));
frb.start_rev = start_revnum;
frb.end_rev = end_revnum;
frb.target = target;
frb.ctx = ctx;
frb.diff_options = diff_options;
frb.ignore_mime_type = ignore_mime_type;
frb.include_merged_revisions = include_merged_revisions;
frb.last_filename = NULL;
frb.last_original_filename = NULL;
frb.chain = apr_palloc(pool, sizeof(*frb.chain));
frb.chain->blame = NULL;
frb.chain->avail = NULL;
frb.chain->pool = pool;
if (include_merged_revisions)
{
frb.merged_chain = apr_palloc(pool, sizeof(*frb.merged_chain));
frb.merged_chain->blame = NULL;
frb.merged_chain->avail = NULL;
frb.merged_chain->pool = pool;
}
SVN_ERR(svn_ra_get_repos_root2(ra_session, &frb.repos_root_url, pool));
frb.mainpool = pool;
/* The callback will flip the following two pools, because it needs
information from the previous call. Obviously, it can't rely on
the lifetime of the pool provided by get_file_revs. */
frb.lastpool = svn_pool_create(pool);
frb.currpool = svn_pool_create(pool);
if (include_merged_revisions)
{
frb.filepool = svn_pool_create(pool);
frb.prevfilepool = svn_pool_create(pool);
}
/* Collect all blame information.
We need to ensure that we get one revision before the start_rev,
if available so that we can know what was actually changed in the start
revision. */
SVN_ERR(svn_ra_get_file_revs2(ra_session, "",
start_revnum - (start_revnum > 0 ? 1 : 0),
end_revnum, include_merged_revisions,
file_rev_handler, &frb, pool));
if (end->kind == svn_opt_revision_working)
{
/* If the local file is modified we have to call the handler on the
working copy file with keywords unexpanded */
svn_wc_status3_t *status;
SVN_ERR(svn_wc_status3(&status, ctx->wc_ctx, target_abspath_or_url, pool,
pool));
if (status->text_status != svn_wc_status_normal)
{
apr_hash_t *props;
svn_stream_t *wcfile;
svn_string_t *keywords;
svn_stream_t *tempfile;
const char *temppath;
apr_hash_t *kw = NULL;
SVN_ERR(svn_wc_prop_list2(&props, ctx->wc_ctx, target_abspath_or_url,
pool, pool));
SVN_ERR(svn_stream_open_readonly(&wcfile, target, pool, pool));
keywords = apr_hash_get(props, SVN_PROP_KEYWORDS,
APR_HASH_KEY_STRING);
if (keywords)
SVN_ERR(svn_subst_build_keywords2(&kw, keywords->data, NULL, NULL,
0, NULL, pool));
wcfile = svn_subst_stream_translated(wcfile, "\n", TRUE, kw, FALSE,
pool);
SVN_ERR(svn_stream_open_unique(&tempfile, &temppath, NULL,
svn_io_file_del_on_pool_cleanup,
pool, pool));
SVN_ERR(svn_stream_copy3(wcfile, tempfile, ctx->cancel_func,
ctx->cancel_baton, pool));
SVN_ERR(add_file_blame(frb.last_filename, temppath, frb.chain, NULL,
frb.diff_options, pool));
frb.last_filename = temppath;
}
}
/* Report the blame to the caller. */
/* The callback has to have been called at least once. */
SVN_ERR_ASSERT(frb.last_filename != NULL);
/* Create a pool for the iteration below. */
iterpool = svn_pool_create(pool);
/* Open the last file and get a stream. */
SVN_ERR(svn_stream_open_readonly(&last_stream, frb.last_filename,
pool, pool));
stream = svn_subst_stream_translated(last_stream,
"\n", TRUE, NULL, FALSE, pool);
/* Perform optional merged chain normalization. */
if (include_merged_revisions)
{
/* If we never created any blame for the original chain, create it now,
with the most recent changed revision. This could occur if a file
was created on a branch and them merged to another branch. This is
semanticly a copy, and we want to use the revision on the branch as
the most recently changed revision. ### Is this really what we want
to do here? Do the sematics of copy change? */
if (!frb.chain->blame)
frb.chain->blame = blame_create(frb.chain, frb.rev, 0);
normalize_blames(frb.chain, frb.merged_chain, pool);
walk_merged = frb.merged_chain->blame;
}
/* Process each blame item. */
for (walk = frb.chain->blame; walk; walk = walk->next)
{
apr_off_t line_no;
svn_revnum_t merged_rev;
const char *merged_path;
apr_hash_t *merged_rev_props;
if (walk_merged)
{
merged_rev = walk_merged->rev->revision;
merged_rev_props = walk_merged->rev->rev_props;
merged_path = walk_merged->rev->path;
}
else
{
merged_rev = SVN_INVALID_REVNUM;
merged_rev_props = NULL;
merged_path = NULL;
}
for (line_no = walk->start;
!walk->next || line_no < walk->next->start;
++line_no)
{
svn_boolean_t eof;
svn_stringbuf_t *sb;
svn_pool_clear(iterpool);
SVN_ERR(svn_stream_readline(stream, &sb, "\n", &eof, iterpool));
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
if (!eof || sb->len)
{
if (walk->rev)
SVN_ERR(receiver(receiver_baton, start_revnum, end_revnum,
line_no, walk->rev->revision,
walk->rev->rev_props, merged_rev,
merged_rev_props, merged_path,
sb->data, FALSE, iterpool));
else
SVN_ERR(receiver(receiver_baton, start_revnum, end_revnum,
line_no, SVN_INVALID_REVNUM,
NULL, SVN_INVALID_REVNUM,
NULL, NULL,
sb->data, TRUE, iterpool));
}
if (eof) break;
}
if (walk_merged)
walk_merged = walk_merged->next;
}
SVN_ERR(svn_stream_close(stream));
svn_pool_destroy(frb.lastpool);
svn_pool_destroy(frb.currpool);
if (include_merged_revisions)
{
svn_pool_destroy(frb.filepool);
svn_pool_destroy(frb.prevfilepool);
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
static svn_error_t *
do_blame (const char *target,
svn_ra_plugin_t *ra_lib,
void *ra_session,
struct file_rev_baton *frb)
{
struct log_message_baton lmb;
apr_array_header_t *condensed_targets;
apr_file_t *file;
svn_stream_t *stream;
struct rev *rev;
svn_node_kind_t kind;
apr_pool_t *pool = frb->mainpool;
SVN_ERR (ra_lib->check_path (ra_session, target, frb->end_rev, &kind, pool));
if (kind == svn_node_dir)
return svn_error_createf (SVN_ERR_CLIENT_IS_DIRECTORY, NULL,
("URL '%s' refers to a directory"), target);
condensed_targets = apr_array_make (pool, 1, sizeof (const char *));
(*((const char **)apr_array_push (condensed_targets))) = "";
lmb.path = apr_pstrcat(pool, "/", target, NULL);
lmb.eldest = NULL;
lmb.pool = pool;
/* Accumulate revision metadata by walking the revisions
backwards; this allows us to follow moves/copies
correctly. */
SVN_ERR (ra_lib->get_log (ra_session,
condensed_targets,
frb->end_rev,
frb->start_rev,
TRUE,
FALSE,
log_message_receiver,
&lmb,
pool));
/* Inspect the first revision's change metadata; if there are any
prior revisions, compute a new starting revision/path. If no
revisions were selected, no blame is assigned. A modified
item certainly has a prior revision. It is reasonable for an
added item to have none, but anything else is unexpected. */
if (!lmb.eldest)
{
lmb.eldest = apr_palloc (pool, sizeof (*rev));
lmb.eldest->revision = frb->end_rev;
lmb.eldest->path = lmb.path;
lmb.eldest->next = NULL;
rev = apr_palloc (pool, sizeof (*rev));
rev->revision = SVN_INVALID_REVNUM;
rev->author = NULL;
rev->date = NULL;
frb->blame = blame_create (frb, rev, 0);
}
else if (lmb.action == 'M' || SVN_IS_VALID_REVNUM (lmb.copyrev))
{
rev = apr_palloc (pool, sizeof (*rev));
if (SVN_IS_VALID_REVNUM (lmb.copyrev))
rev->revision = lmb.copyrev;
else
rev->revision = lmb.eldest->revision - 1;
rev->path = lmb.path;
rev->next = lmb.eldest;
lmb.eldest = rev;
rev = apr_palloc (pool, sizeof (*rev));
rev->revision = SVN_INVALID_REVNUM;
rev->author = NULL;
rev->date = NULL;
frb->blame = blame_create (frb, rev, 0);
}
else if (lmb.action == 'A')
{
frb->blame = blame_create (frb, lmb.eldest, 0);
}
else
return svn_error_createf (APR_EGENERAL, NULL,
("Revision action '%c' for "
"revision %ld of '%s' "
"lacks a prior revision"),
lmb.action, lmb.eldest->revision,
lmb.eldest->path);
/* Walk the revision list in chronological order, downloading
each fulltext, diffing it with its predecessor, and accumulating
the blame information into db.blame. Use two iteration pools
rather than one, because the diff routines need to look at a
sliding window of revisions. Two pools gives us a ring buffer
of sorts. */
for (rev = lmb.eldest; rev; rev = rev->next)
{
const char *tmp;
const char *temp_dir;
apr_hash_t *props;
svn_string_t *mimetype;
apr_pool_clear (frb->currpool);
SVN_ERR (svn_io_temp_dir (&temp_dir, frb->currpool));
SVN_ERR (svn_io_open_unique_file (&file, &tmp,
svn_path_join (temp_dir, "tmp", frb->currpool), ".tmp",
FALSE, frb->currpool));
apr_pool_cleanup_register (frb->currpool, file, cleanup_tempfile,
apr_pool_cleanup_null);
stream = svn_stream_from_aprfile (file, frb->currpool);
SVN_ERR (ra_lib->get_file(ra_session, rev->path + 1, rev->revision,
stream, NULL, &props, frb->currpool));
SVN_ERR (svn_stream_close (stream));
SVN_ERR (svn_io_file_close (file, frb->currpool));
/* If this file has a non-textual mime-type, bail out. */
if (props &&
((mimetype = apr_hash_get (props, SVN_PROP_MIME_TYPE,
sizeof (SVN_PROP_MIME_TYPE) - 1))))
{
if (svn_mime_type_is_binary (mimetype->data))
return svn_error_createf (SVN_ERR_CLIENT_IS_BINARY_FILE, 0,
("Cannot calculate blame information for binary file '%s'"),target);
}
if (frb->last_filename)
{
frb->rev = rev;
SVN_ERR (add_file_blame (frb->last_filename, tmp, frb));
}
frb->last_filename = tmp;
{
apr_pool_t *tmppool = frb->currpool;
frb->currpool = frb->lastpool;
frb->lastpool = tmppool;
}
}
return SVN_NO_ERROR;
}
