Hi Mario,
thanks for sending these use-cases out. Let me give some feedback:
Mario wrote:
Technical talk: USE CASE A: Integrate issue property editing with
Mercurial, including:
* USE CASE A1: Allow users to close issues via tokens embedded
into commit messages.
* USE CASE A2: Allow users to change issue status via tokens
embedded into commit messages.
This is the most fundamental one, and it is implementable without even
touching Roundup itself. All that is required is a 'post-commit-hook'
(whatever that is spelled for a particular VCS) that sends a mail to a
tracker, if some tokens were found in the commit message. While in
theory this is all up for customization, I think it would be nice to set
up some conventions to guide users in how to do this (the 'token
grammar', mostly), just for convenience.
Ronny is about to fix a torny bug, so he has a public branch for that.
He is making great progress, but the issue that tracks the bug only
contains a very out-of-date patch, prompting other developers to try
to fix the same bug. Ronny should be able to tell Roundup about where
his code lives, so users can get up-to-date patches/diffs
automatically. This also allows other users to know all the code that
changed to fix a given bug.
Technical talk: Integrate branch and rich patch handling into Roundup
* USE CASE B: Track all changesets that relate to a given issue:
o USE CASE B1: Using tokens embedded into commit messages.
(Post commit)
o USE CASE B2: Using named branches, bookmarks. (Pre or post commit)
o USE CASE B3: Using patchsets, bundles or whatchacallit for
fat Mercurial patches. (Pre or post commit)
Hmm, I have difficulties mapping your prosaic description of the use
case above to the 'technical talk'. The latter almost sounds like an
implementation strategy to me.
This is a very interesting use case, driving us at the core of the 'VCS
integration'. We need to customize a schema to provide a notion for
'repository' and 'branch', and also for 'patch'. Then we need to somehow
endow the patch type with knowledge of what it means to be 'applied' to
a branch, etc. (more on this below).
Brett wants to fix a couple of related issues and has a local
Mercurial branch for that. He would like his commit messages to
include useful information for when his patch/branch lands in the
Python repository. Besides the Mercurial->Roundup integration, a
Roundup->Mercurial one that would allow one to fetch issue details and
existing patches/branches with metadata would make Brett's work more
valuable.
Technical talk: USE CASE C: Add a CLI interface for Roundup so VCSs
can query the tracker.
* USE CASE C1: Automatically fetch issue data.
* USE CASE C2: Pre-format output for greater usefulness in commit messages:
o USE CASE C2.1: Setting issue properties.
o USE CASE C2.2: Grouping changesets.
* USE CASE C3: Fetch branch information for local cloning.
* USE CASE C4: Add a Mercurial extension to exercize the CLI client.
This set of use cases ('C') is what I have most difficulties with. It
clearly is about 'VCS <-> Roundup integration', but it's in the other
direction. And thus, this doesn't seem to concern Roundup itself, or
does it ? Presumably, everything needed already exists. We now have an
XMLRPC interface, so it is possible to write (remote) Roundup clients. I
think writing such a 'Roundup client library' would be useful, but I
think somewhat out of scope with respect to this GSoC project.
USE CASE D:
Antoine is merging lots of branches and applying lots of patches to
his local branch of the Python repository. He goes to each issue with
a patch/branch and tells people whether their patches apply cleanly,
just to avoid merge issues in the main branch. While he could use
Mercurial Patch Queues (mq), Roundup would need to learn to both
listen to and to submit patches to mq in order to completely replace
Antoine's work with automated tools. Having a quick 'check if this
patch applies cleanly' button would make triaging issues much easier.
Let's drill down here a little, as this may be more than one use-case:
D1: provide an interface through which users can attempt to apply a
submitted patch to a given branch.
This requires a 'working copy' of the code (Roundup may be
configured to create that if it doesn't exist yet), and a simple
interface to the 'patch' tool. If we create a new 'Patch' type, it may
include metadata that help Roundup to figure out what repo / branch URL
to use to fetch the code from against which the patch is to be applied
against.
D2: While D1 is about applying patches, this may not be enough to figure
out whether the patch is good. The user may also want to attempt to
build the code (and even run tests). While I believe this to be outside
the realm of a bug / patch tracker, I can see good use in integration
with external build tools. In fact, it is a u
