comparison contrib/phabricator.py @ 33691:1664406a44d9

phabricator: use Phabricator's last node information

This makes it more strict when checking whether or not we should update a
Differential Revision. For example,

  a) Alice updates D1 to content 1.
  b) Bob updates D1 to content 2.
  c) Alice tries to update D1 to content 1.

Previously, `c)` will do nothing because `phabsend` detects the patch is not
changed. A more correct behavior is to override Bob's update here, hence the
patch.

This also makes it possible to return a reaonsable "last node" when there is
no tags but only `Differential Revision` commit messages.

Test Plan:
```
for i in A B C; do echo $i > $i; hg ci -m $i -A $i; done

hg phabsend 0::
# D40: created
# D41: created
# D42: created

echo 3 >> C; hg amend; hg phabsend .
# D42: updated

hg tag --local --hidden -r 2 -f D42
# move tag to the previous version

hg phabsend .
# D42: skipped (previously it would be "updated")

rm -rf .hg; hg init
hg phabread --stack D42 | hg import -
hg phabsend .
# D42: updated
hg tag --local --remove D42
hg commit --amend
hg phabsend .
# D42: updated (no new diff uploaded, previously it will upload a new diff)
```

The old diff object is now returned, which could be useful in the next
patch.

Differential Revision: https://phab.mercurial-scm.org/D121

33690:40cfe3197bc1

    repo.ui.setconfig('phabricator', 'repophid', repophid)
    return repophid

_differentialrevisiontagre = re.compile('\AD([1-9][0-9]*)\Z')
_differentialrevisiondescre = re.compile(
    '^Differential Revision:\s*(.*)D([1-9][0-9]*)$', re.M)

def getoldnodedrevmap(repo, nodelist):
    """find previous nodes that has been sent to Phabricator

    return {node: (oldnode or None, Differential Revision ID)}
    for node in nodelist with known previous sent versions, or associated
    Differential Revision IDs.

    Examines all precursors and their tags. Tags with format like "D1234" are
    considered a match and the node with that tag, and the number after "D"
    (ex. 1234) will be returned.

    If tags are not found, examine commit message. The "Differential Revision:"
    line could associate this changeset to a Differential Revision.
    """
    url, token = readurltoken(repo)
    unfi = repo.unfiltered()
    nodemap = unfi.changelog.nodemap

    result = {} # {node: (oldnode or None, drev)}
    toconfirm = {} # {node: (oldnode, {precnode}, drev)}
    for node in nodelist:
        ctx = unfi[node]
        # For tags like "D123", put them into "toconfirm" to verify later
        precnodes = list(obsolete.allprecursors(unfi.obsstore, [node]))
        for n in precnodes:
            if n in nodemap:
                for tag in unfi.nodetags(n):
                    m = _differentialrevisiontagre.match(tag)
                    if m:
                        toconfirm[node] = (n, set(precnodes), int(m.group(1)))
                        continue

        # Check commit message (make sure URL matches)
        m = _differentialrevisiondescre.search(ctx.description())
        if m:
            if m.group(1).rstrip('/') == url.rstrip('/'):
                result[node] = (None, int(m.group(2)))
            else:
                unfi.ui.warn(_('%s: Differential Revision URL ignored - host '
                               'does not match config\n') % ctx)

    # Double check if tags are genuine by collecting all old nodes from
    # Phabricator, and expect precursors overlap with it.
    if toconfirm:
        confirmed = {} # {drev: {oldnode}}
        drevs = [drev for n, precs, drev in toconfirm.values()]
        diffs = callconduit(unfi, 'differential.querydiffs',
                            {'revisionIDs': drevs})
        for diff in diffs.values():
            drev = int(diff[r'revisionID'])
            oldnode = bin(encoding.unitolocal(getdiffmeta(diff).get(r'node')))
            if node:
                confirmed.setdefault(drev, set()).add(oldnode)
        for newnode, (oldnode, precset, drev) in toconfirm.items():
            if bool(precset & confirmed.get(drev, set())):
                result[newnode] = (oldnode, drev)
            else:
                tagname = 'D%d' % drev
                tags.tag(repo, tagname, nullid, message=None, user=None,
                         date=None, local=True)
                unfi.ui.warn(_('D%s: local tag removed - does not match '
                               'Differential history\n') % drev)

    return result

def getdiff(ctx, diffopts):
    """plain-text diff without header (user, commit message, etc)"""

    reviewers = opts.get('reviewer', [])
    if reviewers:
        phids = userphids(repo, reviewers)
        actions.append({'type': 'reviewers.add', 'value': phids})

    oldnodedrev = getoldnodedrevmap(repo, [repo[r].node() for r in revs])

    # Send patches one by one so we know their Differential Revision IDs and
    # can provide dependency relationship
    lastrevid = None
    for rev in revs:
        ui.debug('sending rev %d\n' % rev)
        ctx = repo[rev]

        # Get Differential Revision ID
        oldnode, revid = oldnodedrev.get(ctx.node(), (None, None))
        if oldnode != ctx.node():
            # Create or update Differential Revision
            revision = createdifferentialrevision(ctx, revid, lastrevid,
                                                  oldnode, actions)
            newrevid = int(revision[r'object'][r'id'])

33691:1664406a44d9

    repo.ui.setconfig('phabricator', 'repophid', repophid)
    return repophid

_differentialrevisiontagre = re.compile('\AD([1-9][0-9]*)\Z')
_differentialrevisiondescre = re.compile(
    '^Differential Revision:\s*(?:.*)D([1-9][0-9]*)$', re.M)

def getoldnodedrevmap(repo, nodelist):
    """find previous nodes that has been sent to Phabricator

    return {node: (oldnode, Differential diff, Differential Revision ID)}
    for node in nodelist with known previous sent versions, or associated
    Differential Revision IDs. ``oldnode`` and ``Differential diff`` could
    be ``None``.

    Examines commit messages like "Differential Revision:" to get the
    association information.

    If such commit message line is not found, examines all precursors and their
    tags. Tags with format like "D1234" are considered a match and the node
    with that tag, and the number after "D" (ex. 1234) will be returned.

    The ``old node``, if not None, is guaranteed to be the last diff of
    corresponding Differential Revision, and exist in the repo.
    """
    url, token = readurltoken(repo)
    unfi = repo.unfiltered()
    nodemap = unfi.changelog.nodemap

    result = {} # {node: (oldnode?, lastdiff?, drev)}
    toconfirm = {} # {node: (force, {precnode}, drev)}
    for node in nodelist:
        ctx = unfi[node]
        # For tags like "D123", put them into "toconfirm" to verify later
        precnodes = list(obsolete.allprecursors(unfi.obsstore, [node]))
        for n in precnodes:
            if n in nodemap:
                for tag in unfi.nodetags(n):
                    m = _differentialrevisiontagre.match(tag)
                    if m:
                        toconfirm[node] = (0, set(precnodes), int(m.group(1)))
                        continue

        # Check commit message
        m = _differentialrevisiondescre.search(ctx.description())
        if m:
            toconfirm[node] = (1, set(precnodes), int(m.group(1)))

    # Double check if tags are genuine by collecting all old nodes from
    # Phabricator, and expect precursors overlap with it.
    if toconfirm:
        drevs = [drev for force, precs, drev in toconfirm.values()]
        alldiffs = callconduit(unfi, 'differential.querydiffs',
                               {'revisionIDs': drevs})
        getnode = lambda d: bin(encoding.unitolocal(
            getdiffmeta(d).get(r'node', ''))) or None
        for newnode, (force, precset, drev) in toconfirm.items():
            diffs = [d for d in alldiffs.values()
                     if int(d[r'revisionID']) == drev]

            # "precursors" as known by Phabricator
            phprecset = set(getnode(d) for d in diffs)

            # Ignore if precursors (Phabricator and local repo) do not overlap,
            # and force is not set (when commit message says nothing)
            if not force and not bool(phprecset & precset):
                tagname = 'D%d' % drev
                tags.tag(repo, tagname, nullid, message=None, user=None,
                         date=None, local=True)
                unfi.ui.warn(_('D%s: local tag removed - does not match '
                               'Differential history\n') % drev)
                continue

            # Find the last node using Phabricator metadata, and make sure it
            # exists in the repo
            oldnode = lastdiff = None
            if diffs:
                lastdiff = max(diffs, key=lambda d: int(d[r'id']))
                oldnode = getnode(lastdiff)
                if oldnode and oldnode not in nodemap:
                    oldnode = None

            result[newnode] = (oldnode, lastdiff, drev)

    return result

def getdiff(ctx, diffopts):
    """plain-text diff without header (user, commit message, etc)"""

    reviewers = opts.get('reviewer', [])
    if reviewers:
        phids = userphids(repo, reviewers)
        actions.append({'type': 'reviewers.add', 'value': phids})

    # {newnode: (oldnode, olddiff, olddrev}
    oldmap = getoldnodedrevmap(repo, [repo[r].node() for r in revs])

    # Send patches one by one so we know their Differential Revision IDs and
    # can provide dependency relationship
    lastrevid = None
    for rev in revs:
        ui.debug('sending rev %d\n' % rev)
        ctx = repo[rev]

        # Get Differential Revision ID
        oldnode, olddiff, revid = oldmap.get(ctx.node(), (None, None, None))
        if oldnode != ctx.node():
            # Create or update Differential Revision
            revision = createdifferentialrevision(ctx, revid, lastrevid,
                                                  oldnode, actions)
            newrevid = int(revision[r'object'][r'id'])