hgext: enable extensions without "hgext." prefix in help texts

hgext/acl.py

@@ -1,107 +1,107 b''
 # acl.py - changeset access control for mercurial
 #
 # Copyright 2006 Vadim Gelfer <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 #
 
 '''hooks for controlling repository access
 
 This hook makes it possible to allow or deny write access to portions
 of a repository when receiving incoming changesets.
 
 The authorization is matched based on the local user name on the
 system where the hook runs, and not the committer of the original
 changeset (since the latter is merely informative).
 
 The acl hook is best used along with a restricted shell like hgsh,
 preventing authenticating users from doing anything other than
 pushing or pulling. The hook is not safe to use if users have
 interactive shell access, as they can then disable the hook.
 Nor is it safe if remote users share an account, because then there
 is no way to distinguish them.
 
 To use this hook, configure the acl extension in your hgrc like this::
 
   [extensions]
-  hgext.acl =
+  acl =
 
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
 
   [acl]
   # Check whether the source of incoming changes is in this list
   # ("serve" == ssh or http, "push", "pull", "bundle")
   sources = serve
 
 The allow and deny sections take a subtree pattern as key (with a glob
 syntax by default), and a comma separated list of users as the
 corresponding value. The deny list is checked before the allow list
 is. ::
 
   [acl.allow]
   # If acl.allow is not present, all users are allowed by default.
   # An empty acl.allow section means no users allowed.
   docs/** = doc_writer
   .hgtags = release_engineer
 
   [acl.deny]
   # If acl.deny is not present, no users are refused by default.
   # An empty acl.deny section means all users allowed.
   glob pattern = user4, user5
    ** = user6
 '''
 
 from mercurial.i18n import _
 from mercurial import util, match
 import getpass, urllib
 
 def buildmatch(ui, repo, user, key):
     '''return tuple of (match function, list enabled).'''
     if not ui.has_section(key):
         ui.debug('acl: %s not enabled\n' % key)
         return None
 
     pats = [pat for pat, users in ui.configitems(key)
             if user in users.replace(',', ' ').split()]
     ui.debug('acl: %s enabled, %d entries for user %s\n' %
              (key, len(pats), user))
     if pats:
         return match.match(repo.root, '', pats)
     return match.exact(repo.root, '', [])
 
 
 def hook(ui, repo, hooktype, node=None, source=None, **kwargs):
     if hooktype != 'pretxnchangegroup':
         raise util.Abort(_('config error - hook type "%s" cannot stop '
                            'incoming changesets') % hooktype)
     if source not in ui.config('acl', 'sources', 'serve').split():
         ui.debug('acl: changes have source "%s" - skipping\n' % source)
         return
 
     user = None
     if source == 'serve' and 'url' in kwargs:
         url = kwargs['url'].split(':')
         if url[0] == 'remote' and url[1].startswith('http'):
             user = urllib.unquote(url[3])
 
     if user is None:
         user = getpass.getuser()
 
     cfg = ui.config('acl', 'config')
     if cfg:
         ui.readconfig(cfg, sections = ['acl.allow', 'acl.deny'])
     allow = buildmatch(ui, repo, user, 'acl.allow')
     deny = buildmatch(ui, repo, user, 'acl.deny')
 
     for rev in xrange(repo[node], len(repo)):
         ctx = repo[rev]
         for f in ctx.files():
             if deny and deny(f):
                 ui.debug('acl: user %s denied on %s\n' % (user, f))
                 raise util.Abort(_('acl: access denied for changeset %s') % ctx)
             if allow and not allow(f):
                 ui.debug('acl: user %s not allowed on %s\n' % (user, f))
                 raise util.Abort(_('acl: access denied for changeset %s') % ctx)
         ui.debug('acl: allowing changeset %s\n' % ctx)

hgext/bugzilla.py

@@ -1,439 +1,439 b''
 # bugzilla.py - bugzilla integration for mercurial
 #
 # Copyright 2006 Vadim Gelfer <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 '''hooks for integrating with the Bugzilla bug tracker
 
 This hook extension adds comments on bugs in Bugzilla when changesets
 that refer to bugs by Bugzilla ID are seen. The hook does not change
 bug status.
 
 The hook updates the Bugzilla database directly. Only Bugzilla
 installations using MySQL are supported.
 
 The hook relies on a Bugzilla script to send bug change notification
 emails. That script changes between Bugzilla versions; the
 'processmail' script used prior to 2.18 is replaced in 2.18 and
 subsequent versions by 'config/sendbugmail.pl'. Note that these will
 be run by Mercurial as the user pushing the change; you will need to
 ensure the Bugzilla install file permissions are set appropriately.
 
 The extension is configured through three different configuration
 sections. These keys are recognized in the [bugzilla] section:
 
 host
   Hostname of the MySQL server holding the Bugzilla database.
 
 db
   Name of the Bugzilla database in MySQL. Default 'bugs'.
 
 user
   Username to use to access MySQL server. Default 'bugs'.
 
 password
   Password to use to access MySQL server.
 
 timeout
   Database connection timeout (seconds). Default 5.
 
 version
   Bugzilla version. Specify '3.0' for Bugzilla versions 3.0 and later,
   '2.18' for Bugzilla versions from 2.18 and '2.16' for versions prior
   to 2.18.
 
 bzuser
   Fallback Bugzilla user name to record comments with, if changeset
   committer cannot be found as a Bugzilla user.
 
 bzdir
    Bugzilla install directory. Used by default notify. Default
    '/var/www/html/bugzilla'.
 
 notify
   The command to run to get Bugzilla to send bug change notification
   emails. Substitutes from a map with 3 keys, 'bzdir', 'id' (bug id)
   and 'user' (committer bugzilla email). Default depends on version;
   from 2.18 it is "cd %(bzdir)s && perl -T contrib/sendbugmail.pl
   %(id)s %(user)s".
 
 regexp
   Regular expression to match bug IDs in changeset commit message.
   Must contain one "()" group. The default expression matches 'Bug
   1234', 'Bug no. 1234', 'Bug number 1234', 'Bugs 1234,5678', 'Bug
   1234 and 5678' and variations thereof. Matching is case insensitive.
 
 style
   The style file to use when formatting comments.
 
 template
   Template to use when formatting comments. Overrides style if
   specified. In addition to the usual Mercurial keywords, the
   extension specifies::
 
     {bug}       The Bugzilla bug ID.
     {root}      The full pathname of the Mercurial repository.
     {webroot}   Stripped pathname of the Mercurial repository.
     {hgweb}     Base URL for browsing Mercurial repositories.
 
   Default 'changeset {node|short} in repo {root} refers '
           'to bug {bug}.\\ndetails:\\n\\t{desc|tabindent}'
 
 strip
   The number of slashes to strip from the front of {root} to produce
   {webroot}. Default 0.
 
 usermap
   Path of file containing Mercurial committer ID to Bugzilla user ID
   mappings. If specified, the file should contain one mapping per
   line, "committer"="Bugzilla user". See also the [usermap] section.
 
 The [usermap] section is used to specify mappings of Mercurial
 committer ID to Bugzilla user ID. See also [bugzilla].usermap.
 "committer"="Bugzilla user"
 
 Finally, the [web] section supports one entry:
 
 baseurl
   Base URL for browsing Mercurial repositories. Reference from
   templates as {hgweb}.
 
 Activating the extension::
 
     [extensions]
-    hgext.bugzilla =
+    bugzilla =
 
     [hooks]
     # run bugzilla hook on every change pulled or pushed in here
     incoming.bugzilla = python:hgext.bugzilla.hook
 
 Example configuration:
 
 This example configuration is for a collection of Mercurial
 repositories in /var/local/hg/repos/ used with a local Bugzilla 3.2
 installation in /opt/bugzilla-3.2. ::
 
     [bugzilla]
     host=localhost
     password=XYZZY
     version=3.0
     bzuser=[e-mail]
     bzdir=/opt/bugzilla-3.2
     template=Changeset {node|short} in {root|basename}.
              {hgweb}/{webroot}/rev/{node|short}\\n
              {desc}\\n
     strip=5
 
     [web]
     baseurl=http://dev.domain.com/hg
 
     [usermap]
     [e-mail]=[e-mail]
 
 Commits add a comment to the Bugzilla bug record of the form::
 
     Changeset 3b16791d6642 in repository-name.
     http://dev.domain.com/hg/repository-name/rev/3b16791d6642
 
     Changeset commit comment. Bug 1234.
 '''
 
 from mercurial.i18n import _
 from mercurial.node import short
 from mercurial import cmdutil, templater, util
 import re, time
 
 MySQLdb = None
 
 def buglist(ids):
     return '(' + ','.join(map(str, ids)) + ')'
 
 class bugzilla_2_16(object):
     '''support for bugzilla version 2.16.'''
 
     def __init__(self, ui):
         self.ui = ui
         host = self.ui.config('bugzilla', 'host', 'localhost')
         user = self.ui.config('bugzilla', 'user', 'bugs')
         passwd = self.ui.config('bugzilla', 'password')
         db = self.ui.config('bugzilla', 'db', 'bugs')
         timeout = int(self.ui.config('bugzilla', 'timeout', 5))
         usermap = self.ui.config('bugzilla', 'usermap')
         if usermap:
             self.ui.readconfig(usermap, sections=['usermap'])
         self.ui.note(_('connecting to %s:%s as %s, password %s\n') %
                      (host, db, user, '*' * len(passwd)))
         self.conn = MySQLdb.connect(host=host, user=user, passwd=passwd,
                                     db=db, connect_timeout=timeout)
         self.cursor = self.conn.cursor()
         self.longdesc_id = self.get_longdesc_id()
         self.user_ids = {}
         self.default_notify = "cd %(bzdir)s && ./processmail %(id)s %(user)s"
 
     def run(self, *args, **kwargs):
         '''run a query.'''
         self.ui.note(_('query: %s %s\n') % (args, kwargs))
         try:
             self.cursor.execute(*args, **kwargs)
         except MySQLdb.MySQLError:
             self.ui.note(_('failed query: %s %s\n') % (args, kwargs))
             raise
 
     def get_longdesc_id(self):
         '''get identity of longdesc field'''
         self.run('select fieldid from fielddefs where name = "longdesc"')
         ids = self.cursor.fetchall()
         if len(ids) != 1:
             raise util.Abort(_('unknown database schema'))
         return ids[0][0]
 
     def filter_real_bug_ids(self, ids):
         '''filter not-existing bug ids from list.'''
         self.run('select bug_id from bugs where bug_id in %s' % buglist(ids))
         return sorted([c[0] for c in self.cursor.fetchall()])
 
     def filter_unknown_bug_ids(self, node, ids):
         '''filter bug ids from list that already refer to this changeset.'''
 
         self.run('''select bug_id from longdescs where
                     bug_id in %s and thetext like "%%%s%%"''' %
                  (buglist(ids), short(node)))
         unknown = set(ids)
         for (id,) in self.cursor.fetchall():
             self.ui.status(_('bug %d already knows about changeset %s\n') %
                            (id, short(node)))
             unknown.discard(id)
         return sorted(unknown)
 
     def notify(self, ids, committer):
         '''tell bugzilla to send mail.'''
 
         self.ui.status(_('telling bugzilla to send mail:\n'))
         (user, userid) = self.get_bugzilla_user(committer)
         for id in ids:
             self.ui.status(_('  bug %s\n') % id)
             cmdfmt = self.ui.config('bugzilla', 'notify', self.default_notify)
             bzdir = self.ui.config('bugzilla', 'bzdir', '/var/www/html/bugzilla')
             try:
                 # Backwards-compatible with old notify string, which
                 # took one string. This will throw with a new format
                 # string.
                 cmd = cmdfmt % id
             except TypeError:
                 cmd = cmdfmt % {'bzdir': bzdir, 'id': id, 'user': user}
             self.ui.note(_('running notify command %s\n') % cmd)
             fp = util.popen('(%s) 2>&1' % cmd)
             out = fp.read()
             ret = fp.close()
             if ret:
                 self.ui.warn(out)
                 raise util.Abort(_('bugzilla notify command %s') %
                                  util.explain_exit(ret)[0])
         self.ui.status(_('done\n'))
 
     def get_user_id(self, user):
         '''look up numeric bugzilla user id.'''
         try:
             return self.user_ids[user]
         except KeyError:
             try:
                 userid = int(user)
             except ValueError:
                 self.ui.note(_('looking up user %s\n') % user)
                 self.run('''select userid from profiles
                             where login_name like %s''', user)
                 all = self.cursor.fetchall()
                 if len(all) != 1:
                     raise KeyError(user)
                 userid = int(all[0][0])
             self.user_ids[user] = userid
             return userid
 
     def map_committer(self, user):
         '''map name of committer to bugzilla user name.'''
         for committer, bzuser in self.ui.configitems('usermap'):
             if committer.lower() == user.lower():
                 return bzuser
         return user
 
     def get_bugzilla_user(self, committer):
         '''see if committer is a registered bugzilla user. Return
         bugzilla username and userid if so. If not, return default
         bugzilla username and userid.'''
         user = self.map_committer(committer)
         try:
             userid = self.get_user_id(user)
         except KeyError:
             try:
                 defaultuser = self.ui.config('bugzilla', 'bzuser')
                 if not defaultuser:
                     raise util.Abort(_('cannot find bugzilla user id for %s') %
                                      user)
                 userid = self.get_user_id(defaultuser)
                 user = defaultuser
             except KeyError:
                 raise util.Abort(_('cannot find bugzilla user id for %s or %s') %
                                  (user, defaultuser))
         return (user, userid)
 
     def add_comment(self, bugid, text, committer):
         '''add comment to bug. try adding comment as committer of
         changeset, otherwise as default bugzilla user.'''
         (user, userid) = self.get_bugzilla_user(committer)
         now = time.strftime('%Y-%m-%d %H:%M:%S')
         self.run('''insert into longdescs
                     (bug_id, who, bug_when, thetext)
                     values (%s, %s, %s, %s)''',
                  (bugid, userid, now, text))
         self.run('''insert into bugs_activity (bug_id, who, bug_when, fieldid)
                     values (%s, %s, %s, %s)''',
                  (bugid, userid, now, self.longdesc_id))
         self.conn.commit()
 
 class bugzilla_2_18(bugzilla_2_16):
     '''support for bugzilla 2.18 series.'''
 
     def __init__(self, ui):
         bugzilla_2_16.__init__(self, ui)
         self.default_notify = "cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s"
 
 class bugzilla_3_0(bugzilla_2_18):
     '''support for bugzilla 3.0 series.'''
 
     def __init__(self, ui):
         bugzilla_2_18.__init__(self, ui)
 
     def get_longdesc_id(self):
         '''get identity of longdesc field'''
         self.run('select id from fielddefs where name = "longdesc"')
         ids = self.cursor.fetchall()
         if len(ids) != 1:
             raise util.Abort(_('unknown database schema'))
         return ids[0][0]
 
 class bugzilla(object):
     # supported versions of bugzilla. different versions have
     # different schemas.
     _versions = {
         '2.16': bugzilla_2_16,
         '2.18': bugzilla_2_18,
         '3.0':  bugzilla_3_0
         }
 
     _default_bug_re = (r'bugs?\s*,?\s*(?:#|nos?\.?|num(?:ber)?s?)?\s*'
                        r'((?:\d+\s*(?:,?\s*(?:and)?)?\s*)+)')
 
     _bz = None
 
     def __init__(self, ui, repo):
         self.ui = ui
         self.repo = repo
 
     def bz(self):
         '''return object that knows how to talk to bugzilla version in
         use.'''
 
         if bugzilla._bz is None:
             bzversion = self.ui.config('bugzilla', 'version')
             try:
                 bzclass = bugzilla._versions[bzversion]
             except KeyError:
                 raise util.Abort(_('bugzilla version %s not supported') %
                                  bzversion)
             bugzilla._bz = bzclass(self.ui)
         return bugzilla._bz
 
     def __getattr__(self, key):
         return getattr(self.bz(), key)
 
     _bug_re = None
     _split_re = None
 
     def find_bug_ids(self, ctx):
         '''find valid bug ids that are referred to in changeset
         comments and that do not already have references to this
         changeset.'''
 
         if bugzilla._bug_re is None:
             bugzilla._bug_re = re.compile(
                 self.ui.config('bugzilla', 'regexp', bugzilla._default_bug_re),
                 re.IGNORECASE)
             bugzilla._split_re = re.compile(r'\D+')
         start = 0
         ids = set()
         while True:
             m = bugzilla._bug_re.search(ctx.description(), start)
             if not m:
                 break
             start = m.end()
             for id in bugzilla._split_re.split(m.group(1)):
                 if not id: continue
                 ids.add(int(id))
         if ids:
             ids = self.filter_real_bug_ids(ids)
         if ids:
             ids = self.filter_unknown_bug_ids(ctx.node(), ids)
         return ids
 
     def update(self, bugid, ctx):
         '''update bugzilla bug with reference to changeset.'''
 
         def webroot(root):
             '''strip leading prefix of repo root and turn into
             url-safe path.'''
             count = int(self.ui.config('bugzilla', 'strip', 0))
             root = util.pconvert(root)
             while count > 0:
                 c = root.find('/')
                 if c == -1:
                     break
                 root = root[c+1:]
                 count -= 1
             return root
 
         mapfile = self.ui.config('bugzilla', 'style')
         tmpl = self.ui.config('bugzilla', 'template')
         t = cmdutil.changeset_templater(self.ui, self.repo,
                                         False, None, mapfile, False)
         if not mapfile and not tmpl:
             tmpl = _('changeset {node|short} in repo {root} refers '
                      'to bug {bug}.\ndetails:\n\t{desc|tabindent}')
         if tmpl:
             tmpl = templater.parsestring(tmpl, quoted=False)
             t.use_template(tmpl)
         self.ui.pushbuffer()
         t.show(ctx, changes=ctx.changeset(),
                bug=str(bugid),
                hgweb=self.ui.config('web', 'baseurl'),
                root=self.repo.root,
                webroot=webroot(self.repo.root))
         data = self.ui.popbuffer()
         self.add_comment(bugid, data, util.email(ctx.user()))
 
 def hook(ui, repo, hooktype, node=None, **kwargs):
     '''add comment to bugzilla for each changeset that refers to a
     bugzilla bug id. only add a comment once per bug, so same change
     seen multiple times does not fill bug with duplicate data.'''
     try:
         import MySQLdb as mysql
         global MySQLdb
         MySQLdb = mysql
     except ImportError, err:
         raise util.Abort(_('python mysql support not available: %s') % err)
 
     if node is None:
         raise util.Abort(_('hook type %s does not pass a changeset id') %
                          hooktype)
     try:
         bz = bugzilla(ui, repo)
         ctx = repo[node]
         ids = bz.find_bug_ids(ctx)
         if ids:
             for id in ids:
                 bz.update(id, ctx)
             bz.notify(ids, util.email(ctx.user()))
     except MySQLdb.MySQLError, err:
         raise util.Abort(_('database error: %s') % err[1])
 

hgext/notify.py

@@ -1,316 +1,316 b''
 # notify.py - email notifications for mercurial
 #
 # Copyright 2006 Vadim Gelfer <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 '''hooks for sending email notifications at commit/push time
 
 Subscriptions can be managed through a hgrc file. Default mode is to
 print messages to stdout, for testing and configuring.
 
 To use, configure the notify extension and enable it in hgrc like
 this::
 
   [extensions]
-  hgext.notify =
+  notify =
 
   [hooks]
   # one email for each incoming changeset
   incoming.notify = python:hgext.notify.hook
   # batch emails when many changesets incoming at one time
   changegroup.notify = python:hgext.notify.hook
 
   [notify]
   # config items go here
 
 Required configuration items::
 
   config = /path/to/file # file containing subscriptions
 
 Optional configuration items::
 
   test = True            # print messages to stdout for testing
   strip = 3              # number of slashes to strip for url paths
   domain = example.com   # domain to use if committer missing domain
   style = ...            # style file to use when formatting email
   template = ...         # template to use when formatting email
   incoming = ...         # template to use when run as incoming hook
   changegroup = ...      # template when run as changegroup hook
   maxdiff = 300          # max lines of diffs to include (0=none, -1=all)
   maxsubject = 67        # truncate subject line longer than this
   diffstat = True        # add a diffstat before the diff content
   sources = serve        # notify if source of incoming changes in this list
                          # (serve == ssh or http, push, pull, bundle)
   merge = False          # send notification for merges (default True)
   [email]
   from = [e-mail]   # email address to send as if none given
   [web]
   baseurl = http://hgserver/... # root of hg web site for browsing commits
 
 The notify config file has same format as a regular hgrc file. It has
 two sections so you can express subscriptions in whatever way is
 handier for you.
 
 ::
 
   [usersubs]
   # key is subscriber email, value is ","-separated list of glob patterns
   user@host = pattern
 
   [reposubs]
   # key is glob pattern, value is ","-separated list of subscriber emails
   pattern = user@host
 
 Glob patterns are matched against path to repository root.
 
 If you like, you can put notify config file in repository that users
 can push changes to, they can manage their own subscriptions.
 '''
 
 from mercurial.i18n import _
 from mercurial import patch, cmdutil, templater, util, mail
 import email.Parser, email.Errors, fnmatch, socket, time
 
 # template for single changeset can include email headers.
 single_template = '''
 Subject: changeset in {webroot}: {desc|firstline|strip}
 From: {author}
 
 changeset {node|short} in {root}
 details: {baseurl}{webroot}?cmd=changeset;node={node|short}
 description:
 \t{desc|tabindent|strip}
 '''.lstrip()
 
 # template for multiple changesets should not contain email headers,
 # because only first set of headers will be used and result will look
 # strange.
 multiple_template = '''
 changeset {node|short} in {root}
 details: {baseurl}{webroot}?cmd=changeset;node={node|short}
 summary: {desc|firstline}
 '''
 
 deftemplates = {
     'changegroup': multiple_template,
 }
 
 class notifier(object):
     '''email notification class.'''
 
     def __init__(self, ui, repo, hooktype):
         self.ui = ui
         cfg = self.ui.config('notify', 'config')
         if cfg:
             self.ui.readconfig(cfg, sections=['usersubs', 'reposubs'])
         self.repo = repo
         self.stripcount = int(self.ui.config('notify', 'strip', 0))
         self.root = self.strip(self.repo.root)
         self.domain = self.ui.config('notify', 'domain')
         self.test = self.ui.configbool('notify', 'test', True)
         self.charsets = mail._charsets(self.ui)
         self.subs = self.subscribers()
         self.merge = self.ui.configbool('notify', 'merge', True)
 
         mapfile = self.ui.config('notify', 'style')
         template = (self.ui.config('notify', hooktype) or
                     self.ui.config('notify', 'template'))
         self.t = cmdutil.changeset_templater(self.ui, self.repo,
                                              False, None, mapfile, False)
         if not mapfile and not template:
             template = deftemplates.get(hooktype) or single_template
         if template:
             template = templater.parsestring(template, quoted=False)
             self.t.use_template(template)
 
     def strip(self, path):
         '''strip leading slashes from local path, turn into web-safe path.'''
 
         path = util.pconvert(path)
         count = self.stripcount
         while count > 0:
             c = path.find('/')
             if c == -1:
                 break
             path = path[c+1:]
             count -= 1
         return path
 
     def fixmail(self, addr):
         '''try to clean up email addresses.'''
 
         addr = util.email(addr.strip())
         if self.domain:
             a = addr.find('@localhost')
             if a != -1:
                 addr = addr[:a]
             if '@' not in addr:
                 return addr + '@' + self.domain
         return addr
 
     def subscribers(self):
         '''return list of email addresses of subscribers to this repo.'''
         subs = set()
         for user, pats in self.ui.configitems('usersubs'):
             for pat in pats.split(','):
                 if fnmatch.fnmatch(self.repo.root, pat.strip()):
                     subs.add(self.fixmail(user))
         for pat, users in self.ui.configitems('reposubs'):
             if fnmatch.fnmatch(self.repo.root, pat):
                 for user in users.split(','):
                     subs.add(self.fixmail(user))
         return [mail.addressencode(self.ui, s, self.charsets, self.test)
                 for s in sorted(subs)]
 
     def url(self, path=None):
         return self.ui.config('web', 'baseurl') + (path or self.root)
 
     def node(self, ctx, **props):
         '''format one changeset, unless it is a suppressed merge.'''
         if not self.merge and len(ctx.parents()) > 1:
             return False
         self.t.show(ctx, changes=ctx.changeset(),
                     baseurl=self.ui.config('web', 'baseurl'),
                     root=self.repo.root, webroot=self.root, **props)
         return True
 
     def skipsource(self, source):
         '''true if incoming changes from this source should be skipped.'''
         ok_sources = self.ui.config('notify', 'sources', 'serve').split()
         return source not in ok_sources
 
     def send(self, ctx, count, data):
         '''send message.'''
 
         p = email.Parser.Parser()
         try:
             msg = p.parsestr(data)
         except email.Errors.MessageParseError, inst:
             raise util.Abort(inst)
 
         # store sender and subject
         sender, subject = msg['From'], msg['Subject']
         del msg['From'], msg['Subject']
 
         if not msg.is_multipart():
             # create fresh mime message from scratch
             # (multipart templates must take care of this themselves)
             headers = msg.items()
             payload = msg.get_payload()
             # for notification prefer readability over data precision
             msg = mail.mimeencode(self.ui, payload, self.charsets, self.test)
             # reinstate custom headers
             for k, v in headers:
                 msg[k] = v
 
         msg['Date'] = util.datestr(format="%a, %d %b %Y %H:%M:%S %1%2")
 
         # try to make subject line exist and be useful
         if not subject:
             if count > 1:
                 subject = _('%s: %d new changesets') % (self.root, count)
             else:
                 s = ctx.description().lstrip().split('\n', 1)[0].rstrip()
                 subject = '%s: %s' % (self.root, s)
         maxsubject = int(self.ui.config('notify', 'maxsubject', 67))
         if maxsubject and len(subject) > maxsubject:
             subject = subject[:maxsubject-3] + '...'
         msg['Subject'] = mail.headencode(self.ui, subject,
                                          self.charsets, self.test)
 
         # try to make message have proper sender
         if not sender:
             sender = self.ui.config('email', 'from') or self.ui.username()
         if '@' not in sender or '@localhost' in sender:
             sender = self.fixmail(sender)
         msg['From'] = mail.addressencode(self.ui, sender,
                                          self.charsets, self.test)
 
         msg['X-Hg-Notification'] = 'changeset %s' % ctx
         if not msg['Message-Id']:
             msg['Message-Id'] = ('<hg.%s.%s.%s@%s>' %
                                  (ctx, int(time.time()),
                                   hash(self.repo.root), socket.getfqdn()))
         msg['To'] = ', '.join(self.subs)
 
         msgtext = msg.as_string()
         if self.test:
             self.ui.write(msgtext)
             if not msgtext.endswith('\n'):
                 self.ui.write('\n')
         else:
             self.ui.status(_('notify: sending %d subscribers %d changes\n') %
                            (len(self.subs), count))
             mail.sendmail(self.ui, util.email(msg['From']),
                           self.subs, msgtext)
 
     def diff(self, ctx, ref=None):
 
         maxdiff = int(self.ui.config('notify', 'maxdiff', 300))
         prev = ctx.parents()[0].node()
         ref = ref and ref.node() or ctx.node()
         chunks = patch.diff(self.repo, prev, ref, opts=patch.diffopts(self.ui))
         difflines = ''.join(chunks).splitlines()
 
         if self.ui.configbool('notify', 'diffstat', True):
             s = patch.diffstat(difflines)
             # s may be nil, don't include the header if it is
             if s:
                 self.ui.write('\ndiffstat:\n\n%s' % s)
 
         if maxdiff == 0:
             return
         elif maxdiff > 0 and len(difflines) > maxdiff:
             msg = _('\ndiffs (truncated from %d to %d lines):\n\n')
             self.ui.write(msg % (len(difflines), maxdiff))
             difflines = difflines[:maxdiff]
         elif difflines:
             self.ui.write(_('\ndiffs (%d lines):\n\n') % len(difflines))
 
         self.ui.write("\n".join(difflines))
 
 def hook(ui, repo, hooktype, node=None, source=None, **kwargs):
     '''send email notifications to interested subscribers.
 
     if used as changegroup hook, send one email for all changesets in
     changegroup. else send one email per changeset.'''
 
     n = notifier(ui, repo, hooktype)
     ctx = repo[node]
 
     if not n.subs:
         ui.debug('notify: no subscribers to repository %s\n' % n.root)
         return
     if n.skipsource(source):
         ui.debug('notify: changes have source "%s" - skipping\n' % source)
         return
 
     ui.pushbuffer()
     data = ''
     count = 0
     if hooktype == 'changegroup':
         start, end = ctx.rev(), len(repo)
         for rev in xrange(start, end):
             if n.node(repo[rev]):
                 count += 1
             else:
                 data += ui.popbuffer()
                 ui.note(_('notify: suppressing notification for merge %d:%s\n') %
                         (rev, repo[rev].hex()[:12]))
                 ui.pushbuffer()
         if count:
             n.diff(ctx, repo['tip'])
     else:
         if not n.node(ctx):
             ui.popbuffer()
             ui.note(_('notify: suppressing notification for merge %d:%s\n') %
                     (ctx.rev(), ctx.hex()[:12]))
             return
         count += 1
         n.diff(ctx)
 
     data += ui.popbuffer()
     if count:
         n.send(ctx, count, data)

hgext/pager.py

@@ -1,69 +1,69 b''
 # pager.py - display output using a pager
 #
 # Copyright 2008 David Soria Parra <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 #
 # To load the extension, add it to your .hgrc file:
 #
 #   [extension]
-#   hgext.pager =
+#   pager =
 #
 # Run "hg help pager" to get info on configuration.
 
 '''browse command output with an external pager
 
 To set the pager that should be used, set the application variable::
 
   [pager]
   pager = LESS='FSRX' less
 
 If no pager is set, the pager extensions uses the environment variable
 $PAGER. If neither pager.pager, nor $PAGER is set, no pager is used.
 
 If you notice "BROKEN PIPE" error messages, you can disable them by
 setting::
 
   [pager]
   quiet = True
 
 You can disable the pager for certain commands by adding them to the
 pager.ignore list::
 
   [pager]
   ignore = version, help, update
 
 You can also enable the pager only for certain commands using
 pager.attend. Below is the default list of commands to be paged::
 
   [pager]
   attend = annotate, cat, diff, export, glog, log, qdiff
 
 Setting pager.attend to an empty value will cause all commands to be
 paged.
 
 If pager.attend is present, pager.ignore will be ignored.
 
 To ignore global commands like "hg version" or "hg help", you have to
 specify them in the global .hgrc
 '''
 
 import sys, os, signal
 from mercurial import dispatch, util, extensions
 
 def uisetup(ui):
     def pagecmd(orig, ui, options, cmd, cmdfunc):
         p = ui.config("pager", "pager", os.environ.get("PAGER"))
         if p and sys.stdout.isatty() and '--debugger' not in sys.argv:
             attend = ui.configlist('pager', 'attend', attended)
             if (cmd in attend or
                 (cmd not in ui.configlist('pager', 'ignore') and not attend)):
                 sys.stderr = sys.stdout = util.popen(p, "wb")
                 if ui.configbool('pager', 'quiet'):
                     signal.signal(signal.SIGPIPE, signal.SIG_DFL)
         return orig(ui, options, cmd, cmdfunc)
 
     extensions.wrapfunction(dispatch, '_runcommand', pagecmd)
 
 attended = ['annotate', 'cat', 'diff', 'export', 'glog', 'log', 'qdiff']

hgext/win32text.py

@@ -1,158 +1,158 b''
 # win32text.py - LF <-> CRLF/CR translation utilities for Windows/Mac users
 #
 #  Copyright 2005, 2007-2009 Matt Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2, incorporated herein by reference.
 
 '''perform automatic newline conversion
 
 To perform automatic newline conversion, use::
 
   [extensions]
-  hgext.win32text =
+  win32text =
   [encode]
   ** = cleverencode:
   # or ** = macencode:
 
   [decode]
   ** = cleverdecode:
   # or ** = macdecode:
 
 If not doing conversion, to make sure you do not commit CRLF/CR by accident::
 
   [hooks]
   pretxncommit.crlf = python:hgext.win32text.forbidcrlf
   # or pretxncommit.cr = python:hgext.win32text.forbidcr
 
 To do the same check on a server to prevent CRLF/CR from being
 pushed or pulled::
 
   [hooks]
   pretxnchangegroup.crlf = python:hgext.win32text.forbidcrlf
   # or pretxnchangegroup.cr = python:hgext.win32text.forbidcr
 '''
 
 from mercurial.i18n import _
 from mercurial.node import short
 from mercurial import util
 import re
 
 # regexp for single LF without CR preceding.
 re_single_lf = re.compile('(^|[^\r])\n', re.MULTILINE)
 
 newlinestr = {'\r\n': 'CRLF', '\r': 'CR'}
 filterstr = {'\r\n': 'clever', '\r': 'mac'}
 
 def checknewline(s, newline, ui=None, repo=None, filename=None):
     # warn if already has 'newline' in repository.
     # it might cause unexpected eol conversion.
     # see issue 302:
     #   http://mercurial.selenic.com/bts/issue302
     if newline in s and ui and filename and repo:
         ui.warn(_('WARNING: %s already has %s line endings\n'
                   'and does not need EOL conversion by the win32text plugin.\n'
                   'Before your next commit, please reconsider your '
                   'encode/decode settings in \nMercurial.ini or %s.\n') %
                 (filename, newlinestr[newline], repo.join('hgrc')))
 
 def dumbdecode(s, cmd, **kwargs):
     checknewline(s, '\r\n', **kwargs)
     # replace single LF to CRLF
     return re_single_lf.sub('\\1\r\n', s)
 
 def dumbencode(s, cmd):
     return s.replace('\r\n', '\n')
 
 def macdumbdecode(s, cmd, **kwargs):
     checknewline(s, '\r', **kwargs)
     return s.replace('\n', '\r')
 
 def macdumbencode(s, cmd):
     return s.replace('\r', '\n')
 
 def cleverdecode(s, cmd, **kwargs):
     if not util.binary(s):
         return dumbdecode(s, cmd, **kwargs)
     return s
 
 def cleverencode(s, cmd):
     if not util.binary(s):
         return dumbencode(s, cmd)
     return s
 
 def macdecode(s, cmd, **kwargs):
     if not util.binary(s):
         return macdumbdecode(s, cmd, **kwargs)
     return s
 
 def macencode(s, cmd):
     if not util.binary(s):
         return macdumbencode(s, cmd)
     return s
 
 _filters = {
     'dumbdecode:': dumbdecode,
     'dumbencode:': dumbencode,
     'cleverdecode:': cleverdecode,
     'cleverencode:': cleverencode,
     'macdumbdecode:': macdumbdecode,
     'macdumbencode:': macdumbencode,
     'macdecode:': macdecode,
     'macencode:': macencode,
     }
 
 def forbidnewline(ui, repo, hooktype, node, newline, **kwargs):
     halt = False
     seen = set()
     # we try to walk changesets in reverse order from newest to
     # oldest, so that if we see a file multiple times, we take the
     # newest version as canonical. this prevents us from blocking a
     # changegroup that contains an unacceptable commit followed later
     # by a commit that fixes the problem.
     tip = repo['tip']
     for rev in xrange(len(repo)-1, repo[node].rev()-1, -1):
         c = repo[rev]
         for f in c.files():
             if f in seen or f not in tip or f not in c:
                 continue
             seen.add(f)
             data = c[f].data()
             if not util.binary(data) and newline in data:
                 if not halt:
                     ui.warn(_('Attempt to commit or push text file(s) '
                               'using %s line endings\n') %
                               newlinestr[newline])
                 ui.warn(_('in %s: %s\n') % (short(c.node()), f))
                 halt = True
     if halt and hooktype == 'pretxnchangegroup':
         crlf = newlinestr[newline].lower()
         filter = filterstr[newline]
         ui.warn(_('\nTo prevent this mistake in your local repository,\n'
                   'add to Mercurial.ini or .hg/hgrc:\n'
                   '\n'
                   '[hooks]\n'
                   'pretxncommit.%s = python:hgext.win32text.forbid%s\n'
                   '\n'
                   'and also consider adding:\n'
                   '\n'
                   '[extensions]\n'
                   'hgext.win32text =\n'
                   '[encode]\n'
                   '** = %sencode:\n'
                   '[decode]\n'
                   '** = %sdecode:\n') % (crlf, crlf, filter, filter))
     return halt
 
 def forbidcrlf(ui, repo, hooktype, node, **kwargs):
     return forbidnewline(ui, repo, hooktype, node, '\r\n', **kwargs)
 
 def forbidcr(ui, repo, hooktype, node, **kwargs):
     return forbidnewline(ui, repo, hooktype, node, '\r', **kwargs)
 
 def reposetup(ui, repo):
     if not repo.local():
         return
     for name, fn in _filters.iteritems():
         repo.adddatafilter(name, fn)
 

tests/test-notify.out

@@ -1,219 +1,219 b''
 notify extension - hooks for sending email notifications at commit/push time
 
 Subscriptions can be managed through a hgrc file. Default mode is to print
 messages to stdout, for testing and configuring.
 
 To use, configure the notify extension and enable it in hgrc like this:
 
   [extensions]
-  hgext.notify =
+  notify =
 
   [hooks]
   # one email for each incoming changeset
   incoming.notify = python:hgext.notify.hook
   # batch emails when many changesets incoming at one time
   changegroup.notify = python:hgext.notify.hook
 
   [notify]
   # config items go here
 
 Required configuration items:
 
   config = /path/to/file # file containing subscriptions
 
 Optional configuration items:
 
   test = True            # print messages to stdout for testing
   strip = 3              # number of slashes to strip for url paths
   domain = example.com   # domain to use if committer missing domain
   style = ...            # style file to use when formatting email
   template = ...         # template to use when formatting email
   incoming = ...         # template to use when run as incoming hook
   changegroup = ...      # template when run as changegroup hook
   maxdiff = 300          # max lines of diffs to include (0=none, -1=all)
   maxsubject = 67        # truncate subject line longer than this
   diffstat = True        # add a diffstat before the diff content
   sources = serve        # notify if source of incoming changes in this list
                          # (serve == ssh or http, push, pull, bundle)
   merge = False          # send notification for merges (default True)
   [email]
   from = [e-mail]   # email address to send as if none given
   [web]
   baseurl = http://hgserver/... # root of hg web site for browsing commits
 
 The notify config file has same format as a regular hgrc file. It has two
 sections so you can express subscriptions in whatever way is handier for you.
 
   [usersubs]
   # key is subscriber email, value is ","-separated list of glob patterns
   user@host = pattern
 
   [reposubs]
   # key is glob pattern, value is ","-separated list of subscriber emails
   pattern = user@host
 
 Glob patterns are matched against path to repository root.
 
 If you like, you can put notify config file in repository that users can push
 changes to, they can manage their own subscriptions.
 
 no commands defined
 % commit
 adding a
 % clone
 updating to branch default
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 % commit
 % pull (minimal config)
 pulling from ../a
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 Content-Type: text/plain; charset="us-ascii"
 MIME-Version: 1.0
 Content-Transfer-Encoding: 7bit
 Date:
 Subject: changeset in test-notify/b: b
 From: test
 X-Hg-Notification: changeset 0647d048b600
 Message-Id:
 To: baz, foo@bar
 
 changeset 0647d048b600 in test-notify/b
 details: test-notify/b?cmd=changeset;node=0647d048b600
 description: b
 
 diffs (6 lines):
 
 diff -r cb9a9f314b8b -r 0647d048b600 a
 --- a/a	Thu Jan 01 00:00:00 1970 +0000
 +++ b/a	Thu Jan 01 00:00:01 1970 +0000
 @@ -1,1 +1,2 @@
  a
 +a
 (run 'hg update' to get a working copy)
 % fail for config file is missing
 rolling back last transaction
 pull failed
 % pull
 rolling back last transaction
 pulling from ../a
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 Content-Type: text/plain; charset="us-ascii"
 MIME-Version: 1.0
 Content-Transfer-Encoding: 7bit
 X-Test: foo
 Date:
 Subject: b
 From: [e-mail]
 X-Hg-Notification: changeset 0647d048b600
 Message-Id:
 To: [e-mail], foo@bar
 
 changeset 0647d048b600
 description:
 	b
 diffs (6 lines):
 
 diff -r cb9a9f314b8b -r 0647d048b600 a
 --- a/a	Thu Jan 01 00:00:00 1970 +0000
 +++ b/a	Thu Jan 01 00:00:01 1970 +0000
 @@ -1,1 +1,2 @@
  a
 +a
 (run 'hg update' to get a working copy)
 % pull
 rolling back last transaction
 pulling from ../a
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 Content-Type: text/plain; charset="us-ascii"
 MIME-Version: 1.0
 Content-Transfer-Encoding: 7bit
 X-Test: foo
 Date:
 Subject: b
 From: [e-mail]
 X-Hg-Notification: changeset 0647d048b600
 Message-Id:
 To: [e-mail], foo@bar
 
 changeset 0647d048b600
 description:
 	b
 diffstat:
 
  a |  1 +
  1 files changed, 1 insertions(+), 0 deletions(-)
 
 diffs (6 lines):
 
 diff -r cb9a9f314b8b -r 0647d048b600 a
 --- a/a	Thu Jan 01 00:00:00 1970 +0000
 +++ b/a	Thu Jan 01 00:00:01 1970 +0000
 @@ -1,1 +1,2 @@
  a
 +a
 (run 'hg update' to get a working copy)
 % test merge
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 created new head
 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 (branch merge, don't forget to commit)
 pulling from ../a
 searching for changes
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 0 changes to 0 files
 Content-Type: text/plain; charset="us-ascii"
 MIME-Version: 1.0
 Content-Transfer-Encoding: 7bit
 X-Test: foo
 Date:
 Subject: adda2
 From: [e-mail]
 X-Hg-Notification: changeset 0a184ce6067f
 Message-Id:
 To: [e-mail], foo@bar
 
 changeset 0a184ce6067f
 description:
 	adda2
 diffstat:
 
  a |  1 +
  1 files changed, 1 insertions(+), 0 deletions(-)
 
 diffs (6 lines):
 
 diff -r cb9a9f314b8b -r 0a184ce6067f a
 --- a/a	Thu Jan 01 00:00:00 1970 +0000
 +++ b/a	Thu Jan 01 00:00:02 1970 +0000
 @@ -1,1 +1,2 @@
  a
 +a
 Content-Type: text/plain; charset="us-ascii"
 MIME-Version: 1.0
 Content-Transfer-Encoding: 7bit
 X-Test: foo
 Date:
 Subject: merge
 From: [e-mail]
 X-Hg-Notification: changeset 22c88b85aa27
 Message-Id:
 To: [e-mail], foo@bar
 
 changeset 22c88b85aa27
 description:
 	merge
 (run 'hg update' to get a working copy)