/**
* Print detailed info for the given ISSUE.
*
* Optionally return the current repo-path of the entry.
*/
static void _resolve__list(SG_context * pCtx,
struct _resolve_data * pData,
const SG_vhash * pvhIssue,
SG_string ** ppStrRepoPath)
{
SG_string * pStrOutput = NULL;
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &pStrOutput) );
SG_ERR_CHECK( SG_pendingtree__format_issue(pCtx, pData->pPendingTree, pvhIssue, pStrOutput, ppStrRepoPath) );
SG_ERR_IGNORE( SG_console__raw(pCtx, SG_CS_STDOUT, SG_string__sz(pStrOutput)) );
fail:
SG_STRING_NULLFREE(pCtx, pStrOutput);
}
/**
* Compute DIFF on (baseline or arbitrary cset vs WC) and either
* splat to console or launch a GUI tool for each.
*
*/
static void _s01__do_cset_vs_wc(SG_context * pCtx,
const SG_option_state * pOptSt,
const SG_stringarray * psaArgs,
SG_uint32 * pNrErrors)
{
SG_wc_tx * pWcTx = NULL;
SG_varray * pvaDiffSteps = NULL;
SG_varray * pvaDiffSteps_DirtyFiles = NULL;
SG_pathname * pPathWc = NULL;
SG_uint32 nrErrors = 0;
SG_ERR_CHECK( SG_WC_TX__ALLOC__BEGIN(pCtx, &pWcTx, pPathWc, SG_TRUE) );
SG_ERR_CHECK( SG_wc_tx__diff__setup__stringarray(pCtx, pWcTx, pOptSt->pRevSpec,
psaArgs,
WC__GET_DEPTH(pOptSt),
SG_FALSE, // bNoIgnores
SG_FALSE, // bNoTSC
SG_FALSE, // bNoSort,
pOptSt->bInteractive,
pOptSt->psz_tool,
&pvaDiffSteps) );
// rollback/cancel the TX to release the SQL locks,
// but don't free it yet (because that will auto-delete
// the session temp files that we are using for the left
// sides).
//
// This is like SG_wc__diff__throw() but we want to control
// the diff-loop so we can optionally do the interactive prompt.
SG_ERR_CHECK( SG_wc_tx__cancel(pCtx, pWcTx) );
if (pvaDiffSteps)
{
if (pOptSt->bInteractive)
{
SG_ERR_CHECK( _get_dirty_files(pCtx, pvaDiffSteps, &pvaDiffSteps_DirtyFiles) );
if (pvaDiffSteps_DirtyFiles)
SG_ERR_CHECK( _do_gui_diffs(pCtx, SG_TRUE, pOptSt, pvaDiffSteps_DirtyFiles, &nrErrors) );
}
else
{
SG_uint32 k, nrItems;
SG_ERR_CHECK( SG_varray__count(pCtx, pvaDiffSteps, &nrItems) );
for (k=0; k<nrItems; k++)
{
SG_vhash * pvhItem;
const char * pszHeader = NULL;
SG_uint32 iResult;
SG_ERR_CHECK( SG_varray__get__vhash(pCtx, pvaDiffSteps, k, &pvhItem) );
SG_ERR_CHECK( SG_vhash__check__sz(pCtx, pvhItem, "header", &pszHeader) );
if (pszHeader)
SG_ERR_IGNORE( SG_console__raw(pCtx, SG_CS_STDOUT, pszHeader) );
SG_ERR_CHECK( _do_diff1(pCtx, SG_TRUE, pOptSt, pvhItem, &iResult) );
switch (iResult)
{
default:
case SG_FILETOOL__RESULT__SUCCESS:
case SG_DIFFTOOL__RESULT__SAME:
case SG_DIFFTOOL__RESULT__DIFFERENT:
break;
case SG_DIFFTOOL__RESULT__CANCEL:
case SG_FILETOOL__RESULT__FAILURE:
case SG_FILETOOL__RESULT__ERROR:
nrErrors++;
break;
}
}
}
}
*pNrErrors = nrErrors;
fail:
SG_VARRAY_NULLFREE(pCtx, pvaDiffSteps);
SG_VARRAY_NULLFREE(pCtx, pvaDiffSteps_DirtyFiles);
SG_WC_TX__NULLFREE(pCtx, pWcTx);
}
static void _s2__do_cset_vs_cset(SG_context * pCtx,
const SG_option_state * pOptSt,
const SG_stringarray * psaArgs,
SG_uint32 * pNrErrors)
{
SG_varray * pvaStatus = NULL;
SG_varray * pvaStatusDirtyFiles = NULL;
SG_stringarray * psa1 = NULL;
SG_string * pStringGidRepoPath = NULL;
SG_string * pStringErr = NULL;
SG_uint32 nrErrors = 0;
SG_ERR_CHECK( SG_vv2__status(pCtx,
pOptSt->psz_repo,
pOptSt->pRevSpec,
psaArgs,
WC__GET_DEPTH(pOptSt),
SG_FALSE, // bNoSort
&pvaStatus, NULL) );
if (pvaStatus)
{
if (pOptSt->bInteractive)
{
// Filter list down to just modified files and show them one-by-one.
SG_ERR_CHECK( _get_dirty_files(pCtx, pvaStatus, &pvaStatusDirtyFiles) );
if (pvaStatusDirtyFiles)
SG_ERR_CHECK( _do_gui_diffs(pCtx, SG_FALSE, pOptSt, pvaStatusDirtyFiles, &nrErrors) );
}
else
{
SG_uint32 k, nrItems;
// Print the changes with PATCH-like headers.
// Accumulate any tool errors.
SG_ERR_CHECK( SG_varray__count(pCtx, pvaStatus, &nrItems) );
for (k=0; k<nrItems; k++)
{
SG_vhash * pvhItem;
const char * pszGid = NULL;
SG_ERR_CHECK( SG_varray__get__vhash(pCtx, pvaStatus, k, &pvhItem) );
// TODO 2013/02/22 Our pvhItem has all of the details for the diff,
// TODO but we don't yet have a public API to let it be
// TODO used as is. So we build a @gid repo-path and
// TODO run the old historical diff code on a 1-item array
// TODO containing this @gid.
// TODO
// TODO We should fix this to just pass down the pvhItem
// TOOD so that it doesn't have to repeat the status lookup.
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, pvhItem, "gid", &pszGid) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &pStringGidRepoPath) );
SG_ERR_CHECK( SG_string__sprintf(pCtx, pStringGidRepoPath, "@%s", pszGid) );
SG_ERR_CHECK( SG_STRINGARRAY__ALLOC(pCtx, &psa1, 1) );
SG_ERR_CHECK( SG_stringarray__add(pCtx, psa1, SG_string__sz(pStringGidRepoPath)) );
SG_vv2__diff_to_stream__throw(pCtx, pOptSt->psz_repo, pOptSt->pRevSpec,
psa1, 0,
SG_TRUE, // bNoSort -- doesn't matter only 1 item in list
SG_FALSE, // bInteractive,
pOptSt->psz_tool);
// Don't throw the error from the tool. Just print it on STDERR
// and remember that we had an error so that don't stop showing
// the diffs just because we stumble over a changed binary file
// or mis-configured tool, for example.
if (SG_context__has_err(pCtx))
{
SG_context__err_to_string(pCtx, SG_FALSE, &pStringErr);
SG_context__err_reset(pCtx);
SG_ERR_CHECK( SG_console__raw(pCtx, SG_CS_STDERR, SG_string__sz(pStringErr)) );
SG_STRING_NULLFREE(pCtx, pStringErr);
nrErrors++;
}
SG_STRING_NULLFREE(pCtx, pStringGidRepoPath);
SG_STRINGARRAY_NULLFREE(pCtx, psa1);
}
}
}
*pNrErrors = nrErrors;
fail:
SG_VARRAY_NULLFREE(pCtx, pvaStatus);
SG_VARRAY_NULLFREE(pCtx, pvaStatusDirtyFiles);
SG_STRINGARRAY_NULLFREE(pCtx, psa1);
SG_STRING_NULLFREE(pCtx, pStringGidRepoPath);
SG_STRING_NULLFREE(pCtx, pStringErr);
}
/**
* Do diff of an individual item.
* When WC-based, we have a "DiffStep" vhash.
* When historical, we have an item from a pvaStatus.
*
*/
static void _do_diff1(SG_context * pCtx,
SG_bool bWC,
const SG_option_state * pOptSt,
const SG_vhash * pvhItem,
SG_uint32 * piResult)
{
SG_string * pStringGidRepoPath = NULL;
SG_vhash * pvhResultCodes = NULL;
SG_stringarray * psa1 = NULL;
const char * pszGid;
SG_int64 i64Result = 0;
SG_string * pStringErr = NULL;
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, pvhItem, "gid", &pszGid) );
if (bWC)
{
SG_pathname * pPathWc = NULL;
SG_bool bHasTool = SG_FALSE;
// With the __diff__setup() and __diff__run() changes, we have already
// examined the items during the __setup() step and recorded a tool for
// the *FILE* that have changed content. So if "tool" isn't set in the
// DiffStep/Item, we don't need to diff it -- it could be a structural
// change, a non-file, a found item, etc.
//
// we do not use SG_wc__diff__throw() because we already have the diff info
// and we want to control the result-code processing below.
SG_ERR_CHECK( SG_vhash__has(pCtx, pvhItem, "tool", &bHasTool) );
if (bHasTool)
SG_ERR_CHECK( SG_wc__diff__run(pCtx, pPathWc, pvhItem, &pvhResultCodes) );
}
else
{
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &pStringGidRepoPath) );
SG_ERR_CHECK( SG_string__sprintf(pCtx, pStringGidRepoPath, "@%s", pszGid) );
SG_ERR_CHECK( SG_STRINGARRAY__ALLOC(pCtx, &psa1, 1) );
SG_ERR_CHECK( SG_stringarray__add(pCtx, psa1, SG_string__sz(pStringGidRepoPath)) );
// we do not use the __throw() version of this routine so we can control
// result-code processing below.
SG_ERR_CHECK( SG_vv2__diff_to_stream(pCtx, pOptSt->psz_repo, pOptSt->pRevSpec,
psa1, 0,
SG_FALSE, // bNoSort
SG_TRUE, // bInteractive,
pOptSt->psz_tool,
&pvhResultCodes) );
}
if (pvhResultCodes)
{
SG_vhash * pvhResult; // we do not own this
SG_ERR_CHECK( SG_vhash__check__vhash(pCtx, pvhResultCodes, pszGid, &pvhResult) );
if (pvhResult)
{
const char * pszTool;
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, pvhResult, "tool", &pszTool) );
SG_ERR_CHECK( SG_vhash__get__int64(pCtx, pvhResult, "result", &i64Result) );
SG_difftool__check_result_code__throw(pCtx, i64Result, pszTool);
if (SG_context__has_err(pCtx))
{
SG_context__err_to_string(pCtx, SG_FALSE, &pStringErr);
SG_context__err_reset(pCtx);
SG_ERR_CHECK( SG_console__raw(pCtx, SG_CS_STDERR, SG_string__sz(pStringErr)) );
// eat the tool error. the result code is set.
}
}
}
if (piResult)
*piResult = (SG_uint32)i64Result;
fail:
SG_STRING_NULLFREE(pCtx, pStringGidRepoPath);
SG_VHASH_NULLFREE(pCtx, pvhResultCodes);
SG_STRINGARRAY_NULLFREE(pCtx, psa1);
SG_STRING_NULLFREE(pCtx, pStringErr);
}
