def extsetup(ui):
# Modelled after dispatch._dispatch. We have to re-parse the
# arguments to find the path to the repository since there is no
# repo object yet.
# extsetup is called after all the extension are loaded, and can be useful in case one extension optionally depends on another extension. Signature:
# https://www.mercurial-scm.org/wiki/WritingExtensions#Setup_Callbacks
#moved to uisetup
#args = sys.argv[1:]
#rpath = dispatch._earlygetopt(["-R", "--repository", "--repo"], args)
#readprojrc(ui, rpath)
extensions.loadall(ui)
if hasattr(dispatch, "_loaded"):
for name, module in extensions.extensions():
if name in dispatch._loaded:
continue
cmdtable = getattr(module, 'cmdtable', {})
overrides = [cmd for cmd in cmdtable if cmd in commands.table]
if overrides:
ui.warn(_("extension '%s' overrides commands: %s\n")
% (name, " ".join(overrides)))
commands.table.update(cmdtable)
dispatch._loaded.add(name)
else:
#dispatch._loaded was removed in the latest mercurial
faux_loaded = set()
for name in extensions._extensions:
faux_loaded.add(name)
for name, module in extensions.extensions():
if name in faux_loaded:
continue
cmdtable = getattr(module, 'cmdtable', {})
overrides = [cmd for cmd in cmdtable if cmd in commands.table]
if overrides:
ui.warn(_("extension '%s' overrides commands: %s\n")
% (name, " ".join(overrides)))
commands.table.update(cmdtable)
faux_loaded.add(name)
extensions.wrapfunction(hg, 'clone', clone)
extensions.wrapfunction(hg, 'incoming', incoming)
extensions.wrapfunction(exchange, 'pull', pull)
pushkey.register('projrc', pushprojrc, listprojrc)
def add(parent, ui, repo, files):
haslf = "largefiles" in repo.extensions()
haskbf = "kbfiles" in repo.extensions()
if haslf or haskbf:
result = lfprompt.promptForLfiles(parent, ui, repo, files, haskbf)
if not result:
return False
files, lfiles = result
for name, module in extensions.extensions():
if name == "largefiles":
override_add = module.overrides.override_add
if files:
override_add(commands.add, ui, repo, *files)
if lfiles:
override_add(commands.add, ui, repo, large=True, *lfiles)
return True
if name == "kbfiles":
override_add = module.bfsetup.override_add
if files:
override_add(commands.add, ui, repo, *files)
if lfiles:
override_add(commands.add, ui, repo, bf=True, *lfiles)
return True
commands.add(ui, repo, *files)
return True
def _uisetup(ui):
localrepo.featuresetupfuncs.add(featuresetup)
hg.wirepeersetupfuncs.append(proto.wirereposetup)
cmdutil.outgoinghooks.add(b'largefiles', overrides.outgoinghook)
cmdutil.summaryremotehooks.add(b'largefiles', overrides.summaryremotehook)
# create the new wireproto commands ...
wireprotov1server.wireprotocommand(b'putlfile', b'sha',
permission=b'push')(proto.putlfile)
wireprotov1server.wireprotocommand(b'getlfile', b'sha',
permission=b'pull')(proto.getlfile)
wireprotov1server.wireprotocommand(b'statlfile',
b'sha',
permission=b'pull')(proto.statlfile)
wireprotov1server.wireprotocommand(b'lheads', b'', permission=b'pull')(
wireprotov1server.heads)
extensions.wrapfunction(wireprotov1server.commands[b'heads'], b'func',
proto.heads)
# TODO also wrap wireproto.commandsv2 once heads is implemented there.
# override some extensions' stuff as well
for name, module in extensions.extensions():
if name == b'rebase':
# TODO: teach exthelper to handle this
extensions.wrapfunction(module, b'rebase',
overrides.overriderebasecmd)
def get_error_text(self):
if self.__error_text__ == None:
text = '{{{\n#!python\n' # Wrap in Bitbucket wiki preformat markers
text += _('** Please report this bug to '
'http://bitbucket.org/tortoisehg/stable/issues\n')
text += '** Mercurial version (%s). TortoiseHg version (%s)\n' % (
hglib.hgversion, version.version())
text += '** Command: %s\n' % (self.opts['cmd'])
text += '** CWD: %s\n' % os.getcwd()
extlist = [x[0] for x in extensions.extensions()]
text += '** Extensions loaded: %s\n' % ', '.join(extlist)
text += '** Python %s\n' % sys.version.replace('\n', '')
if os.name == 'nt':
text += '** sys.getwindowsversion(): %s\n' % str(sys.getwindowsversion())
arch = 'unknown (failed to import win32api)'
try:
import win32api
arch = 'unknown'
archval = win32api.GetNativeSystemInfo()[0]
if archval == 9:
arch = 'x64'
elif archval == 0:
arch = 'x86'
except (ImportError, AttributeError):
pass
text += '** Processor architecture: %s\n' % arch
text += self.opts['error']
text += '\n}}}'
self.__error_text__ = text
return self.__error_text__
def _uisetup(ui):
localrepo.featuresetupfuncs.add(featuresetup)
hg.wirepeersetupfuncs.append(proto.wirereposetup)
cmdutil.outgoinghooks.add('largefiles', overrides.outgoinghook)
cmdutil.summaryremotehooks.add('largefiles', overrides.summaryremotehook)
# create the new wireproto commands ...
wireprotov1server.wireprotocommand('putlfile', 'sha',
permission='push')(proto.putlfile)
wireprotov1server.wireprotocommand('getlfile', 'sha',
permission='pull')(proto.getlfile)
wireprotov1server.wireprotocommand('statlfile', 'sha',
permission='pull')(proto.statlfile)
wireprotov1server.wireprotocommand('lheads', '', permission='pull')(
wireprotov1server.heads)
extensions.wrapfunction(wireprotov1server.commands['heads'], 'func',
proto.heads)
# TODO also wrap wireproto.commandsv2 once heads is implemented there.
# can't do this in reposetup because it needs to have happened before
# wirerepo.__init__ is called
proto.ssholdcallstream = sshpeer.sshv1peer._callstream
proto.httpoldcallstream = httppeer.httppeer._callstream
sshpeer.sshv1peer._callstream = proto.sshrepocallstream
httppeer.httppeer._callstream = proto.httprepocallstream
# override some extensions' stuff as well
for name, module in extensions.extensions():
if name == 'rebase':
# TODO: teach exthelper to handle this
extensions.wrapfunction(module, 'rebase', overrides.overriderebase)
def _exts(self):
lclexts = []
allexts = [n for n, m in extensions.extensions()]
for name, path in self.ui.configitems('extensions'):
if name.startswith('hgext.'):
name = name[6:]
if name in allexts:
lclexts.append(name)
return lclexts
def _exts(self):
lclexts = []
allexts = [n for n,m in extensions.extensions()]
for name, path in self.ui.configitems('extensions'):
if name.startswith('hgext.'):
name = name[6:]
if name in allexts:
lclexts.append(name)
return lclexts
def load_guestrepo():
# load guestrepo module and check that current repo is a guestrepo-managed master repo
for ext, mod in extensions.extensions():
if ext == 'guestrepo':
guestrepo = mod.guestrepo
break
else:
raise util.Abort(
'Cannot find the guestrepo extension! Check your configuration')
return guestrepo
def addlf(parent, ui, repo, files):
for name, module in extensions.extensions():
if name == "largefiles":
override_add = module.overrides.override_add
override_add(commands.add, ui, repo, large=True, *files)
return True
if name == "kbfiles":
override_add = module.bfsetup.override_add
override_add(commands.add, ui, repo, bf=True, *files)
return True
return False
def _resolverevlogstorevfsoptions(orig, ui, requirements, features):
opts = orig(ui, requirements, features)
for name, module in extensions.extensions(ui):
if module is sys.modules[__name__]:
if revlog.REVIDX_EXTSTORED in opts[b'flagprocessors']:
msg = (
_(b"cannot register multiple processors on flag '%#x'.") %
revlog.REVIDX_EXTSTORED)
raise error.Abort(msg)
opts[b'flagprocessors'][revlog.REVIDX_EXTSTORED] = lfsprocessor
break
return opts
def uisetup(ui):
# Disable auto-status for some commands which assume that all
# files in the result are under Mercurial's control
entry = extensions.wrapcommand(commands.table, 'add', override_add)
addopt = [('', 'bf', None, _('add as bfile')),
('', 'bfsize', '', _('add all files above this size (in megabytes) as bfiles (default: 10)'))]
entry[1].extend(addopt)
entry = extensions.wrapcommand(commands.table, 'addremove', override_addremove)
entry = extensions.wrapcommand(commands.table, 'remove', override_remove)
entry = extensions.wrapcommand(commands.table, 'forget', override_forget)
entry = extensions.wrapcommand(commands.table, 'status', override_status)
entry = extensions.wrapcommand(commands.table, 'verify', override_verify)
verifyopt = [('', 'bf', None, _('verify bfiles')),
('', 'bfa', None, _('verify all revisions of bfiles not just current')),
('', 'bfc', None, _('verify bfile contents not just existence'))]
entry[1].extend(verifyopt)
entry = extensions.wrapcommand(commands.table, 'outgoing', override_outgoing)
outgoingopt = [('', 'bf', None, _('display outgoing bfiles'))]
entry[1].extend(outgoingopt)
entry = extensions.wrapcommand(commands.table, 'summary', override_summary)
summaryopt = [('', 'bf', None, _('display outgoing bfiles'))]
entry[1].extend(summaryopt)
entry = extensions.wrapcommand(commands.table, 'update', override_update)
entry = extensions.wrapcommand(commands.table, 'pull', override_pull)
entry = extensions.wrapfunction(filemerge, 'filemerge', override_filemerge)
entry = extensions.wrapfunction(cmdutil, 'copy', override_copy)
# Backout calls revert so we need to override both the command and the function
entry = extensions.wrapcommand(commands.table, 'revert', override_revert)
entry = extensions.wrapfunction(commands, 'revert', override_revert)
# clone uses hg._update instead of hg.update even though they are the
# same function... so wrap both of them)
extensions.wrapfunction(hg, 'update', hg_update)
extensions.wrapfunction(hg, '_update', hg_update)
extensions.wrapfunction(hg, 'clean', hg_clean)
extensions.wrapfunction(hg, 'merge', hg_merge)
extensions.wrapfunction(archival, 'archive', override_archive)
extensions.wrapfunction(cmdutil, 'bail_if_changed', override_bail_if_changed)
for name, module in extensions.extensions():
if name == 'fetch':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'fetch', override_fetch)
def configstyles(ui):
# extensions may provide more labels and default effects
for name, ext in extensions.extensions():
_styles.update(getattr(ext, 'colortable', {}))
# tortoisehg defines a few labels and default effects
_styles.update(_thgstyles)
# allow the user to override
for status, cfgeffects in ui.configitems('color'):
if '.' not in status:
continue
cfgeffects = ui.configlist('color', status)
good = []
for e in cfgeffects:
if e in TextBufferTags:
good.append(e)
if good:
_styles[status] = ' '.join(good)
def configstyles(ui):
# extensions may provide more labels and default effects
for name, ext in extensions.extensions():
_styles.update(getattr(ext, 'colortable', {}))
# tortoisehg defines a few labels and default effects
_styles.update(_thgstyles)
# allow the user to override
for status, cfgeffects in ui.configitems('color'):
if '.' not in status:
continue
cfgeffects = ui.configlist('color', status)
_styles[status] = ' '.join(cfgeffects)
for status, cfgeffects in ui.configitems('thg-color'):
if '.' not in status:
continue
cfgeffects = ui.configlist('thg-color', status)
_styles[status] = ' '.join(cfgeffects)
def configstyles(ui):
# extensions may provide more labels and default effects
for name, ext in extensions.extensions():
_styles.update(getattr(ext, 'colortable', {}))
# tortoisehg defines a few labels and default effects
_styles.update(_thgstyles)
# allow the user to override
for status, cfgeffects in ui.configitems('color'):
if '.' not in status:
continue
cfgeffects = ui.configlist('color', status)
_styles[status] = ' '.join(cfgeffects)
for status, cfgeffects in ui.configitems('thg-color'):
if '.' not in status:
continue
cfgeffects = ui.configlist('thg-color', status)
_styles[status] = ' '.join(cfgeffects)
def _getmtimepaths(ui):
"""get a list of paths that should be checked to detect change
The list will include:
- extensions (will not cover all files for complex extensions)
- mercurial/__version__.py
- python binary
"""
modules = [m for n, m in extensions.extensions(ui)]
try:
from mercurial import __version__
modules.append(__version__)
except ImportError:
pass
files = [sys.executable]
for m in modules:
try:
files.append(inspect.getabsfile(m))
except TypeError:
pass
return sorted(set(files))
def _getmtimepaths(ui):
"""get a list of paths that should be checked to detect change
The list will include:
- extensions (will not cover all files for complex extensions)
- mercurial/__version__.py
- python binary
"""
modules = [m for n, m in extensions.extensions(ui)]
try:
from mercurial import __version__
modules.append(__version__)
except ImportError:
pass
files = [sys.executable]
for m in modules:
try:
files.append(inspect.getabsfile(m))
except TypeError:
pass
return sorted(set(files))
def uisetup(ui):
# Disable auto-status for some commands which assume that all
# files in the result are under Mercurial's control
entry = extensions.wrapcommand(commands.table, "add", overrides.override_add)
addopt = [
("", "large", None, _("add as largefile")),
("", "normal", None, _("add as normal file")),
("", "lfsize", "", _("add all files above this size " "(in megabytes) as largefiles " "(default: 10)")),
]
entry[1].extend(addopt)
entry = extensions.wrapcommand(commands.table, "addremove", overrides.override_addremove)
entry = extensions.wrapcommand(commands.table, "remove", overrides.override_remove)
entry = extensions.wrapcommand(commands.table, "forget", overrides.override_forget)
entry = extensions.wrapcommand(commands.table, "status", overrides.override_status)
entry = extensions.wrapcommand(commands.table, "log", overrides.override_log)
entry = extensions.wrapcommand(commands.table, "rollback", overrides.override_rollback)
entry = extensions.wrapcommand(commands.table, "verify", overrides.override_verify)
verifyopt = [
("", "large", None, _("verify largefiles")),
("", "lfa", None, _("verify all revisions of largefiles not just current")),
("", "lfc", None, _("verify largefile contents not just existence")),
]
entry[1].extend(verifyopt)
entry = extensions.wrapcommand(commands.table, "outgoing", overrides.override_outgoing)
outgoingopt = [("", "large", None, _("display outgoing largefiles"))]
entry[1].extend(outgoingopt)
entry = extensions.wrapcommand(commands.table, "summary", overrides.override_summary)
summaryopt = [("", "large", None, _("display outgoing largefiles"))]
entry[1].extend(summaryopt)
entry = extensions.wrapcommand(commands.table, "update", overrides.override_update)
entry = extensions.wrapcommand(commands.table, "pull", overrides.override_pull)
entry = extensions.wrapfunction(merge, "_checkunknown", overrides.override_checkunknown)
entry = extensions.wrapfunction(merge, "manifestmerge", overrides.override_manifestmerge)
entry = extensions.wrapfunction(filemerge, "filemerge", overrides.override_filemerge)
entry = extensions.wrapfunction(cmdutil, "copy", overrides.override_copy)
# Backout calls revert so we need to override both the command and the
# function
entry = extensions.wrapcommand(commands.table, "revert", overrides.override_revert)
entry = extensions.wrapfunction(commands, "revert", overrides.override_revert)
# clone uses hg._update instead of hg.update even though they are the
# same function... so wrap both of them)
extensions.wrapfunction(hg, "update", overrides.hg_update)
extensions.wrapfunction(hg, "_update", overrides.hg_update)
extensions.wrapfunction(hg, "clean", overrides.hg_clean)
extensions.wrapfunction(hg, "merge", overrides.hg_merge)
extensions.wrapfunction(archival, "archive", overrides.override_archive)
extensions.wrapfunction(cmdutil, "bailifchanged", overrides.override_bailifchanged)
# create the new wireproto commands ...
wireproto.commands["putlfile"] = (proto.putlfile, "sha")
wireproto.commands["getlfile"] = (proto.getlfile, "sha")
wireproto.commands["statlfile"] = (proto.statlfile, "sha")
# ... and wrap some existing ones
wireproto.commands["capabilities"] = (proto.capabilities, "")
wireproto.commands["heads"] = (proto.heads, "")
wireproto.commands["lheads"] = (wireproto.heads, "")
# make putlfile behave the same as push and {get,stat}lfile behave
# the same as pull w.r.t. permissions checks
hgweb_mod.perms["putlfile"] = "push"
hgweb_mod.perms["getlfile"] = "pull"
hgweb_mod.perms["statlfile"] = "pull"
# the hello wireproto command uses wireproto.capabilities, so it won't see
# our largefiles capability unless we replace the actual function as well.
proto.capabilities_orig = wireproto.capabilities
wireproto.capabilities = proto.capabilities
# these let us reject non-largefiles clients and make them display
# our error messages
protocol.webproto.refuseclient = proto.webproto_refuseclient
sshserver.sshserver.refuseclient = proto.sshproto_refuseclient
# can't do this in reposetup because it needs to have happened before
# wirerepo.__init__ is called
proto.ssh_oldcallstream = sshrepo.sshrepository._callstream
proto.http_oldcallstream = httprepo.httprepository._callstream
sshrepo.sshrepository._callstream = proto.sshrepo_callstream
httprepo.httprepository._callstream = proto.httprepo_callstream
# don't die on seeing a repo with the largefiles requirement
localrepo.localrepository.supported |= set(["largefiles"])
# override some extensions' stuff as well
for name, module in extensions.extensions():
if name == "fetch":
extensions.wrapcommand(getattr(module, "cmdtable"), "fetch", overrides.override_fetch)
if name == "purge":
extensions.wrapcommand(getattr(module, "cmdtable"), "purge", overrides.override_purge)
if name == "rebase":
extensions.wrapcommand(getattr(module, "cmdtable"), "rebase", overrides.override_rebase)
if name == "transplant":
extensions.wrapcommand(getattr(module, "cmdtable"), "transplant", overrides.override_transplant)
def get_body(self, vbox):
# MRU lists
self.recentsrc = self.settings.mrul('src_paths')
self.recentdest = self.settings.mrul('dest_paths')
def createcombo(path, label, title, bundle=False):
# comboentry
model = gtk.ListStore(str)
combo = gtk.ComboBoxEntry(model, 0)
combo.set_size_request(280, -1)
combo.size_request()
entry = combo.get_child()
entry.set_text(path)
entry.set_position(-1)
entry.connect('activate',
lambda b: self.response(gtk.RESPONSE_OK))
# replace the drop-down widget so we can modify it's properties
combo.clear()
cell = gtk.CellRendererText()
cell.set_property('ellipsize', pango.ELLIPSIZE_MIDDLE)
combo.pack_start(cell)
combo.add_attribute(cell, 'text', 0)
# browse button
browse = gtk.Button(_('Browse...'))
browse.connect('clicked', self.browse_clicked, title, entry)
if bundle:
# bundle button
bundlebtn = gtk.Button(_('Bundle...'))
bundlebtn.connect('clicked', self.bundle_clicked,
_('Select a Mercurial Bundle'), entry)
table.add_row(label, combo, 0, browse, bundlebtn)
else:
table.add_row(label, combo, 0, browse)
return model, combo
# layout table for fixed options
self.table = table = gtklib.LayoutTable()
vbox.pack_start(table, False, False, 2)
## comboentry for source paths
self.srclist, srccombo = createcombo(self.srcpath,
_('Source path:'),
_('Select Source Folder'), True)
self.srcentry = srccombo.get_child()
## add pre-defined src paths to pull-down list
sync_src = settings.Settings('synch').mrul('src_paths')
sympaths = [x[1] for x in self.ui.configitems('paths')]
recent = [x for x in self.recentsrc]
syncsrc = [x for x in sync_src]
paths = list(set(sympaths + recent + syncsrc))
paths.sort()
for p in paths:
self.srclist.append([p])
## comboentry for destination paths
self.destlist, destcombo = createcombo(self.destpath,
_('Destination path:'),
_('Select Destination Folder'))
self.destentry = destcombo.get_child()
## add most-recent dest paths to pull-down list
paths = list(self.recentdest)
paths.sort()
for p in paths:
self.destlist.append([p])
# expander for advanced options
self.expander = expander = gtk.Expander(_('Advanced options'))
vbox.pack_start(expander, False, False, 2)
# layout table for advanced options
table = gtklib.LayoutTable()
expander.add(table)
## revision option
self.reventry = gtk.Entry()
self.reventry.set_sensitive(False)
self.optrev = gtk.CheckButton(_('Clone to revision:'))
self.optrev.connect('toggled', self.checkbutton_toggled, self.reventry)
table.add_row(self.optrev, self.reventry)
self.exs = [name for name, module in extensions.extensions()]
if ('perfarce' in self.exs) or ('hgsubversion' in self.exs):
self.startreventry = gtk.Entry()
self.startreventry.set_sensitive(False)
self.optstartrev = gtk.CheckButton(_('Starting Revision:'))
self.optstartrev.connect('toggled',
self.checkbutton_toggled, self.startreventry)
table.add_row(self.optstartrev, self.startreventry)
## options
self.optupdate = gtk.CheckButton(_('Do not update the new working directory'))
self.optpull = gtk.CheckButton(_('Use pull protocol to copy metadata'))
self.optuncomp = gtk.CheckButton(_('Use uncompressed transfer'))
table.add_row(self.optupdate)
table.add_row(self.optpull)
table.add_row(self.optuncomp)
## proxy options
self.optproxy = gtk.CheckButton(_('Use proxy server'))
table.add_row(self.optproxy)
if self.ui.config('http_proxy', 'host'):
self.optproxy.set_active(True)
else:
self.optproxy.set_sensitive(False)
## remote cmd option
self.remotecmdentry = gtk.Entry()
self.remotecmdentry.set_sensitive(False)
self.optremote = gtk.CheckButton(_('Remote command:'))
self.optremote.connect('toggled', self.checkbutton_toggled, self.remotecmdentry)
table.add_row(self.optremote)
table.add_row(self.remotecmdentry, padding=False)
def thgdispatch(ui, path=None, args=[]):
'''
Replicate functionality of mercurial dispatch but force the use
of the passed in ui for all purposes
'''
# read --config before doing anything else
# (e.g. to change trust settings for reading .hg/hgrc)
config = _earlygetopt(['--config'], args)
if config:
ui.updateopts(config=_parseconfig(config))
# check for cwd
cwd = _earlygetopt(['--cwd'], args)
if cwd:
os.chdir(cwd[-1])
# read the local repository .hgrc into a local ui object
path = rootpath(path) or ""
if path:
try:
ui.readconfig(os.path.join(path, ".hg", "hgrc"))
except IOError:
pass
# now we can expand paths, even ones in .hg/hgrc
rpath = _earlygetopt(["-R", "--repository", "--repo"], args)
if rpath:
path = ui.expandpath(rpath[-1])
extensions.loadall(ui)
if not hasattr(extensions, 'extensions'):
extensions.extensions = lambda: () # pre-0.9.5, loadall did below
for name, module in extensions.extensions():
if name in _loaded:
continue
# setup extensions
extsetup = getattr(module, 'extsetup', None)
if extsetup:
extsetup()
cmdtable = getattr(module, 'cmdtable', {})
overrides = [cmd for cmd in cmdtable if cmd in commands.table]
if overrides:
ui.warn(_("extension '%s' overrides commands: %s\n")
% (name, " ".join(overrides)))
commands.table.update(cmdtable)
_loaded[name] = 1
# check for fallback encoding
fallback = ui.config('ui', 'fallbackencoding')
if fallback:
util._fallbackencoding = fallback
fullargs = args
cmd, func, args, options, cmdoptions = parse(ui, args)
if options["encoding"]:
util._encoding = options["encoding"]
if options["encodingmode"]:
util._encodingmode = options["encodingmode"]
ui.updateopts(options["verbose"], options["debug"], options["quiet"],
not options["noninteractive"], options["traceback"])
if options['help']:
return commands.help_(ui, cmd, options['version'])
elif options['version']:
return commands.version_(ui)
elif not cmd:
return commands.help_(ui, 'shortlist')
repo = None
if cmd not in commands.norepo.split():
try:
repo = hg.repository(ui, path=path)
repo.ui = ui
ui.setconfig("bundle", "mainreporoot", repo.root)
if not repo.local():
raise util.Abort(_("repository '%s' is not local") % path)
except RepoError:
if cmd not in commands.optionalrepo.split():
if not path:
raise RepoError(_("There is no Mercurial repository here"
" (.hg not found)"))
raise
d = lambda: func(ui, repo, *args, **cmdoptions)
else:
d = lambda: func(ui, *args, **cmdoptions)
# run pre-hook, and abort if it fails
ret = hook.hook(ui, repo, "pre-%s" % cmd, False, args=" ".join(fullargs))
if ret:
return ret
# Run actual command
try:
ret = d()
except TypeError, inst:
# was this an argument error?
tb = traceback.extract_tb(sys.exc_info()[2])
if len(tb) != 2: # no
raise
raise ParseError(cmd, _("invalid arguments"))
def extstyles():
for name, ext in extensions.extensions():
_styles.update(getattr(ext, 'colortable', {}))
def uisetup(ui):
# Disable auto-status for some commands which assume that all
# files in the result are under Mercurial's control
entry = extensions.wrapcommand(commands.table, 'add',
overrides.overrideadd)
addopt = [('', 'large', None, _('add as largefile')),
('', 'normal', None, _('add as normal file')),
('', 'lfsize', '',
_('add all files above this size '
'(in megabytes) as largefiles '
'(default: 10)'))]
entry[1].extend(addopt)
entry = extensions.wrapcommand(commands.table, 'addremove',
overrides.overrideaddremove)
entry = extensions.wrapcommand(commands.table, 'remove',
overrides.overrideremove)
entry = extensions.wrapcommand(commands.table, 'forget',
overrides.overrideforget)
# Subrepos call status function
entry = extensions.wrapcommand(commands.table, 'status',
overrides.overridestatus)
entry = extensions.wrapfunction(hgsubrepo, 'status',
overrides.overridestatusfn)
entry = extensions.wrapcommand(commands.table, 'log',
overrides.overridelog)
entry = extensions.wrapcommand(commands.table, 'rollback',
overrides.overriderollback)
entry = extensions.wrapcommand(commands.table, 'verify',
overrides.overrideverify)
verifyopt = [('', 'large', None, _('verify largefiles')),
('', 'lfa', None,
_('verify all revisions of largefiles not just current')),
('', 'lfc', None,
_('verify largefile contents not just existence'))]
entry[1].extend(verifyopt)
entry = extensions.wrapcommand(commands.table, 'outgoing',
overrides.overrideoutgoing)
outgoingopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(outgoingopt)
entry = extensions.wrapcommand(commands.table, 'summary',
overrides.overridesummary)
summaryopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(summaryopt)
entry = extensions.wrapcommand(commands.table, 'update',
overrides.overrideupdate)
entry = extensions.wrapcommand(commands.table, 'pull',
overrides.overridepull)
entry = extensions.wrapcommand(commands.table, 'cat',
overrides.overridecat)
entry = extensions.wrapfunction(merge, '_checkunknownfile',
overrides.overridecheckunknownfile)
entry = extensions.wrapfunction(merge, 'manifestmerge',
overrides.overridemanifestmerge)
entry = extensions.wrapfunction(filemerge, 'filemerge',
overrides.overridefilemerge)
entry = extensions.wrapfunction(cmdutil, 'copy', overrides.overridecopy)
# Summary calls dirty on the subrepos
entry = extensions.wrapfunction(hgsubrepo, 'dirty',
overrides.overridedirty)
# Backout calls revert so we need to override both the command and the
# function
entry = extensions.wrapcommand(commands.table, 'revert',
overrides.overriderevert)
entry = extensions.wrapfunction(commands, 'revert',
overrides.overriderevert)
# clone uses hg._update instead of hg.update even though they are the
# same function... so wrap both of them)
extensions.wrapfunction(hg, 'update', overrides.hgupdate)
extensions.wrapfunction(hg, '_update', overrides.hgupdate)
extensions.wrapfunction(hg, 'clean', overrides.hgclean)
extensions.wrapfunction(hg, 'merge', overrides.hgmerge)
extensions.wrapfunction(archival, 'archive', overrides.overridearchive)
extensions.wrapfunction(cmdutil, 'bailifchanged',
overrides.overridebailifchanged)
# create the new wireproto commands ...
wireproto.commands['putlfile'] = (proto.putlfile, 'sha')
wireproto.commands['getlfile'] = (proto.getlfile, 'sha')
wireproto.commands['statlfile'] = (proto.statlfile, 'sha')
# ... and wrap some existing ones
wireproto.commands['capabilities'] = (proto.capabilities, '')
wireproto.commands['heads'] = (proto.heads, '')
wireproto.commands['lheads'] = (wireproto.heads, '')
# make putlfile behave the same as push and {get,stat}lfile behave
# the same as pull w.r.t. permissions checks
hgweb_mod.perms['putlfile'] = 'push'
hgweb_mod.perms['getlfile'] = 'pull'
hgweb_mod.perms['statlfile'] = 'pull'
extensions.wrapfunction(webcommands, 'decodepath', overrides.decodepath)
# the hello wireproto command uses wireproto.capabilities, so it won't see
# our largefiles capability unless we replace the actual function as well.
proto.capabilitiesorig = wireproto.capabilities
wireproto.capabilities = proto.capabilities
# these let us reject non-largefiles clients and make them display
# our error messages
protocol.webproto.refuseclient = proto.webprotorefuseclient
sshserver.sshserver.refuseclient = proto.sshprotorefuseclient
# can't do this in reposetup because it needs to have happened before
# wirerepo.__init__ is called
proto.ssholdcallstream = sshrepo.sshrepository._callstream
proto.httpoldcallstream = httprepo.httprepository._callstream
sshrepo.sshrepository._callstream = proto.sshrepocallstream
httprepo.httprepository._callstream = proto.httprepocallstream
# don't die on seeing a repo with the largefiles requirement
localrepo.localrepository.supported |= set(['largefiles'])
# override some extensions' stuff as well
for name, module in extensions.extensions():
if name == 'fetch':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'fetch',
overrides.overridefetch)
if name == 'purge':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'purge',
overrides.overridepurge)
if name == 'rebase':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'rebase',
overrides.overriderebase)
if name == 'transplant':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'transplant',
overrides.overridetransplant)
def uisetup(ui):
# Disable auto-status for some commands which assume that all
# files in the result are under Mercurial's control
entry = extensions.wrapcommand(commands.table, 'add',
overrides.overrideadd)
addopt = [('', 'large', None, _('add as largefile')),
('', 'normal', None, _('add as normal file')),
('', 'lfsize', '', _('add all files above this size '
'(in megabytes) as largefiles '
'(default: 10)'))]
entry[1].extend(addopt)
# The scmutil function is called both by the (trivial) addremove command,
# and in the process of handling commit -A (issue3542)
entry = extensions.wrapfunction(scmutil, 'addremove',
overrides.scmutiladdremove)
extensions.wrapfunction(cmdutil, 'add', overrides.cmdutiladd)
extensions.wrapfunction(cmdutil, 'remove', overrides.cmdutilremove)
extensions.wrapfunction(cmdutil, 'forget', overrides.cmdutilforget)
extensions.wrapfunction(copies, 'pathcopies', overrides.copiespathcopies)
# Subrepos call status function
entry = extensions.wrapcommand(commands.table, 'status',
overrides.overridestatus)
entry = extensions.wrapfunction(subrepo.hgsubrepo, 'status',
overrides.overridestatusfn)
entry = extensions.wrapcommand(commands.table, 'log',
overrides.overridelog)
entry = extensions.wrapcommand(commands.table, 'rollback',
overrides.overriderollback)
entry = extensions.wrapcommand(commands.table, 'verify',
overrides.overrideverify)
verifyopt = [('', 'large', None,
_('verify that all largefiles in current revision exists')),
('', 'lfa', None,
_('verify largefiles in all revisions, not just current')),
('', 'lfc', None,
_('verify local largefile contents, not just existence'))]
entry[1].extend(verifyopt)
entry = extensions.wrapcommand(commands.table, 'debugstate',
overrides.overridedebugstate)
debugstateopt = [('', 'large', None, _('display largefiles dirstate'))]
entry[1].extend(debugstateopt)
outgoing = lambda orgfunc, *arg, **kwargs: orgfunc(*arg, **kwargs)
entry = extensions.wrapcommand(commands.table, 'outgoing', outgoing)
outgoingopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(outgoingopt)
cmdutil.outgoinghooks.add('largefiles', overrides.outgoinghook)
entry = extensions.wrapcommand(commands.table, 'summary',
overrides.overridesummary)
summaryopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(summaryopt)
cmdutil.summaryremotehooks.add('largefiles', overrides.summaryremotehook)
entry = extensions.wrapcommand(commands.table, 'pull',
overrides.overridepull)
pullopt = [('', 'all-largefiles', None,
_('download all pulled versions of largefiles (DEPRECATED)')),
('', 'lfrev', [],
_('download largefiles for these revisions'), _('REV'))]
entry[1].extend(pullopt)
revset.symbols['pulled'] = overrides.pulledrevsetsymbol
entry = extensions.wrapcommand(commands.table, 'clone',
overrides.overrideclone)
cloneopt = [('', 'all-largefiles', None,
_('download all versions of all largefiles'))]
entry[1].extend(cloneopt)
entry = extensions.wrapfunction(hg, 'clone', overrides.hgclone)
entry = extensions.wrapcommand(commands.table, 'cat',
overrides.overridecat)
entry = extensions.wrapfunction(merge, '_checkunknownfile',
overrides.overridecheckunknownfile)
entry = extensions.wrapfunction(merge, 'calculateupdates',
overrides.overridecalculateupdates)
entry = extensions.wrapfunction(merge, 'recordupdates',
overrides.mergerecordupdates)
entry = extensions.wrapfunction(merge, 'update',
overrides.mergeupdate)
entry = extensions.wrapfunction(filemerge, 'filemerge',
overrides.overridefilemerge)
entry = extensions.wrapfunction(cmdutil, 'copy',
overrides.overridecopy)
# Summary calls dirty on the subrepos
entry = extensions.wrapfunction(subrepo.hgsubrepo, 'dirty',
overrides.overridedirty)
entry = extensions.wrapfunction(cmdutil, 'revert',
overrides.overriderevert)
extensions.wrapfunction(archival, 'archive', overrides.overridearchive)
extensions.wrapfunction(subrepo.hgsubrepo, 'archive',
overrides.hgsubrepoarchive)
extensions.wrapfunction(cmdutil, 'bailifchanged',
overrides.overridebailifchanged)
extensions.wrapfunction(scmutil, 'marktouched',
overrides.scmutilmarktouched)
# create the new wireproto commands ...
wireproto.commands['putlfile'] = (proto.putlfile, 'sha')
wireproto.commands['getlfile'] = (proto.getlfile, 'sha')
wireproto.commands['statlfile'] = (proto.statlfile, 'sha')
# ... and wrap some existing ones
wireproto.commands['capabilities'] = (proto.capabilities, '')
wireproto.commands['heads'] = (proto.heads, '')
wireproto.commands['lheads'] = (wireproto.heads, '')
# make putlfile behave the same as push and {get,stat}lfile behave
# the same as pull w.r.t. permissions checks
hgweb_mod.perms['putlfile'] = 'push'
hgweb_mod.perms['getlfile'] = 'pull'
hgweb_mod.perms['statlfile'] = 'pull'
extensions.wrapfunction(webcommands, 'decodepath', overrides.decodepath)
# the hello wireproto command uses wireproto.capabilities, so it won't see
# our largefiles capability unless we replace the actual function as well.
proto.capabilitiesorig = wireproto.capabilities
wireproto.capabilities = proto.capabilities
# can't do this in reposetup because it needs to have happened before
# wirerepo.__init__ is called
proto.ssholdcallstream = sshpeer.sshpeer._callstream
proto.httpoldcallstream = httppeer.httppeer._callstream
sshpeer.sshpeer._callstream = proto.sshrepocallstream
httppeer.httppeer._callstream = proto.httprepocallstream
# override some extensions' stuff as well
for name, module in extensions.extensions():
if name == 'purge':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'purge',
overrides.overridepurge)
if name == 'rebase':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'rebase',
overrides.overriderebase)
extensions.wrapfunction(module, 'rebase',
overrides.overriderebase)
if name == 'transplant':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'transplant',
overrides.overridetransplant)
def uisetup(ui):
# Disable auto-status for some commands which assume that all
# files in the result are under Mercurial's control
entry = extensions.wrapcommand(commands.table, 'add',
overrides.overrideadd)
addopt = [('', 'large', None, _('add as largefile')),
('', 'normal', None, _('add as normal file')),
('', 'lfsize', '',
_('add all files above this size '
'(in megabytes) as largefiles '
'(default: 10)'))]
entry[1].extend(addopt)
# The scmutil function is called both by the (trivial) addremove command,
# and in the process of handling commit -A (issue3542)
entry = extensions.wrapfunction(scmutil, 'addremove',
overrides.scmutiladdremove)
extensions.wrapfunction(cmdutil, 'add', overrides.cmdutiladd)
extensions.wrapfunction(cmdutil, 'remove', overrides.cmdutilremove)
extensions.wrapfunction(cmdutil, 'forget', overrides.cmdutilforget)
extensions.wrapfunction(copies, 'pathcopies', overrides.copiespathcopies)
# Subrepos call status function
entry = extensions.wrapcommand(commands.table, 'status',
overrides.overridestatus)
entry = extensions.wrapfunction(subrepo.hgsubrepo, 'status',
overrides.overridestatusfn)
entry = extensions.wrapcommand(commands.table, 'log',
overrides.overridelog)
entry = extensions.wrapcommand(commands.table, 'rollback',
overrides.overriderollback)
entry = extensions.wrapcommand(commands.table, 'verify',
overrides.overrideverify)
verifyopt = [('', 'large', None,
_('verify that all largefiles in current revision exists')),
('', 'lfa', None,
_('verify largefiles in all revisions, not just current')),
('', 'lfc', None,
_('verify local largefile contents, not just existence'))]
entry[1].extend(verifyopt)
entry = extensions.wrapcommand(commands.table, 'debugstate',
overrides.overridedebugstate)
debugstateopt = [('', 'large', None, _('display largefiles dirstate'))]
entry[1].extend(debugstateopt)
outgoing = lambda orgfunc, *arg, **kwargs: orgfunc(*arg, **kwargs)
entry = extensions.wrapcommand(commands.table, 'outgoing', outgoing)
outgoingopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(outgoingopt)
cmdutil.outgoinghooks.add('largefiles', overrides.outgoinghook)
entry = extensions.wrapcommand(commands.table, 'summary',
overrides.overridesummary)
summaryopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(summaryopt)
cmdutil.summaryremotehooks.add('largefiles', overrides.summaryremotehook)
entry = extensions.wrapcommand(commands.table, 'pull',
overrides.overridepull)
pullopt = [('', 'all-largefiles', None,
_('download all pulled versions of largefiles (DEPRECATED)')),
('', 'lfrev', [], _('download largefiles for these revisions'),
_('REV'))]
entry[1].extend(pullopt)
entry = extensions.wrapcommand(commands.table, 'push',
overrides.overridepush)
pushopt = [('', 'lfrev', [], _('upload largefiles for these revisions'),
_('REV'))]
entry[1].extend(pushopt)
entry = extensions.wrapfunction(exchange, 'pushoperation',
overrides.exchangepushoperation)
entry = extensions.wrapcommand(commands.table, 'clone',
overrides.overrideclone)
cloneopt = [('', 'all-largefiles', None,
_('download all versions of all largefiles'))]
entry[1].extend(cloneopt)
entry = extensions.wrapfunction(hg, 'clone', overrides.hgclone)
entry = extensions.wrapcommand(commands.table, 'cat',
overrides.overridecat)
entry = extensions.wrapfunction(merge, '_checkunknownfile',
overrides.overridecheckunknownfile)
entry = extensions.wrapfunction(merge, 'calculateupdates',
overrides.overridecalculateupdates)
entry = extensions.wrapfunction(merge, 'recordupdates',
overrides.mergerecordupdates)
entry = extensions.wrapfunction(merge, 'update', overrides.mergeupdate)
entry = extensions.wrapfunction(filemerge, '_filemerge',
overrides.overridefilemerge)
entry = extensions.wrapfunction(cmdutil, 'copy', overrides.overridecopy)
# Summary calls dirty on the subrepos
entry = extensions.wrapfunction(subrepo.hgsubrepo, 'dirty',
overrides.overridedirty)
entry = extensions.wrapfunction(cmdutil, 'revert',
overrides.overriderevert)
extensions.wrapcommand(commands.table, 'archive',
overrides.overridearchivecmd)
extensions.wrapfunction(archival, 'archive', overrides.overridearchive)
extensions.wrapfunction(subrepo.hgsubrepo, 'archive',
overrides.hgsubrepoarchive)
extensions.wrapfunction(webcommands, 'archive', overrides.hgwebarchive)
extensions.wrapfunction(cmdutil, 'bailifchanged',
overrides.overridebailifchanged)
extensions.wrapfunction(cmdutil, 'postcommitstatus',
overrides.postcommitstatus)
extensions.wrapfunction(scmutil, 'marktouched',
overrides.scmutilmarktouched)
# create the new wireproto commands ...
wireproto.commands['putlfile'] = (proto.putlfile, 'sha')
wireproto.commands['getlfile'] = (proto.getlfile, 'sha')
wireproto.commands['statlfile'] = (proto.statlfile, 'sha')
# ... and wrap some existing ones
wireproto.commands['capabilities'] = (proto.capabilities, '')
wireproto.commands['heads'] = (proto.heads, '')
wireproto.commands['lheads'] = (wireproto.heads, '')
# make putlfile behave the same as push and {get,stat}lfile behave
# the same as pull w.r.t. permissions checks
wireproto.permissions['putlfile'] = 'push'
wireproto.permissions['getlfile'] = 'pull'
wireproto.permissions['statlfile'] = 'pull'
wireproto.permissions['lheads'] = 'pull'
extensions.wrapfunction(webcommands, 'decodepath', overrides.decodepath)
# the hello wireproto command uses wireproto.capabilities, so it won't see
# our largefiles capability unless we replace the actual function as well.
proto.capabilitiesorig = wireproto.capabilities
wireproto.capabilities = proto.capabilities
# can't do this in reposetup because it needs to have happened before
# wirerepo.__init__ is called
proto.ssholdcallstream = sshpeer.sshpeer._callstream
proto.httpoldcallstream = httppeer.httppeer._callstream
sshpeer.sshpeer._callstream = proto.sshrepocallstream
httppeer.httppeer._callstream = proto.httprepocallstream
# override some extensions' stuff as well
for name, module in extensions.extensions():
if name == 'purge':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'purge',
overrides.overridepurge)
if name == 'rebase':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'rebase',
overrides.overriderebase)
extensions.wrapfunction(module, 'rebase', overrides.overriderebase)
if name == 'transplant':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'transplant',
overrides.overridetransplant)
def uisetup(ui):
# Disable auto-status for some commands which assume that all
# files in the result are under Mercurial's control
entry = extensions.wrapcommand(commands.table, 'add',
overrides.overrideadd)
addopt = [('', 'large', None, _('add as largefile')),
('', 'normal', None, _('add as normal file')),
('', 'lfsize', '', _('add all files above this size '
'(in megabytes) as largefiles '
'(default: 10)'))]
entry[1].extend(addopt)
entry = extensions.wrapcommand(commands.table, 'addremove',
overrides.overrideaddremove)
entry = extensions.wrapcommand(commands.table, 'remove',
overrides.overrideremove)
entry = extensions.wrapcommand(commands.table, 'forget',
overrides.overrideforget)
# Subrepos call status function
entry = extensions.wrapcommand(commands.table, 'status',
overrides.overridestatus)
entry = extensions.wrapfunction(hgsubrepo, 'status',
overrides.overridestatusfn)
entry = extensions.wrapcommand(commands.table, 'log',
overrides.overridelog)
entry = extensions.wrapcommand(commands.table, 'rollback',
overrides.overriderollback)
entry = extensions.wrapcommand(commands.table, 'verify',
overrides.overrideverify)
verifyopt = [('', 'large', None, _('verify largefiles')),
('', 'lfa', None,
_('verify all revisions of largefiles not just current')),
('', 'lfc', None,
_('verify largefile contents not just existence'))]
entry[1].extend(verifyopt)
entry = extensions.wrapcommand(commands.table, 'outgoing',
overrides.overrideoutgoing)
outgoingopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(outgoingopt)
entry = extensions.wrapcommand(commands.table, 'summary',
overrides.overridesummary)
summaryopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(summaryopt)
entry = extensions.wrapcommand(commands.table, 'update',
overrides.overrideupdate)
entry = extensions.wrapcommand(commands.table, 'pull',
overrides.overridepull)
entry = extensions.wrapcommand(commands.table, 'cat',
overrides.overridecat)
entry = extensions.wrapfunction(merge, '_checkunknownfile',
overrides.overridecheckunknownfile)
entry = extensions.wrapfunction(merge, 'manifestmerge',
overrides.overridemanifestmerge)
entry = extensions.wrapfunction(filemerge, 'filemerge',
overrides.overridefilemerge)
entry = extensions.wrapfunction(cmdutil, 'copy',
overrides.overridecopy)
# Summary calls dirty on the subrepos
entry = extensions.wrapfunction(hgsubrepo, 'dirty',
overrides.overridedirty)
# Backout calls revert so we need to override both the command and the
# function
entry = extensions.wrapcommand(commands.table, 'revert',
overrides.overriderevert)
entry = extensions.wrapfunction(commands, 'revert',
overrides.overriderevert)
# clone uses hg._update instead of hg.update even though they are the
# same function... so wrap both of them)
extensions.wrapfunction(hg, 'update', overrides.hgupdate)
extensions.wrapfunction(hg, '_update', overrides.hgupdate)
extensions.wrapfunction(hg, 'clean', overrides.hgclean)
extensions.wrapfunction(hg, 'merge', overrides.hgmerge)
extensions.wrapfunction(archival, 'archive', overrides.overridearchive)
extensions.wrapfunction(cmdutil, 'bailifchanged',
overrides.overridebailifchanged)
# create the new wireproto commands ...
wireproto.commands['putlfile'] = (proto.putlfile, 'sha')
wireproto.commands['getlfile'] = (proto.getlfile, 'sha')
wireproto.commands['statlfile'] = (proto.statlfile, 'sha')
# ... and wrap some existing ones
wireproto.commands['capabilities'] = (proto.capabilities, '')
wireproto.commands['heads'] = (proto.heads, '')
wireproto.commands['lheads'] = (wireproto.heads, '')
# make putlfile behave the same as push and {get,stat}lfile behave
# the same as pull w.r.t. permissions checks
hgweb_mod.perms['putlfile'] = 'push'
hgweb_mod.perms['getlfile'] = 'pull'
hgweb_mod.perms['statlfile'] = 'pull'
extensions.wrapfunction(webcommands, 'decodepath', overrides.decodepath)
# the hello wireproto command uses wireproto.capabilities, so it won't see
# our largefiles capability unless we replace the actual function as well.
proto.capabilitiesorig = wireproto.capabilities
wireproto.capabilities = proto.capabilities
# these let us reject non-largefiles clients and make them display
# our error messages
protocol.webproto.refuseclient = proto.webprotorefuseclient
sshserver.sshserver.refuseclient = proto.sshprotorefuseclient
# can't do this in reposetup because it needs to have happened before
# wirerepo.__init__ is called
proto.ssholdcallstream = sshrepo.sshrepository._callstream
proto.httpoldcallstream = httprepo.httprepository._callstream
sshrepo.sshrepository._callstream = proto.sshrepocallstream
httprepo.httprepository._callstream = proto.httprepocallstream
# don't die on seeing a repo with the largefiles requirement
localrepo.localrepository.supported |= set(['largefiles'])
# override some extensions' stuff as well
for name, module in extensions.extensions():
if name == 'fetch':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'fetch',
overrides.overridefetch)
if name == 'purge':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'purge',
overrides.overridepurge)
if name == 'rebase':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'rebase',
overrides.overriderebase)
if name == 'transplant':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'transplant',
overrides.overridetransplant)
def uisetup(ui):
# Disable auto-status for some commands which assume that all
# files in the result are under Mercurial's control
entry = extensions.wrapcommand(commands.table, 'add',
overrides.overrideadd)
addopt = [('', 'large', None, _('add as largefile')),
('', 'normal', None, _('add as normal file')),
('', 'lfsize', '',
_('add all files above this size '
'(in megabytes) as largefiles '
'(default: 10)'))]
entry[1].extend(addopt)
# The scmutil function is called both by the (trivial) addremove command,
# and in the process of handling commit -A (issue3542)
entry = extensions.wrapfunction(scmutil, 'addremove',
overrides.scmutiladdremove)
entry = extensions.wrapcommand(commands.table, 'remove',
overrides.overrideremove)
entry = extensions.wrapcommand(commands.table, 'forget',
overrides.overrideforget)
# Subrepos call status function
entry = extensions.wrapcommand(commands.table, 'status',
overrides.overridestatus)
entry = extensions.wrapfunction(hgsubrepo, 'status',
overrides.overridestatusfn)
entry = extensions.wrapcommand(commands.table, 'log',
overrides.overridelog)
entry = extensions.wrapcommand(commands.table, 'rollback',
overrides.overriderollback)
entry = extensions.wrapcommand(commands.table, 'verify',
overrides.overrideverify)
verifyopt = [('', 'large', None,
_('verify that all largefiles in current revision exists')),
('', 'lfa', None,
_('verify largefiles in all revisions, not just current')),
('', 'lfc', None,
_('verify local largefile contents, not just existence'))]
entry[1].extend(verifyopt)
entry = extensions.wrapcommand(commands.table, 'debugstate',
overrides.overridedebugstate)
debugstateopt = [('', 'large', None, _('display largefiles dirstate'))]
entry[1].extend(debugstateopt)
entry = extensions.wrapcommand(commands.table, 'outgoing',
overrides.overrideoutgoing)
outgoingopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(outgoingopt)
entry = extensions.wrapcommand(commands.table, 'summary',
overrides.overridesummary)
summaryopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(summaryopt)
entry = extensions.wrapcommand(commands.table, 'update',
overrides.overrideupdate)
entry = extensions.wrapcommand(commands.table, 'pull',
overrides.overridepull)
pullopt = [('', 'all-largefiles', None,
_('download all pulled versions of largefiles (DEPRECATED)')),
('', 'lfrev', [], _('download largefiles for these revisions'),
_('REV'))]
entry[1].extend(pullopt)
revset.symbols['pulled'] = overrides.pulledrevsetsymbol
entry = extensions.wrapcommand(commands.table, 'clone',
overrides.overrideclone)
cloneopt = [('', 'all-largefiles', None,
_('download all versions of all largefiles'))]
entry[1].extend(cloneopt)
entry = extensions.wrapfunction(hg, 'clone', overrides.hgclone)
entry = extensions.wrapcommand(commands.table, 'cat',
overrides.overridecat)
entry = extensions.wrapfunction(merge, '_checkunknownfile',
overrides.overridecheckunknownfile)
entry = extensions.wrapfunction(merge, 'manifestmerge',
overrides.overridemanifestmerge)
entry = extensions.wrapfunction(filemerge, 'filemerge',
overrides.overridefilemerge)
entry = extensions.wrapfunction(cmdutil, 'copy', overrides.overridecopy)
# Summary calls dirty on the subrepos
entry = extensions.wrapfunction(hgsubrepo, 'dirty',
overrides.overridedirty)
# Backout calls revert so we need to override both the command and the
# function
entry = extensions.wrapcommand(commands.table, 'revert',
overrides.overriderevert)
entry = extensions.wrapfunction(commands, 'revert',
overrides.overriderevert)
extensions.wrapfunction(hg, 'updaterepo', overrides.hgupdaterepo)
extensions.wrapfunction(hg, 'merge', overrides.hgmerge)
extensions.wrapfunction(archival, 'archive', overrides.overridearchive)
extensions.wrapfunction(hgsubrepo, 'archive', overrides.hgsubrepoarchive)
extensions.wrapfunction(cmdutil, 'bailifchanged',
overrides.overridebailifchanged)
# create the new wireproto commands ...
wireproto.commands['putlfile'] = (proto.putlfile, 'sha')
wireproto.commands['getlfile'] = (proto.getlfile, 'sha')
wireproto.commands['statlfile'] = (proto.statlfile, 'sha')
# ... and wrap some existing ones
wireproto.commands['capabilities'] = (proto.capabilities, '')
wireproto.commands['heads'] = (proto.heads, '')
wireproto.commands['lheads'] = (wireproto.heads, '')
# make putlfile behave the same as push and {get,stat}lfile behave
# the same as pull w.r.t. permissions checks
hgweb_mod.perms['putlfile'] = 'push'
hgweb_mod.perms['getlfile'] = 'pull'
hgweb_mod.perms['statlfile'] = 'pull'
extensions.wrapfunction(webcommands, 'decodepath', overrides.decodepath)
# the hello wireproto command uses wireproto.capabilities, so it won't see
# our largefiles capability unless we replace the actual function as well.
proto.capabilitiesorig = wireproto.capabilities
wireproto.capabilities = proto.capabilities
# can't do this in reposetup because it needs to have happened before
# wirerepo.__init__ is called
proto.ssholdcallstream = sshpeer.sshpeer._callstream
proto.httpoldcallstream = httppeer.httppeer._callstream
sshpeer.sshpeer._callstream = proto.sshrepocallstream
httppeer.httppeer._callstream = proto.httprepocallstream
# don't die on seeing a repo with the largefiles requirement
localrepo.localrepository.supported |= set(['largefiles'])
# override some extensions' stuff as well
for name, module in extensions.extensions():
if name == 'fetch':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'fetch',
overrides.overridefetch)
if name == 'purge':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'purge',
overrides.overridepurge)
if name == 'rebase':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'rebase',
overrides.overriderebase)
if name == 'transplant':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'transplant',
overrides.overridetransplant)
if name == 'convert':
convcmd = getattr(module, 'convcmd')
hgsink = getattr(convcmd, 'mercurial_sink')
extensions.wrapfunction(hgsink, 'before',
overrides.mercurialsinkbefore)
extensions.wrapfunction(hgsink, 'after',
overrides.mercurialsinkafter)
def extstyles():
for name, ext in extensions.extensions():
_styles.update(getattr(ext, 'colortable', {}))
def featuresetup(ui, supported):
for name, module in extensions.extensions(ui):
if __name__ == module.__name__:
# don't die on seeing a repo with the largefiles requirement
supported |= set(['largefiles'])
return
def uisetup(ui):
# Disable auto-status for some commands which assume that all
# files in the result are under Mercurial's control
entry = extensions.wrapcommand(commands.table, "add", overrides.overrideadd)
addopt = [
("", "large", None, _("add as largefile")),
("", "normal", None, _("add as normal file")),
("", "lfsize", "", _("add all files above this size " "(in megabytes) as largefiles " "(default: 10)")),
]
entry[1].extend(addopt)
# The scmutil function is called both by the (trivial) addremove command,
# and in the process of handling commit -A (issue3542)
entry = extensions.wrapfunction(scmutil, "addremove", overrides.scmutiladdremove)
entry = extensions.wrapcommand(commands.table, "remove", overrides.overrideremove)
entry = extensions.wrapcommand(commands.table, "forget", overrides.overrideforget)
# Subrepos call status function
entry = extensions.wrapcommand(commands.table, "status", overrides.overridestatus)
entry = extensions.wrapfunction(hgsubrepo, "status", overrides.overridestatusfn)
entry = extensions.wrapcommand(commands.table, "log", overrides.overridelog)
entry = extensions.wrapcommand(commands.table, "rollback", overrides.overriderollback)
entry = extensions.wrapcommand(commands.table, "verify", overrides.overrideverify)
verifyopt = [
("", "large", None, _("verify that all largefiles in current revision exists")),
("", "lfa", None, _("verify largefiles in all revisions, not just current")),
("", "lfc", None, _("verify local largefile contents, not just existence")),
]
entry[1].extend(verifyopt)
entry = extensions.wrapcommand(commands.table, "debugstate", overrides.overridedebugstate)
debugstateopt = [("", "large", None, _("display largefiles dirstate"))]
entry[1].extend(debugstateopt)
entry = extensions.wrapcommand(commands.table, "outgoing", overrides.overrideoutgoing)
outgoingopt = [("", "large", None, _("display outgoing largefiles"))]
entry[1].extend(outgoingopt)
entry = extensions.wrapcommand(commands.table, "summary", overrides.overridesummary)
summaryopt = [("", "large", None, _("display outgoing largefiles"))]
entry[1].extend(summaryopt)
entry = extensions.wrapcommand(commands.table, "update", overrides.overrideupdate)
entry = extensions.wrapcommand(commands.table, "pull", overrides.overridepull)
pullopt = [
("", "all-largefiles", None, _("download all pulled versions of largefiles (DEPRECATED)")),
("", "lfrev", [], _("download largefiles for these revisions"), _("REV")),
]
entry[1].extend(pullopt)
revset.symbols["pulled"] = overrides.pulledrevsetsymbol
entry = extensions.wrapcommand(commands.table, "clone", overrides.overrideclone)
cloneopt = [("", "all-largefiles", None, _("download all versions of all largefiles"))]
entry[1].extend(cloneopt)
entry = extensions.wrapfunction(hg, "clone", overrides.hgclone)
entry = extensions.wrapcommand(commands.table, "cat", overrides.overridecat)
entry = extensions.wrapfunction(merge, "_checkunknownfile", overrides.overridecheckunknownfile)
entry = extensions.wrapfunction(merge, "manifestmerge", overrides.overridemanifestmerge)
entry = extensions.wrapfunction(filemerge, "filemerge", overrides.overridefilemerge)
entry = extensions.wrapfunction(cmdutil, "copy", overrides.overridecopy)
# Summary calls dirty on the subrepos
entry = extensions.wrapfunction(hgsubrepo, "dirty", overrides.overridedirty)
# Backout calls revert so we need to override both the command and the
# function
entry = extensions.wrapcommand(commands.table, "revert", overrides.overriderevert)
entry = extensions.wrapfunction(commands, "revert", overrides.overriderevert)
extensions.wrapfunction(hg, "updaterepo", overrides.hgupdaterepo)
extensions.wrapfunction(hg, "merge", overrides.hgmerge)
extensions.wrapfunction(archival, "archive", overrides.overridearchive)
extensions.wrapfunction(hgsubrepo, "archive", overrides.hgsubrepoarchive)
extensions.wrapfunction(cmdutil, "bailifchanged", overrides.overridebailifchanged)
# create the new wireproto commands ...
wireproto.commands["putlfile"] = (proto.putlfile, "sha")
wireproto.commands["getlfile"] = (proto.getlfile, "sha")
wireproto.commands["statlfile"] = (proto.statlfile, "sha")
# ... and wrap some existing ones
wireproto.commands["capabilities"] = (proto.capabilities, "")
wireproto.commands["heads"] = (proto.heads, "")
wireproto.commands["lheads"] = (wireproto.heads, "")
# make putlfile behave the same as push and {get,stat}lfile behave
# the same as pull w.r.t. permissions checks
hgweb_mod.perms["putlfile"] = "push"
hgweb_mod.perms["getlfile"] = "pull"
hgweb_mod.perms["statlfile"] = "pull"
extensions.wrapfunction(webcommands, "decodepath", overrides.decodepath)
# the hello wireproto command uses wireproto.capabilities, so it won't see
# our largefiles capability unless we replace the actual function as well.
proto.capabilitiesorig = wireproto.capabilities
wireproto.capabilities = proto.capabilities
# can't do this in reposetup because it needs to have happened before
# wirerepo.__init__ is called
proto.ssholdcallstream = sshpeer.sshpeer._callstream
proto.httpoldcallstream = httppeer.httppeer._callstream
sshpeer.sshpeer._callstream = proto.sshrepocallstream
httppeer.httppeer._callstream = proto.httprepocallstream
# don't die on seeing a repo with the largefiles requirement
localrepo.localrepository.supported |= set(["largefiles"])
# override some extensions' stuff as well
for name, module in extensions.extensions():
if name == "fetch":
extensions.wrapcommand(getattr(module, "cmdtable"), "fetch", overrides.overridefetch)
if name == "purge":
extensions.wrapcommand(getattr(module, "cmdtable"), "purge", overrides.overridepurge)
if name == "rebase":
extensions.wrapcommand(getattr(module, "cmdtable"), "rebase", overrides.overriderebase)
if name == "transplant":
extensions.wrapcommand(getattr(module, "cmdtable"), "transplant", overrides.overridetransplant)
if name == "convert":
convcmd = getattr(module, "convcmd")
hgsink = getattr(convcmd, "mercurial_sink")
extensions.wrapfunction(hgsink, "before", overrides.mercurialsinkbefore)
extensions.wrapfunction(hgsink, "after", overrides.mercurialsinkafter)
def __init__(self, repos=[], pushmode=False):
""" Initialize the Dialog. """
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
gtklib.set_tortoise_icon(self, 'menusynch.ico')
gtklib.set_tortoise_keys(self)
self.root = paths.find_root()
self.selected_path = None
self.hgthread = None
self.notify_func = None
self.last_drop_time = None
self.lastcmd = []
# persistent app data
self._settings = settings.Settings('synch')
self.set_default_size(655, 552)
self.paths = self.get_paths()
self.set_title(_('%s - synchronize') % hglib.get_reponame(self.repo))
self.connect('delete-event', self.delete)
# toolbar
self.tbar = gtk.Toolbar()
self.tips = gtklib.Tooltips()
self.stop_button = self.toolbutton(gtk.STOCK_STOP,
_('Stop'), self.stop_clicked, tip=_('Stop the hg operation'))
self.stop_button.set_sensitive(False)
tbuttons = [
self.toolbutton(gtk.STOCK_GO_DOWN,
_('Incoming'),
self.incoming_clicked,
tip=_('Display changes that can be pulled '
'from selected repository')),
self.toolbutton(gtk.STOCK_GOTO_BOTTOM,
_(' Pull '),
self.pull_clicked,
tip=_('Pull changes from selected '
'repository')),
gtk.SeparatorToolItem(),
self.toolbutton(gtk.STOCK_GO_UP,
_('Outgoing'),
self.outgoing_clicked,
tip=_('Display local changes that will be '
'pushed to selected repository')),
self.toolbutton(gtk.STOCK_GOTO_TOP,
_('Push'),
self.push_clicked,
tip=_('Push local changes to selected '
'repository')),
self.toolbutton(gtk.STOCK_GOTO_LAST,
_('Email'),
self.email_clicked,
tip=_('Email local outgoing changes to '
'one or more recipients')),
self.toolbutton(gtk.STOCK_UNDO,
_('Shelve'),
self.shelve_clicked,
tip=_('Shelve uncommited changes')),
gtk.SeparatorToolItem(),
self.stop_button,
gtk.SeparatorToolItem(),
self.toolbutton(gtk.STOCK_PREFERENCES,
_('Configure'),
self.conf_clicked,
tip=_('Configure peer repository paths')),
gtk.SeparatorToolItem(),
]
for btn in tbuttons:
self.tbar.insert(btn, -1)
# Base box
self.basevbox = basevbox = gtk.VBox()
self.add(basevbox)
basevbox.pack_start(self.tbar, False, False, 2)
# Sync Target Path
targethbox = gtk.HBox()
## target selection buttons
lbl = gtk.Button(_('Repo:'))
lbl.unset_flags(gtk.CAN_FOCUS)
lbl.connect('clicked', self.btn_remotepath_clicked)
targethbox.pack_start(lbl, False, False)
lbl = gtk.Button(_('Bundle:'))
lbl.unset_flags(gtk.CAN_FOCUS)
lbl.connect('clicked', self.btn_bundlepath_clicked)
targethbox.pack_start(lbl, False, False)
## target path combobox
self.pathlist = gtk.ListStore(str, str)
self.pathbox = gtk.ComboBoxEntry(self.pathlist, 0)
self.pathtext = self.pathbox.get_child()
cell = gtk.CellRendererText()
self.pathbox.pack_end(cell, False)
self.pathbox.add_attribute(cell, 'text', 1)
targethbox.pack_start(self.pathbox, True, True)
self.fill_path_combo()
defrow = None
defpushrow = None
for i, (path, alias) in enumerate(self.pathlist):
if alias == 'default':
defrow = i
if defpushrow is None:
defpushrow = i
elif alias == 'default-push':
defpushrow = i
if repos:
self.pathtext.set_text(hglib.toutf(repos[0]))
elif defpushrow is not None and pushmode:
self.pathbox.set_active(defpushrow)
elif defrow is not None:
self.pathbox.set_active(defrow)
exs = [ name for name, module in extensions.extensions() ]
# Post Pull Operation
ppullhbox = gtk.HBox()
self.ppulldata = [('none', _('Nothing')), ('update', _('Update'))]
cfg = self.repo.ui.config('tortoisehg.postpull', 'none')
if 'fetch' in exs or 'fetch' == cfg:
self.ppulldata.append(('fetch', _('Fetch')))
if 'rebase' in exs or 'rebase' == cfg:
self.ppulldata.append(('rebase', _('Rebase')))
self.ppullcombo = combo = gtk.combo_box_new_text()
for (index, (name, label)) in enumerate(self.ppulldata):
combo.insert_text(index, label)
ppullhbox.pack_start(gtk.Label(_('Post Pull: ')), False, False, 2)
ppullhbox.pack_start(self.ppullcombo, True, True)
# Fixed options box (non-foldable)
fixedhbox = gtk.HBox()
fixedhbox.pack_start(targethbox, True, True, 2)
fixedhbox.pack_start(ppullhbox, False, False, 2)
# Advanced options (foldable)
opthbox = gtk.HBox()
self.expander = expander = gtk.Expander(_('Advanced Options'))
expander.set_expanded(False)
expander.connect_after('activate', self.expanded)
expander.add(opthbox)
## checkbox options
chkopthbox = gtk.HBox()
self.force = gtk.CheckButton(_('Force pull or push'))
self.tips.set_tip(self.force,
_('Run even when remote repository is unrelated.'))
self.newbranch = gtk.CheckButton(_('Push new branch'))
self.tips.set_tip(self.newbranch, _('Allow pushing a new branch'))
self.use_proxy = gtk.CheckButton(_('Use proxy server'))
if ui.ui().config('http_proxy', 'host', ''):
self.use_proxy.set_active(True)
else:
self.use_proxy.set_sensitive(False)
chkopthbox.pack_start(self.force, False, False, 4)
chkopthbox.pack_start(self.newbranch, False, False, 4)
chkopthbox.pack_start(self.use_proxy, False, False, 4)
## target revision option
revhbox = gtk.HBox()
self.reventry = gtk.Entry()
revhbox.pack_start(gtk.Label(_('Target revision:')), False, False, 2)
revhbox.pack_start(self.reventry, True, True, 2)
reveventbox = gtk.EventBox()
reveventbox.add(revhbox)
self.tips.set_tip(reveventbox,
_('A specific revision up to which you '
'would like to push or pull.'))
## remote command option
cmdhbox = gtk.HBox()
self.cmdentry = gtk.Entry()
cmdhbox.pack_start(gtk.Label(_('Remote command:')), False, False, 2)
cmdhbox.pack_start(self.cmdentry, True, True, 2)
cmdeventbox = gtk.EventBox()
cmdeventbox.add(cmdhbox)
self.tips.set_tip(cmdeventbox,
_('Name of hg executable on remote machine.'))
revvbox = gtk.VBox()
revvbox.pack_start(chkopthbox, False, False, 8)
revvbox.pack_start(reveventbox, False, False, 4)
revvbox.pack_start(cmdeventbox, False, False, 4)
opthbox.pack_start(revvbox, True, True, 4)
## incoming/outgoing options
frame = gtk.Frame(_('Incoming/Outgoing'))
opthbox.pack_start(frame, False, False, 2)
self.showpatch = gtk.CheckButton(_('Show patches'))
self.newestfirst = gtk.CheckButton(_('Show newest first'))
self.nomerge = gtk.CheckButton(_('Show no merges'))
iovbox = gtk.VBox()
iovbox.pack_start(self.showpatch, False, False, 2)
iovbox.pack_start(self.newestfirst, False, False, 2)
iovbox.pack_start(self.nomerge, False, False, 2)
frame.add(iovbox)
# Main option box
topvbox = gtk.VBox()
topvbox.pack_start(fixedhbox, True, True, 2)
topvbox.pack_start(expander, False, False, 2)
basevbox.pack_start(topvbox, False, False, 2)
# hg output window
scrolledwindow = gtk.ScrolledWindow()
scrolledwindow.set_shadow_type(gtk.SHADOW_ETCHED_IN)
scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.textview = gtk.TextView(buffer=None)
self.textview.set_editable(False)
fontlog = hglib.getfontconfig()['fontlog']
self.textview.modify_font(pango.FontDescription(fontlog))
scrolledwindow.add(self.textview)
self.textview.connect('populate-popup', self.add_to_popup)
self.textbuffer = self.textview.get_buffer()
gtklib.configstyles(self.repo.ui)
for tag, argdict in gtklib.TextBufferTags.iteritems():
self.textbuffer.create_tag(tag, **argdict)
basevbox.pack_start(scrolledwindow, True, True)
# statusbar
self.stbar = statusbar.StatusBar()
basevbox.pack_end(self.stbar, False, False, 2)
# support dropping of repos or bundle files
self.drag_dest_set(gtk.DEST_DEFAULT_ALL,
[("text/uri-list", 0, 1)], gtk.gdk.ACTION_COPY)
self.connect('drag_data_received', self._drag_receive)
# prepare to show
self.load_settings()
self.update_pull_setting()
gtklib.idle_add_single_call(self.finalize_startup)
