keyword: wrap functions only once at loading keyword extension

Before this patch, some functions are wrapped in reposetup(), but this
causes redundant nested wrapping, if two ore more repositories enable
keyword extension (e.g. hgweb serves multiple repositories).

Now, there is no need to define these wrapper functions in
reposetup(), because previous patches made them not directly refer to
kwtemplater instanciated in reposetup().

This patch factors these wrapper functions out from reposetup(), and
uses them to wrap functions only at once at loading keyword extension.

hgext/keyword.py

@@ -577,96 +577,8 b' def shrink(ui, repo, *pats, **opts):'
     # 3rd argument sets expansion to False
     _kwfwrite(ui, repo, False, *pats, **opts)
 
-
-def uisetup(ui):
-    ''' Monkeypatches dispatch._parse to retrieve user command.'''
-
-    def kwdispatch_parse(orig, ui, args):
-        '''Monkeypatch dispatch._parse to obtain running hg command.'''
-        cmd, func, args, options, cmdoptions = orig(ui, args)
-        kwtools['hgcmd'] = cmd
-        return cmd, func, args, options, cmdoptions
-
-    extensions.wrapfunction(dispatch, '_parse', kwdispatch_parse)
-
-def reposetup(ui, repo):
-    '''Sets up repo as kwrepo for keyword substitution.
-    Overrides file method to return kwfilelog instead of filelog
-    if file matches user configuration.
-    Wraps commit to overwrite configured files with updated
-    keyword substitutions.
-    Monkeypatches patch and webcommands.'''
-
-    try:
-        if (not repo.local() or kwtools['hgcmd'] in nokwcommands.split()
-            or '.hg' in util.splitpath(repo.root)
-            or repo._url.startswith('bundle:')):
-            return
-    except AttributeError:
-        pass
-
-    inc, exc = [], ['.hg*']
-    for pat, opt in ui.configitems('keyword'):
-        if opt != 'ignore':
-            inc.append(pat)
-        else:
-            exc.append(pat)
-    if not inc:
-        return
-
-    kwt = kwtemplater(ui, repo, inc, exc)
-
-    class kwrepo(repo.__class__):
-        def file(self, f):
-            if f[0] == '/':
-                f = f[1:]
-            return kwfilelog(self.svfs, kwt, f)
+# monkeypatches
 
-        def wread(self, filename):
-            data = super(kwrepo, self).wread(filename)
-            return kwt.wread(filename, data)
-
-        def commit(self, *args, **opts):
-            # use custom commitctx for user commands
-            # other extensions can still wrap repo.commitctx directly
-            self.commitctx = self.kwcommitctx
-            try:
-                return super(kwrepo, self).commit(*args, **opts)
-            finally:
-                del self.commitctx
-
-        def kwcommitctx(self, ctx, error=False):
-            n = super(kwrepo, self).commitctx(ctx, error)
-            # no lock needed, only called from repo.commit() which already locks
-            if not kwt.postcommit:
-                restrict = kwt.restrict
-                kwt.restrict = True
-                kwt.overwrite(self[n], sorted(ctx.added() + ctx.modified()),
-                              False, True)
-                kwt.restrict = restrict
-            return n
-
-        def rollback(self, dryrun=False, force=False):
-            with self.wlock():
-                origrestrict = kwt.restrict
-                try:
-                    if not dryrun:
-                        changed = self['.'].files()
-                    ret = super(kwrepo, self).rollback(dryrun, force)
-                    if not dryrun:
-                        ctx = self['.']
-                        modified, added = _preselect(ctx.status(), changed)
-                        kwt.restrict = False
-                        kwt.overwrite(ctx, modified, True, True)
-                        kwt.overwrite(ctx, added, True, False)
-                    return ret
-                finally:
-                    kwt.restrict = origrestrict
-
-    repo.__class__ = kwrepo
-    repo._keywordkwt = kwt
-
-    # monkeypatches
     def kwpatchfile_init(orig, self, ui, gp, backend, store, eolmode=None):
         '''Monkeypatch/wrap patch.patchfile.__init__ to avoid
         rejects or conflicts due to expanded keywords in working dir.'''
@@ -788,6 +700,22 b' def reposetup(ui, repo):'
             return self._filelog.cmp(self._filenode, fctx.data())
         return True
 
+def uisetup(ui):
+    ''' Monkeypatches dispatch._parse to retrieve user command.
+    Overrides file method to return kwfilelog instead of filelog
+    if file matches user configuration.
+    Wraps commit to overwrite configured files with updated
+    keyword substitutions.
+    Monkeypatches patch and webcommands.'''
+
+    def kwdispatch_parse(orig, ui, args):
+        '''Monkeypatch dispatch._parse to obtain running hg command.'''
+        cmd, func, args, options, cmdoptions = orig(ui, args)
+        kwtools['hgcmd'] = cmd
+        return cmd, func, args, options, cmdoptions
+
+    extensions.wrapfunction(dispatch, '_parse', kwdispatch_parse)
+
     extensions.wrapfunction(context.filectx, 'cmp', kwfilectx_cmp)
     extensions.wrapfunction(patch.patchfile, '__init__', kwpatchfile_init)
     extensions.wrapfunction(patch, 'diff', kwdiff)
@@ -796,3 +724,75 b' def reposetup(ui, repo):'
     extensions.wrapfunction(cmdutil, 'dorecord', kw_dorecord)
     for c in nokwwebcommands.split():
         extensions.wrapfunction(webcommands, c, kwweb_skip)
+
+def reposetup(ui, repo):
+    '''Sets up repo as kwrepo for keyword substitution.'''
+
+    try:
+        if (not repo.local() or kwtools['hgcmd'] in nokwcommands.split()
+            or '.hg' in util.splitpath(repo.root)
+            or repo._url.startswith('bundle:')):
+            return
+    except AttributeError:
+        pass
+
+    inc, exc = [], ['.hg*']
+    for pat, opt in ui.configitems('keyword'):
+        if opt != 'ignore':
+            inc.append(pat)
+        else:
+            exc.append(pat)
+    if not inc:
+        return
+
+    kwt = kwtemplater(ui, repo, inc, exc)
+
+    class kwrepo(repo.__class__):
+        def file(self, f):
+            if f[0] == '/':
+                f = f[1:]
+            return kwfilelog(self.svfs, kwt, f)
+
+        def wread(self, filename):
+            data = super(kwrepo, self).wread(filename)
+            return kwt.wread(filename, data)
+
+        def commit(self, *args, **opts):
+            # use custom commitctx for user commands
+            # other extensions can still wrap repo.commitctx directly
+            self.commitctx = self.kwcommitctx
+            try:
+                return super(kwrepo, self).commit(*args, **opts)
+            finally:
+                del self.commitctx
+
+        def kwcommitctx(self, ctx, error=False):
+            n = super(kwrepo, self).commitctx(ctx, error)
+            # no lock needed, only called from repo.commit() which already locks
+            if not kwt.postcommit:
+                restrict = kwt.restrict
+                kwt.restrict = True
+                kwt.overwrite(self[n], sorted(ctx.added() + ctx.modified()),
+                              False, True)
+                kwt.restrict = restrict
+            return n
+
+        def rollback(self, dryrun=False, force=False):
+            with self.wlock():
+                origrestrict = kwt.restrict
+                try:
+                    if not dryrun:
+                        changed = self['.'].files()
+                    ret = super(kwrepo, self).rollback(dryrun, force)
+                    if not dryrun:
+                        ctx = self['.']
+                        modified, added = _preselect(ctx.status(), changed)
+                        kwt.restrict = False
+                        kwt.overwrite(ctx, modified, True, True)
+                        kwt.overwrite(ctx, added, True, False)
+                    return ret
+                finally:
+                    kwt.restrict = origrestrict
+
+    repo.__class__ = kwrepo
+    repo._keywordkwt = kwt