Question

Here is the workflow.

1. User has created a branch from default to do work for bug 123.
2. User does some work, including a lot of commits WITHOUT a BugzID:123 in the messages.
3. User then merges this branch into default WITH a BugzID:123 in the message.
4. User pushes to central repo

Fogbugz mercurial integration does not pick up the files that were modified/added from the branch. It only picks up the files that may have been modified due to a manual merge.

Is this intended behavior? We typically tag or create a named branch with the bug id in it so we don't really want to HAVE to have the BugzID:123 in every single commit.

If not, is there something I'm missing. Normal commit/push workflow off default seems to work fine and always has the files I expect.

I thought about modifying the fogbugz.py file to recursively go through all the parent changesets not default, but this seems like a brute force option for something I expect to work already.

Answer 1

For those interested, I have modified the fogbugz.py file to get files from merged branches into the fogbugz system. It's still a work in progress, but it works for us.

def process(self, node=None):
    """Begins processing on the given node"""
    ctxNew = self.repo.changectx(node)
    ctxOld = self.repo.changectx(ctxNew.rev() - 1)
    ids = self.extract_bug_ids(ctxNew)
    if not ids:
        return
    for bugId in ids:
        for filename in ctxNew.files():
            newRev = ctxNew.rev()
            oldRev = 0
            # FogBugz wants the new and old rev.  We actually only
            # need the new one for Mercurial, but placate FogBugz's
            # CVS-centric view anyway
            try:
                oldRev = ctxOld.filectx(filename).rev()
            except:
                pass
            self.submit(bugId, filename, oldRev, newRev)
        self.extract_files_recursive(ctxNew, bugId) #this is the new line, I didn't want to disturb the whole code base

Then somewhere in the class

def extract_files_recursive(self, ctx, bugId):
    ccparents = ctx.parents()
    if len(ccparents) == 1:
        parent = ccparents[0]
        branch = parent.branch()
        if branch == "default":
            return
    for parentCtx in ccparents:
        branch = parentCtx.branch()
        if branch != "default":
            for filename in parentCtx.files():
                newRev = parentCtx.rev()
                oldRev = 0
                # FogBugz wants the new and old rev.  We actually only
                # need the new one for Mercurial, but placate FogBugz's
                # CVS-centric view anyway
                try:
                    oldRev = ctxOld.filectx(filename).rev()
                except:
                    pass
                self.submit(bugId, filename, oldRev, newRev)
            self.extract_files_recursive(parentCtx, bugId)

Answer 2

I agree that this would potentially be quite useful (thanks for filing the feature request!), but IMVHO, if you only have a single case open for an entire branch with many changesets, you probably haven't specified the work to be completed sufficiently (see Joel's article on EBS...specifically the "Break 'er down" section).

Having one parent case for the branch's work (e.g. "Add feature X") and multiple subcases is probably closer to the workflow I usually use. This way each changeset can have a bugzid with only a few of them sharing any single bugzid. I think the granularity is helpful...especially when I come back to look at a change that was made 6 months ago.

This is just my personal view though...which might not be applicable/useful at all. :)