void u0051_hidlookup__commit_all(
SG_context* pCtx,
const SG_pathname* pPathWorkingDir,
SG_dagnode** ppdn
)
{
SG_pendingtree* pPendingTree = NULL;
SG_repo* pRepo = NULL;
SG_dagnode* pdn = NULL;
SG_audit q;
SG_ERR_CHECK( SG_pendingtree__alloc(pCtx, pPathWorkingDir, SG_FALSE, &pPendingTree) );
SG_ERR_CHECK( SG_pendingtree__get_repo(pCtx, pPendingTree, &pRepo) );
SG_ERR_CHECK( SG_audit__init(pCtx, &q, pRepo, SG_AUDIT__WHEN__NOW, SG_AUDIT__WHO__FROM_SETTINGS) );
SG_ERR_CHECK( unittests_pendingtree__commit(pCtx, pPendingTree, &q, NULL, 0, NULL, NULL, 0, NULL, 0, NULL, 0, &pdn) );
SG_PENDINGTREE_NULLFREE(pCtx, pPendingTree);
*ppdn = pdn;
return;
fail:
SG_PENDINGTREE_NULLFREE(pCtx, pPendingTree);
}
/**
* Find the appropriate external tool to let the user perform a TEXT MERGE
* on a file.
*
* TODO 2010/07/13 For now, this is hard-coded to use DiffMerge.
* TODO Later we want to allow them to have multiple
* TODO tools configured and/or to use the file suffix
* TODO and so on.
*/
static void _resolve__external_tool__lookup(SG_context * pCtx,
struct _resolve_data * pData,
const char * pszGid,
const SG_vhash * pvhIssue,
SG_string * pStrRepoPath,
_resolve__external_tool ** ppET)
{
_resolve__external_tool * pET = NULL;
SG_repo * pRepo;
SG_UNUSED( pszGid );
SG_UNUSED( pvhIssue );
SG_ERR_CHECK( SG_pendingtree__get_repo(pCtx, pData->pPendingTree, &pRepo) );
SG_ERR_CHECK( SG_alloc1(pCtx, pET) );
// TODO 2010/07/13 Use localsettings to determine WHICH external tool we should use.
// TODO (This could be based upon suffixes and/or whatever.)
// TODO Then -- for THAT tool -- lookup the program executable path and
// TODO the argument list.
// TODO Substitute the given pathnames into the argument list.
// TODO
// TODO For now, we just hard-code DiffMerge.
SG_ERR_CHECK( SG_strdup(pCtx, "DiffMerge", &pET->pszName) );
SG_localsettings__get__sz(pCtx, "merge/diffmerge/program", pRepo, &pET->pszExe, NULL);
if (SG_context__has_err(pCtx) || (!pET->pszExe) || (!*pET->pszExe))
{
SG_context__err_reset(pCtx);
SG_ERR_THROW2( SG_ERR_NO_MERGE_TOOL_CONFIGURED,
(pCtx, "'%s' Use 'vv localsetting set merge/diffmerge/program' and retry -or- manually merge content and then use 'vv resolve --mark'.",
SG_string__sz(pStrRepoPath)) );
}
// TODO 2010/07/13 Get argvec.
*ppET = pET;
return;
fail:
_RESOLVE__EXTERNAL_TOOL__NULLFREE(pCtx, pET);
}
static void _advise_after_update(SG_context * pCtx,
SG_option_state * pOptSt,
SG_pathname * pPathCwd,
const char * pszBaselineBeforeUpdate)
{
SG_pendingtree * pPendingTree = NULL;
SG_repo * pRepo;
char * pszBaselineAfterUpdate = NULL;
SG_rbtree * prbLeaves = NULL;
SG_uint32 nrLeaves;
SG_bool bUpdateChangedBaseline;
// re-open pendingtree to get the now-current baseline (we have to do
// this in a new instance because the UPDATE saves the pendingtree which
// frees all of the interesting stuff).
SG_ERR_CHECK( SG_PENDINGTREE__ALLOC(pCtx, pPathCwd, pOptSt->bIgnoreWarnings, &pPendingTree) );
SG_ERR_CHECK( SG_pendingtree__get_repo(pCtx, pPendingTree, &pRepo) );
SG_ERR_CHECK( _get_baseline(pCtx, pPendingTree, &pszBaselineAfterUpdate) );
// see if the update actually changed the baseline.
bUpdateChangedBaseline = (strcmp(pszBaselineBeforeUpdate, pszBaselineAfterUpdate) != 0);
// get the list of all heads/leaves.
//
// TODO 2010/06/30 Revisit this when we have NAMED BRANCHES because we
// TODO want to filter this list for things within their BRANCH.
SG_ERR_CHECK( SG_repo__fetch_dag_leaves(pCtx,pRepo,SG_DAGNUM__VERSION_CONTROL,&prbLeaves) );
#if defined(DEBUG)
{
SG_bool bFound = SG_FALSE;
SG_ERR_CHECK( SG_rbtree__find(pCtx, prbLeaves, pszBaselineAfterUpdate, &bFound, NULL) );
SG_ASSERT( (bFound) );
}
#endif
SG_ERR_CHECK( SG_rbtree__count(pCtx, prbLeaves, &nrLeaves) );
if (nrLeaves > 1)
{
if (bUpdateChangedBaseline)
{
SG_ERR_IGNORE( SG_console(pCtx, SG_CS_STDOUT,
"Baseline updated to descendant head, but there are multiple heads; consider merging.\n") );
}
else
{
SG_ERR_IGNORE( SG_console(pCtx, SG_CS_STDOUT,
"Baseline already at head, but there are multiple heads; consider merging.\n") );
}
}
else
{
if (bUpdateChangedBaseline)
{
SG_ERR_IGNORE( SG_console(pCtx, SG_CS_STDOUT,
"Baseline updated to head.\n") );
}
else
{
SG_ERR_IGNORE( SG_console(pCtx, SG_CS_STDOUT,
"Baseline already at head.\n") );
}
}
fail:
SG_PENDINGTREE_NULLFREE(pCtx, pPendingTree);
SG_RBTREE_NULLFREE(pCtx, prbLeaves);
SG_NULLFREE(pCtx, pszBaselineAfterUpdate);
}
/**
* Handle the UPDATE command.
*
*
*/
void do_cmd_update(SG_context * pCtx,
SG_option_state * pOptSt)
{
SG_pathname * pPathCwd = NULL;
SG_pendingtree * pPendingTree = NULL;
SG_repo * pRepo;
char * pszTargetChangeset = NULL;
char * pszBaselineBeforeUpdate = NULL;
// use the current directory to find the pending-tree, the repo, and the current baseline.
SG_ERR_CHECK( SG_PATHNAME__ALLOC(pCtx, &pPathCwd) );
SG_ERR_CHECK( SG_pathname__set__from_cwd(pCtx, pPathCwd) );
SG_ERR_CHECK( SG_PENDINGTREE__ALLOC(pCtx, pPathCwd, pOptSt->bIgnoreWarnings, &pPendingTree) );
SG_ERR_CHECK( SG_pendingtree__get_repo(pCtx, pPendingTree, &pRepo) );
SG_ERR_CHECK( _get_baseline(pCtx, pPendingTree, &pszBaselineBeforeUpdate) );
// determine the target changeset
// we check that we have at most 1 rev *or* 1 tag up in sg.c
if (pOptSt->iCountRevs == 1)
{
SG_rev_tag_obj* pRTobj = NULL;
const char * psz_rev_0;
SG_ERR_CHECK( SG_vector__get(pCtx, pOptSt->pvec_rev_tags, 0, (void**)&pRTobj) );
psz_rev_0 = pRTobj->pszRevTag;
SG_ERR_CHECK( SG_repo__hidlookup__dagnode(pCtx, pRepo, SG_DAGNUM__VERSION_CONTROL, psz_rev_0, &pszTargetChangeset) );
}
else if (pOptSt->iCountTags == 1)
{
SG_rev_tag_obj* pRTobj = NULL;
const char * psz_tag_0;
SG_ERR_CHECK( SG_vector__get(pCtx, pOptSt->pvec_rev_tags, 0, (void**)&pRTobj) );
psz_tag_0 = pRTobj->pszRevTag;
SG_ERR_CHECK( SG_vc_tags__lookup__tag(pCtx, pRepo, psz_tag_0, &pszTargetChangeset) );
}
else
{
// pass NULL for target changeset and let the UPDATE code find the proper head/tip.
}
SG_ERR_CHECK( _my_do_cmd_update(pCtx, pOptSt, pPendingTree, pszTargetChangeset) );
SG_PENDINGTREE_NULLFREE(pCtx, pPendingTree);
pRepo = NULL;
if (pszTargetChangeset == NULL)
{
// if they didn't ask for a specific changeset (and we successfully
// went to the SINGLE/UNIQUE DESCENDANT HEAD from their (then current)
// BASELINE, we should look around and see if there are other heads/leaves
// and advise them to MERGE with them.
//
// Since we did successfully do the UPDATE we should exit with OK, so
// I'm going to do all of this advisory stuff in an IGNORE.
SG_ERR_IGNORE( _advise_after_update(pCtx, pOptSt, pPathCwd, pszBaselineBeforeUpdate) );
}
fail:
SG_PENDINGTREE_NULLFREE(pCtx, pPendingTree);
SG_PATHNAME_NULLFREE(pCtx, pPathCwd);
SG_NULLFREE(pCtx, pszTargetChangeset);
SG_NULLFREE(pCtx, pszBaselineBeforeUpdate);
}