hg.py
631 lines
| 21.5 KiB
| text/x-python
|
PythonLexer
/ mercurial / hg.py
|
r0 | # hg.py - repository classes for mercurial | ||
# | ||||
|
r4635 | # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r2859 | # Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> | ||
|
r0 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r0 | |||
|
r3891 | from i18n import _ | ||
|
r8109 | from lock import release | ||
|
r14064 | from node import hex, nullid | ||
|
r18944 | import localrepo, bundlerepo, unionrepo, httppeer, sshpeer, statichttprepo | ||
import bookmarks, lock, util, extensions, error, node, scmutil, phases, url | ||||
|
r14076 | import cmdutil, discovery | ||
|
r10651 | import merge as mergemod | ||
import verify as verifymod | ||||
|
r8312 | import errno, os, shutil | ||
|
r0 | |||
|
r2740 | def _local(path): | ||
|
r14825 | path = util.expandpath(util.urllocalpath(path)) | ||
|
r11154 | return (os.path.isfile(path) and bundlerepo or localrepo) | ||
|
r2469 | |||
|
r17191 | def addbranchrevs(lrepo, other, branches, revs): | ||
peer = other.peer() # a courtesy to callers using a localrepo for other | ||||
|
r11322 | hashbranch, branches = branches | ||
if not hashbranch and not branches: | ||||
|
r10365 | return revs or None, revs and revs[0] or None | ||
|
r10380 | revs = revs and list(revs) or [] | ||
|
r17191 | if not peer.capable('branchmap'): | ||
|
r11322 | if branches: | ||
raise util.Abort(_("remote branch lookup not supported")) | ||||
revs.append(hashbranch) | ||||
|
r10380 | return revs, revs[0] | ||
|
r17191 | branchmap = peer.branchmap() | ||
|
r11322 | |||
|
r13047 | def primary(branch): | ||
if branch == '.': | ||||
|
r17191 | if not lrepo: | ||
|
r10365 | raise util.Abort(_("dirstate branch not accessible")) | ||
|
r13047 | branch = lrepo.dirstate.branch() | ||
if branch in branchmap: | ||||
revs.extend(node.hex(r) for r in reversed(branchmap[branch])) | ||||
|
r11322 | return True | ||
|
r10365 | else: | ||
|
r11322 | return False | ||
for branch in branches: | ||||
|
r13047 | if not primary(branch): | ||
|
r11322 | raise error.RepoLookupError(_("unknown branch '%s'") % branch) | ||
if hashbranch: | ||||
|
r13047 | if not primary(hashbranch): | ||
|
r11322 | revs.append(hashbranch) | ||
|
r10365 | return revs, revs[0] | ||
|
r13824 | def parseurl(path, branches=None): | ||
|
r11322 | '''parse url#branch, returning (url, (branch, branches))''' | ||
|
r5177 | |||
|
r14076 | u = util.url(path) | ||
|
r13897 | branch = None | ||
if u.fragment: | ||||
branch = u.fragment | ||||
u.fragment = None | ||||
|
r13824 | return str(u), (branch, branches or []) | ||
|
r5177 | |||
|
r14606 | schemes = { | ||
|
r14568 | 'bundle': bundlerepo, | ||
|
r18944 | 'union': unionrepo, | ||
|
r14568 | 'file': _local, | ||
|
r17192 | 'http': httppeer, | ||
'https': httppeer, | ||||
'ssh': sshpeer, | ||||
|
r14568 | 'static-http': statichttprepo, | ||
} | ||||
def _peerlookup(path): | ||||
u = util.url(path) | ||||
scheme = u.scheme or 'file' | ||||
|
r14606 | thing = schemes.get(scheme) or schemes['file'] | ||
|
r14568 | try: | ||
return thing(path) | ||||
except TypeError: | ||||
return thing | ||||
|
r14605 | def islocal(repo): | ||
|
r20355 | '''return true if repo (or path pointing to repo) is local''' | ||
|
r14605 | if isinstance(repo, str): | ||
try: | ||||
return _peerlookup(repo).islocal(repo) | ||||
except AttributeError: | ||||
return False | ||||
return repo.local() | ||||
|
r17887 | def openpath(ui, path): | ||
'''open path with open if local, url.open if remote''' | ||||
|
r20354 | pathurl = util.url(path, parsequery=False, parsefragment=False) | ||
if pathurl.islocal(): | ||||
return util.posixfile(pathurl.localpath(), 'rb') | ||||
|
r17887 | else: | ||
return url.open(ui, path) | ||||
|
r17191 | def _peerorrepo(ui, path, create=False): | ||
|
r14605 | """return a repository object for the specified path""" | ||
|
r17191 | obj = _peerlookup(path).instance(ui, path, create) | ||
ui = getattr(obj, "ui", ui) | ||||
|
r19777 | for name, module in extensions.extensions(ui): | ||
|
r14605 | hook = getattr(module, 'reposetup', None) | ||
if hook: | ||||
|
r17191 | hook(ui, obj) | ||
return obj | ||||
def repository(ui, path='', create=False): | ||||
"""return a repository object for the specified path""" | ||||
peer = _peerorrepo(ui, path, create) | ||||
repo = peer.local() | ||||
if not repo: | ||||
raise util.Abort(_("repository '%s' is not local") % | ||||
(path or peer.url())) | ||||
|
r18382 | return repo.filtered('visible') | ||
|
r14605 | |||
|
r14839 | def peer(uiorrepo, opts, path, create=False): | ||
|
r14554 | '''return a repository peer for the specified path''' | ||
|
r14839 | rui = remoteui(uiorrepo, opts) | ||
|
r17191 | return _peerorrepo(rui, path, create).peer() | ||
|
r14554 | |||
|
r2719 | def defaultdest(source): | ||
'''return default destination of clone if none is given''' | ||||
|
r18553 | return os.path.basename(os.path.normpath(util.url(source).path or '')) | ||
|
r2774 | |||
|
r8807 | def share(ui, source, dest=None, update=True): | ||
|
r8800 | '''create a shared repository''' | ||
if not islocal(source): | ||||
raise util.Abort(_('can only share local repositories')) | ||||
|
r8807 | if not dest: | ||
|
r10099 | dest = defaultdest(source) | ||
|
r9344 | else: | ||
dest = ui.expandpath(dest) | ||||
|
r8807 | |||
|
r8800 | if isinstance(source, str): | ||
origsource = ui.expandpath(source) | ||||
|
r10365 | source, branches = parseurl(origsource) | ||
|
r8800 | srcrepo = repository(ui, source) | ||
|
r10365 | rev, checkout = addbranchrevs(srcrepo, srcrepo, branches, None) | ||
|
r8800 | else: | ||
|
r17191 | srcrepo = source.local() | ||
|
r8800 | origsource = source = srcrepo.url() | ||
checkout = None | ||||
sharedpath = srcrepo.sharedpath # if our source is already sharing | ||||
|
r15381 | root = os.path.realpath(dest) | ||
|
r8800 | roothg = os.path.join(root, '.hg') | ||
if os.path.exists(roothg): | ||||
raise util.Abort(_('destination already exists')) | ||||
if not os.path.isdir(root): | ||||
os.mkdir(root) | ||||
|
r13795 | util.makedir(roothg, notindexed=True) | ||
|
r8800 | |||
requirements = '' | ||||
try: | ||||
|
r14168 | requirements = srcrepo.opener.read('requires') | ||
|
r8800 | except IOError, inst: | ||
if inst.errno != errno.ENOENT: | ||||
raise | ||||
requirements += 'shared\n' | ||||
|
r14168 | util.writefile(os.path.join(roothg, 'requires'), requirements) | ||
util.writefile(os.path.join(roothg, 'sharedpath'), sharedpath) | ||||
|
r8800 | |||
|
r14156 | r = repository(ui, root) | ||
|
r8800 | default = srcrepo.ui.config('paths', 'default') | ||
|
r18511 | if default: | ||
fp = r.opener("hgrc", "w", text=True) | ||||
fp.write("[paths]\n") | ||||
fp.write("default = %s\n" % default) | ||||
fp.close() | ||||
|
r8800 | |||
if update: | ||||
r.ui.status(_("updating working directory\n")) | ||||
if update is not True: | ||||
checkout = update | ||||
for test in (checkout, 'default', 'tip'): | ||||
|
r9423 | if test is None: | ||
continue | ||||
|
r8800 | try: | ||
uprev = r.lookup(test) | ||||
break | ||||
|
r9423 | except error.RepoLookupError: | ||
|
r8800 | continue | ||
_update(r, uprev) | ||||
|
r15078 | def copystore(ui, srcrepo, destpath): | ||
'''copy files from store of srcrepo in destpath | ||||
returns destlock | ||||
''' | ||||
destlock = None | ||||
try: | ||||
hardlink = None | ||||
num = 0 | ||||
|
r15741 | srcpublishing = srcrepo.ui.configbool('phases', 'publish', True) | ||
|
r20089 | srcvfs = scmutil.vfs(srcrepo.sharedpath) | ||
dstvfs = scmutil.vfs(destpath) | ||||
|
r15078 | for f in srcrepo.store.copylist(): | ||
|
r15741 | if srcpublishing and f.endswith('phaseroots'): | ||
continue | ||||
|
r20089 | dstbase = os.path.dirname(f) | ||
if dstbase and not dstvfs.exists(dstbase): | ||||
dstvfs.mkdir(dstbase) | ||||
if srcvfs.exists(f): | ||||
if f.endswith('data'): | ||||
|
r15078 | # lock to avoid premature writing to the target | ||
|
r20091 | destlock = lock.lock(dstvfs, dstbase + "/lock") | ||
|
r20089 | hardlink, n = util.copyfiles(srcvfs.join(f), dstvfs.join(f), | ||
hardlink) | ||||
|
r15078 | num += n | ||
if hardlink: | ||||
ui.debug("linked %d files\n" % num) | ||||
else: | ||||
ui.debug("copied %d files\n" % num) | ||||
return destlock | ||||
|
r16705 | except: # re-raises | ||
|
r15078 | release(destlock) | ||
raise | ||||
|
r14607 | def clone(ui, peeropts, source, dest=None, pull=False, rev=None, | ||
update=True, stream=False, branch=None): | ||||
|
r2597 | """Make a copy of an existing repository. | ||
Create a copy of an existing repository in a new directory. The | ||||
source and destination are URLs, as passed to the repository | ||||
|
r17191 | function. Returns a pair of repository peers, the source and | ||
|
r2597 | newly created destination. | ||
The location of the source is added to the new repository's | ||||
.hg/hgrc file, as the default to be used for future pulls and | ||||
pushes. | ||||
If an exception is raised, the partly cloned/updated destination | ||||
repository will be deleted. | ||||
|
r2600 | |||
|
r2719 | Arguments: | ||
source: repository object or URL | ||||
|
r2597 | |||
dest: URL of destination repository to create (defaults to base | ||||
name of source repository) | ||||
pull: always pull from source repository, even in local case | ||||
|
r2621 | stream: stream raw data uncompressed from repository (fast over | ||
LAN, slow over WAN) | ||||
|
r2613 | |||
|
r2597 | rev: revision to clone up to (implies pull=True) | ||
update: update working directory after clone completes, if | ||||
|
r6526 | destination is local repository (True means update to default rev, | ||
anything else is treated as a revision) | ||||
|
r10379 | |||
branch: branches to clone | ||||
|
r2597 | """ | ||
|
r4478 | |||
|
r2719 | if isinstance(source, str): | ||
|
r6089 | origsource = ui.expandpath(source) | ||
|
r10379 | source, branch = parseurl(origsource, branch) | ||
|
r17191 | srcpeer = peer(ui, peeropts, source) | ||
|
r2719 | else: | ||
|
r17191 | srcpeer = source.peer() # in case we were called with a localrepo | ||
|
r11818 | branch = (None, branch or []) | ||
|
r17191 | origsource = source = srcpeer.url() | ||
rev, checkout = addbranchrevs(srcpeer, srcpeer, branch, rev) | ||||
|
r2719 | |||
|
r2597 | if dest is None: | ||
|
r2719 | dest = defaultdest(source) | ||
|
r3841 | ui.status(_("destination directory: %s\n") % dest) | ||
|
r9344 | else: | ||
dest = ui.expandpath(dest) | ||||
|
r2719 | |||
|
r14825 | dest = util.urllocalpath(dest) | ||
source = util.urllocalpath(source) | ||||
|
r2597 | |||
|
r17159 | if not dest: | ||
raise util.Abort(_("empty destination path is not valid")) | ||||
|
r2597 | if os.path.exists(dest): | ||
|
r7927 | if not os.path.isdir(dest): | ||
raise util.Abort(_("destination '%s' already exists") % dest) | ||||
elif os.listdir(dest): | ||||
raise util.Abort(_("destination '%s' is not empty") % dest) | ||||
|
r2597 | |||
|
r18441 | srclock = destlock = cleandir = None | ||
|
r17191 | srcrepo = srcpeer.local() | ||
|
r4915 | try: | ||
|
r14377 | abspath = origsource | ||
if islocal(origsource): | ||||
|
r14825 | abspath = os.path.abspath(util.urllocalpath(origsource)) | ||
|
r14377 | |||
|
r4915 | if islocal(dest): | ||
|
r18441 | cleandir = dest | ||
|
r2597 | |||
|
r4915 | copy = False | ||
|
r17194 | if (srcrepo and srcrepo.cancopy() and islocal(dest) | ||
|
r17671 | and not phases.hassecret(srcrepo)): | ||
|
r4915 | copy = not pull and not rev | ||
|
r2597 | |||
|
r4915 | if copy: | ||
try: | ||||
# we use a lock here because if we race with commit, we | ||||
# can end up with extra data in the cloned revlogs that's | ||||
# not pointed to by changesets, thus causing verify to | ||||
# fail | ||||
|
r14463 | srclock = srcrepo.lock(wait=False) | ||
|
r7640 | except error.LockError: | ||
|
r4915 | copy = False | ||
|
r2597 | |||
|
r4915 | if copy: | ||
|
r14463 | srcrepo.hook('preoutgoing', throw=True, source='clone') | ||
|
r15381 | hgdir = os.path.realpath(os.path.join(dest, ".hg")) | ||
|
r4915 | if not os.path.exists(dest): | ||
os.mkdir(dest) | ||||
|
r7935 | else: | ||
# only clean up directories we create ourselves | ||||
|
r18441 | cleandir = hgdir | ||
|
r5569 | try: | ||
|
r14463 | destpath = hgdir | ||
util.makedir(destpath, notindexed=True) | ||||
|
r5569 | except OSError, inst: | ||
if inst.errno == errno.EEXIST: | ||||
|
r18441 | cleandir = None | ||
|
r5569 | raise util.Abort(_("destination '%s' already exists") | ||
% dest) | ||||
raise | ||||
|
r2597 | |||
|
r15078 | destlock = copystore(ui, srcrepo, destpath) | ||
|
r2597 | |||
|
r17740 | # Recomputing branch cache might be slow on big repos, | ||
# so just copy it | ||||
dstcachedir = os.path.join(destpath, 'cache') | ||||
|
r20185 | srcbranchcache = srcrepo.sjoin('cache/branch2') | ||
dstbranchcache = os.path.join(dstcachedir, 'branch2') | ||||
|
r17740 | if os.path.exists(srcbranchcache): | ||
if not os.path.exists(dstcachedir): | ||||
os.mkdir(dstcachedir) | ||||
util.copyfile(srcbranchcache, dstbranchcache) | ||||
|
r4915 | # we need to re-init the repo after manually copying the data | ||
# into it | ||||
|
r17874 | destpeer = peer(srcrepo, peeropts, dest) | ||
|
r14463 | srcrepo.hook('outgoing', source='clone', | ||
|
r12144 | node=node.hex(node.nullid)) | ||
|
r4915 | else: | ||
|
r5569 | try: | ||
|
r17875 | destpeer = peer(srcrepo or ui, peeropts, dest, create=True) | ||
# only pass ui when no srcrepo | ||||
|
r5569 | except OSError, inst: | ||
if inst.errno == errno.EEXIST: | ||||
|
r18441 | cleandir = None | ||
|
r5569 | raise util.Abort(_("destination '%s' already exists") | ||
% dest) | ||||
raise | ||||
|
r2597 | |||
|
r4915 | revs = None | ||
if rev: | ||||
|
r17191 | if not srcpeer.capable('lookup'): | ||
|
r9171 | raise util.Abort(_("src repository does not support " | ||
"revision lookup and so doesn't " | ||||
"support clone by revision")) | ||||
|
r17191 | revs = [srcpeer.lookup(r) for r in rev] | ||
|
r8417 | checkout = revs[0] | ||
|
r17191 | if destpeer.local(): | ||
destpeer.local().clone(srcpeer, heads=revs, stream=stream) | ||||
elif srcrepo: | ||||
srcrepo.push(destpeer, revs=revs) | ||||
|
r4915 | else: | ||
raise util.Abort(_("clone from remote to remote not supported")) | ||||
|
r2597 | |||
|
r18441 | cleandir = None | ||
|
r2597 | |||
|
r16276 | # clone all bookmarks except divergent ones | ||
|
r17191 | destrepo = destpeer.local() | ||
if destrepo and srcpeer.capable("pushkey"): | ||||
rb = srcpeer.listkeys('bookmarks') | ||||
|
r17922 | marks = destrepo._bookmarks | ||
|
r15590 | for k, n in rb.iteritems(): | ||
try: | ||||
m = destrepo.lookup(n) | ||||
|
r17922 | marks[k] = m | ||
|
r15590 | except error.RepoLookupError: | ||
pass | ||||
if rb: | ||||
|
r17922 | marks.write() | ||
|
r17191 | elif srcrepo and destpeer.capable("pushkey"): | ||
|
r15590 | for k, n in srcrepo._bookmarks.iteritems(): | ||
|
r17191 | destpeer.pushkey('bookmarks', k, '', hex(n)) | ||
|
r15590 | |||
|
r17191 | if destrepo: | ||
|
r14463 | fp = destrepo.opener("hgrc", "w", text=True) | ||
|
r4915 | fp.write("[paths]\n") | ||
|
r15552 | u = util.url(abspath) | ||
u.passwd = None | ||||
defaulturl = str(u) | ||||
fp.write("default = %s\n" % defaulturl) | ||||
|
r4915 | fp.close() | ||
|
r5185 | |||
|
r15552 | destrepo.ui.setconfig('paths', 'default', defaulturl) | ||
|
r8814 | |||
|
r4915 | if update: | ||
|
r6526 | if update is not True: | ||
|
r17342 | checkout = srcpeer.lookup(update) | ||
|
r17867 | uprev = None | ||
|
r17882 | status = None | ||
|
r17867 | if checkout is not None: | ||
|
r5248 | try: | ||
|
r17867 | uprev = destrepo.lookup(checkout) | ||
|
r9423 | except error.RepoLookupError: | ||
|
r17867 | pass | ||
if uprev is None: | ||||
try: | ||||
uprev = destrepo._bookmarks['@'] | ||||
|
r17870 | update = '@' | ||
|
r17882 | bn = destrepo[uprev].branch() | ||
if bn == 'default': | ||||
status = _("updating to bookmark @\n") | ||||
else: | ||||
status = _("updating to bookmark @ on branch %s\n" | ||||
% bn) | ||||
|
r17867 | except KeyError: | ||
try: | ||||
uprev = destrepo.branchtip('default') | ||||
except error.RepoLookupError: | ||||
uprev = destrepo.lookup('tip') | ||||
|
r17882 | if not status: | ||
bn = destrepo[uprev].branch() | ||||
status = _("updating to branch %s\n") % bn | ||||
destrepo.ui.status(status) | ||||
|
r14463 | _update(destrepo, uprev) | ||
|
r17703 | if update in destrepo._bookmarks: | ||
bookmarks.setcurrent(destrepo, update) | ||||
|
r4915 | finally: | ||
|
r15908 | release(srclock, destlock) | ||
|
r18441 | if cleandir is not None: | ||
shutil.rmtree(cleandir, True) | ||||
|
r17191 | if srcpeer is not None: | ||
srcpeer.close() | ||||
|
r19313 | return srcpeer, destpeer | ||
|
r2775 | |||
|
r3316 | def _showstats(repo, stats): | ||
|
r9454 | repo.ui.status(_("%d files updated, %d files merged, " | ||
"%d files removed, %d files unresolved\n") % stats) | ||||
|
r3316 | |||
|
r17895 | def updaterepo(repo, node, overwrite): | ||
"""Update the working directory to node. | ||||
When overwrite is set, changes are clobbered, merged else | ||||
returns stats (see pydoc mercurial.merge.applyupdates)""" | ||||
return mergemod.update(repo, node, False, overwrite, None) | ||||
|
r2808 | def update(repo, node): | ||
"""update the working directory to node, merging linear changes""" | ||||
|
r17895 | stats = updaterepo(repo, node, False) | ||
|
r3316 | _showstats(repo, stats) | ||
if stats[3]: | ||||
|
r6518 | repo.ui.status(_("use 'hg resolve' to retry unresolved file merges\n")) | ||
|
r5635 | return stats[3] > 0 | ||
|
r2775 | |||
|
r7546 | # naming conflict in clone() | ||
_update = update | ||||
|
r4917 | def clean(repo, node, show_stats=True): | ||
|
r2808 | """forcibly switch the working directory to node, clobbering changes""" | ||
|
r17895 | stats = updaterepo(repo, node, True) | ||
|
r19332 | util.unlinkpath(repo.join('graftstate'), ignoremissing=True) | ||
|
r10282 | if show_stats: | ||
_showstats(repo, stats) | ||||
|
r5635 | return stats[3] > 0 | ||
|
r2775 | |||
|
r4917 | def merge(repo, node, force=None, remind=True): | ||
|
r13162 | """Branch merge with node, resolving changes. Return true if any | ||
unresolved conflicts.""" | ||||
|
r10651 | stats = mergemod.update(repo, node, True, force, False) | ||
|
r3316 | _showstats(repo, stats) | ||
if stats[3]: | ||||
|
r7821 | repo.ui.status(_("use 'hg resolve' to retry unresolved file merges " | ||
|
r12314 | "or 'hg update -C .' to abandon\n")) | ||
|
r3316 | elif remind: | ||
repo.ui.status(_("(branch merge, don't forget to commit)\n")) | ||||
|
r5635 | return stats[3] > 0 | ||
|
r2808 | |||
|
r12730 | def _incoming(displaychlist, subreporecurse, ui, repo, source, | ||
opts, buffered=False): | ||||
""" | ||||
Helper for incoming / gincoming. | ||||
displaychlist gets called with | ||||
(remoterepo, incomingchangesetlist, displayer) parameters, | ||||
and is supposed to contain only code that can't be unified. | ||||
""" | ||||
source, branches = parseurl(ui.expandpath(source), opts.get('branch')) | ||||
|
r14556 | other = peer(repo, opts, source) | ||
|
r14076 | ui.status(_('comparing with %s\n') % util.hidepassword(source)) | ||
|
r12730 | revs, checkout = addbranchrevs(repo, other, branches, opts.get('rev')) | ||
if revs: | ||||
revs = [other.lookup(rev) for rev in revs] | ||||
|
r14161 | other, chlist, cleanupfn = bundlerepo.getremotechanges(ui, repo, other, | ||
revs, opts["bundle"], opts["force"]) | ||||
try: | ||||
if not chlist: | ||||
ui.status(_("no changes found\n")) | ||||
return subreporecurse() | ||||
|
r12730 | |||
displayer = cmdutil.show_changeset(ui, other, opts, buffered) | ||||
displaychlist(other, chlist, displayer) | ||||
displayer.close() | ||||
finally: | ||||
|
r14161 | cleanupfn() | ||
|
r12730 | subreporecurse() | ||
return 0 # exit code is zero since we found incoming changes | ||||
|
r12273 | def incoming(ui, repo, source, opts): | ||
|
r12730 | def subreporecurse(): | ||
|
r12400 | ret = 1 | ||
if opts.get('subrepos'): | ||||
ctx = repo[None] | ||||
for subpath in sorted(ctx.substate): | ||||
sub = ctx.sub(subpath) | ||||
ret = min(ret, sub.incoming(ui, source, opts)) | ||||
return ret | ||||
|
r12730 | def display(other, chlist, displayer): | ||
limit = cmdutil.loglimit(opts) | ||||
|
r12273 | if opts.get('newest_first'): | ||
|
r12729 | chlist.reverse() | ||
|
r12273 | count = 0 | ||
|
r12729 | for n in chlist: | ||
|
r12273 | if limit is not None and count >= limit: | ||
break | ||||
parents = [p for p in other.changelog.parents(n) if p != nullid] | ||||
if opts.get('no_merges') and len(parents) == 2: | ||||
continue | ||||
count += 1 | ||||
displayer.show(other[n]) | ||||
|
r12730 | return _incoming(display, subreporecurse, ui, repo, source, opts) | ||
|
r12273 | |||
|
r12735 | def _outgoing(ui, repo, dest, opts): | ||
dest = ui.expandpath(dest or 'default-push', dest or 'default') | ||||
dest, branches = parseurl(dest, opts.get('branch')) | ||||
|
r14076 | ui.status(_('comparing with %s\n') % util.hidepassword(dest)) | ||
|
r12735 | revs, checkout = addbranchrevs(repo, repo, branches, opts.get('rev')) | ||
if revs: | ||||
|
r17198 | revs = [repo.lookup(rev) for rev in scmutil.revrange(repo, revs)] | ||
|
r12735 | |||
|
r14556 | other = peer(repo, opts, dest) | ||
|
r18493 | outgoing = discovery.findcommonoutgoing(repo.unfiltered(), other, revs, | ||
|
r15837 | force=opts.get('force')) | ||
o = outgoing.missing | ||||
|
r12735 | if not o: | ||
|
r17248 | scmutil.nochangesfound(repo.ui, repo, outgoing.excluded) | ||
|
r12735 | return None | ||
|
r14073 | return o | ||
|
r12735 | |||
|
r12271 | def outgoing(ui, repo, dest, opts): | ||
|
r12400 | def recurse(): | ||
ret = 1 | ||||
if opts.get('subrepos'): | ||||
ctx = repo[None] | ||||
for subpath in sorted(ctx.substate): | ||||
sub = ctx.sub(subpath) | ||||
ret = min(ret, sub.outgoing(ui, dest, opts)) | ||||
return ret | ||||
|
r12271 | limit = cmdutil.loglimit(opts) | ||
|
r12735 | o = _outgoing(ui, repo, dest, opts) | ||
if o is None: | ||||
|
r12400 | return recurse() | ||
|
r12271 | if opts.get('newest_first'): | ||
o.reverse() | ||||
displayer = cmdutil.show_changeset(ui, repo, opts) | ||||
count = 0 | ||||
for n in o: | ||||
if limit is not None and count >= limit: | ||||
break | ||||
parents = [p for p in repo.changelog.parents(n) if p != nullid] | ||||
if opts.get('no_merges') and len(parents) == 2: | ||||
continue | ||||
count += 1 | ||||
displayer.show(repo[n]) | ||||
displayer.close() | ||||
|
r12400 | recurse() | ||
return 0 # exit code is zero since we found outgoing changes | ||||
|
r12271 | |||
|
r4917 | def revert(repo, node, choose): | ||
|
r2808 | """revert changes to revision in node without updating dirstate""" | ||
|
r10651 | return mergemod.update(repo, node, False, True, choose)[3] > 0 | ||
|
r2778 | |||
def verify(repo): | ||||
"""verify the consistency of a repository""" | ||||
|
r10651 | return verifymod.verify(repo) | ||
|
r11273 | |||
def remoteui(src, opts): | ||||
'build a remote ui from ui or repo and opts' | ||||
|
r14952 | if util.safehasattr(src, 'baseui'): # looks like a repository | ||
|
r11273 | dst = src.baseui.copy() # drop repo-specific config | ||
src = src.ui # copy target options from repo | ||||
else: # assume it's a global ui object | ||||
dst = src.copy() # keep all global options | ||||
# copy ssh-specific options | ||||
for o in 'ssh', 'remotecmd': | ||||
v = opts.get(o) or src.config('ui', o) | ||||
if v: | ||||
dst.setconfig("ui", o, v) | ||||
# copy bundle-specific options | ||||
r = src.config('bundle', 'mainreporoot') | ||||
if r: | ||||
dst.setconfig('bundle', 'mainreporoot', r) | ||||
|
r13192 | # copy selected local settings to the remote ui | ||
|
r13314 | for sect in ('auth', 'hostfingerprints', 'http_proxy'): | ||
|
r11273 | for key, val in src.configitems(sect): | ||
dst.setconfig(sect, key, val) | ||||
|
r13192 | v = src.config('web', 'cacerts') | ||
if v: | ||||
|
r13231 | dst.setconfig('web', 'cacerts', util.expandpath(v)) | ||
|
r11273 | |||
return dst | ||||