Prevent mercurial precommit hook from running on histedit - mercurial

Question

I would like to run clang-format (actually clang-format-diff.py, to format only what's changed) on the code I commit in Mercurial automatically. I know I can do it with a precommit hook. In fact, I've done it in the past but it messed up some histedits, so I removed the hook, and now do it manually, running the command before commiting.
Obviously, the problem is I can, and do, forget to do it sometimes.
Is there any way to run the hook only on "normal" commits, not the ones on histedit or rebase?

Answer 1

There's not a direct way as far as I know. But you can create yourself an alias to use instead of rebase and histedit, let's call them hrebase and hhistedit which disable the hook for their usage.
In order to disable a hook for a single run on the command line you can use --config hook.HOOKNAME=, thus for instance:
hg --config hook.HOOKNAME= rebase -d2 -b5
and you thus define your alias:
[alias]
hrebase = rebase --config hook.HOOKNAME=
hhistedit = histedit --config hook.HOOKNAME=

Answer 2

In order to wrap a single command (in your case, commit) you can either use an alias or an extension. The alias approach is fairly simple, but has some drawbacks. Example for an alias:
commit = !$HG commit --config alias.commit=commit --config hooks.precommit.clang=/tmp/msg "$#"
There are a few subtle issues involved in creating such an alias: first, normal aliases do not accept a --config paramater (all configuration has already been parsed at the point of alias expansion). Therefore, we need to use a shell alias (!$HG) in order to work around this problem; second, in order to avoid getting stuck in a recursion during shell alias expansion (unlike normal aliases, Mercurial cannot do this for shell aliases), we have to realias commit to itself (hence the --config alias.commit=commit part).
This approach has a couple of downsides: First, it doubles startup time (because Mercurial gets invoked twice for a shell alias); while this is relatively little overhead, it can be sufficient to be annoying for a human user. Second, it interacts poorly with scripting; scripts and GUIs may either unintentionally use the alias when they don't intend to or (worse) disable it, thus bypassing the hook.
An alternative is to use an extension to wrap the commit command. For example:
# Simple extension to provide a hook for manual commits only
"""hook for manual commits
This extension allows the selective definition of a hook for
manual commits only (i.e. outside graft, histedit, rebase, etc.).
In order to use it, add the following lines to your ``.hg/hgrc`` or
``~/.hgrc`` file::
[extensions]
manualcommithook=/path/to/extension
[hooks]
premanualcommit=/path/to/hook
The ``hooks.premanualcommit`` hook will then be (temporarily) installed
under ``hooks.precommit.manual``, but only for manual commits.
"""
from mercurial import commands, extensions
def commit_with_hook(original_cmd, ui, repo, *pats, **opts):
hook = ui.config("hooks", "premanualcommit")
if hook:
if ui.config("hooks", "precommit.manual"):
ui.warn("overriding existing precommit.manual hook\n")
ui.setconfig("hooks", "precommit.manual", hook)
return original_cmd(ui, repo, *pats, **opts)
def uisetup(ui):
extensions.wrapcommand(commands.table, "commit", commit_with_hook)
See the doc comment for instructions on how to use the extension.