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 _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) # 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 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)