def _outgoing(ui, repo, dest, opts): dest = ui.expandpath(dest or "default-push", dest or "default") dest, branches = parseurl(dest, opts.get("branch")) ui.status(_("comparing with %s\n") % util.hidepassword(dest)) revs, checkout = addbranchrevs(repo, repo, branches, opts.get("rev")) if revs: revs = [repo.lookup(rev) for rev in scmutil.revrange(repo, revs)] other = peer(repo, opts, dest) outgoing = discovery.findcommonoutgoing(repo.unfiltered(), other, revs, force=opts.get("force")) o = outgoing.missing if not o: scmutil.nochangesfound(repo.ui, repo, outgoing.excluded) return o, other
def _outgoing(ui, repo, dest, opts): dest = ui.expandpath(dest or 'default-push', dest or 'default') dest, branches = parseurl(dest, opts.get('branch')) ui.status(_('comparing with %s\n') % util.hidepassword(dest)) revs, checkout = addbranchrevs(repo, repo, branches, opts.get('rev')) if revs: revs = [repo.lookup(rev) for rev in scmutil.revrange(repo, revs)] other = peer(repo, opts, dest) outgoing = discovery.findcommonoutgoing(repo.unfiltered(), other, revs, force=opts.get('force')) o = outgoing.missing if not o: scmutil.nochangesfound(repo.ui, repo, outgoing.excluded) return o, other
def walkchangerevs(repo, match, opts, prepare): '''Iterate over files and the revs in which they changed. Callers most commonly need to iterate backwards over the history in which they are interested. Doing so has awful (quadratic-looking) performance, so we use iterators in a "windowed" way. We walk a window of revisions in the desired order. Within the window, we first walk forwards to gather data, then in the desired order (usually backwards) to display it. This function returns an iterator yielding contexts. Before yielding each context, the iterator will first call the prepare function on each context in the window in forward order.''' def increasing_windows(start, end, windowsize=8, sizelimit=512): if start < end: while start < end: yield start, min(windowsize, end - start) start += windowsize if windowsize < sizelimit: windowsize *= 2 else: while start > end: yield start, min(windowsize, start - end - 1) start -= windowsize if windowsize < sizelimit: windowsize *= 2 follow = opts.get('follow') or opts.get('follow_first') if not len(repo): return [] if follow: defrange = '%s:0' % repo['.'].rev() else: defrange = '-1:0' revs = scmutil.revrange(repo, opts['rev'] or [defrange]) if not revs: return [] wanted = set() slowpath = match.anypats() or (match.files() and opts.get('removed')) fncache = {} change = util.cachefunc(repo.changectx) # First step is to fill wanted, the set of revisions that we want to yield. # When it does not induce extra cost, we also fill fncache for revisions in # wanted: a cache of filenames that were changed (ctx.files()) and that # match the file filtering conditions. if not slowpath and not match.files(): # No files, no patterns. Display all revs. wanted = set(revs) copies = [] if not slowpath: # We only have to read through the filelog to find wanted revisions minrev, maxrev = min(revs), max(revs) def filerevgen(filelog, last): """ Only files, no patterns. Check the history of each file. Examines filelog entries within minrev, maxrev linkrev range Returns an iterator yielding (linkrev, parentlinkrevs, copied) tuples in backwards order """ cl_count = len(repo) revs = [] for j in xrange(0, last + 1): linkrev = filelog.linkrev(j) if linkrev < minrev: continue # only yield rev for which we have the changelog, it can # happen while doing "hg log" during a pull or commit if linkrev >= cl_count: break parentlinkrevs = [] for p in filelog.parentrevs(j): if p != nullrev: parentlinkrevs.append(filelog.linkrev(p)) n = filelog.node(j) revs.append((linkrev, parentlinkrevs, follow and filelog.renamed(n))) return reversed(revs) def iterfiles(): for filename in match.files(): yield filename, None for filename_node in copies: yield filename_node for file_, node in iterfiles(): filelog = repo.file(file_) if not len(filelog): if node is None: # A zero count may be a directory or deleted file, so # try to find matching entries on the slow path. if follow: raise util.Abort( _('cannot follow nonexistent file: "%s"') % file_) slowpath = True break else: continue if node is None: last = len(filelog) - 1 else: last = filelog.rev(node) # keep track of all ancestors of the file ancestors = set([filelog.linkrev(last)]) # iterate from latest to oldest revision for rev, flparentlinkrevs, copied in filerevgen(filelog, last): if not follow: if rev > maxrev: continue else: # Note that last might not be the first interesting # rev to us: # if the file has been changed after maxrev, we'll # have linkrev(last) > maxrev, and we still need # to explore the file graph if rev not in ancestors: continue # XXX insert 1327 fix here if flparentlinkrevs: ancestors.update(flparentlinkrevs) fncache.setdefault(rev, []).append(file_) wanted.add(rev) if copied: copies.append(copied) if slowpath: # We have to read the changelog to match filenames against # changed files if follow: raise util.Abort( _('can only follow copies/renames for explicit ' 'filenames')) # The slow path checks files modified in every changeset. for i in sorted(revs): ctx = change(i) matches = filter(match, ctx.files()) if matches: fncache[i] = matches wanted.add(i) class followfilter(object): def __init__(self, onlyfirst=False): self.startrev = nullrev self.roots = set() self.onlyfirst = onlyfirst def match(self, rev): def realparents(rev): if self.onlyfirst: return repo.changelog.parentrevs(rev)[0:1] else: return filter(lambda x: x != nullrev, repo.changelog.parentrevs(rev)) if self.startrev == nullrev: self.startrev = rev return True if rev > self.startrev: # forward: all descendants if not self.roots: self.roots.add(self.startrev) for parent in realparents(rev): if parent in self.roots: self.roots.add(rev) return True else: # backwards: all parents if not self.roots: self.roots.update(realparents(self.startrev)) if rev in self.roots: self.roots.remove(rev) self.roots.update(realparents(rev)) return True return False # it might be worthwhile to do this in the iterator if the rev range # is descending and the prune args are all within that range for rev in opts.get('prune', ()): rev = repo.changelog.rev(repo.lookup(rev)) ff = followfilter() stop = min(revs[0], revs[-1]) for x in xrange(rev, stop - 1, -1): if ff.match(x): wanted.discard(x) # Now that wanted is correctly initialized, we can iterate over the # revision range, yielding only revisions in wanted. def iterate(): if follow and not match.files(): ff = followfilter(onlyfirst=opts.get('follow_first')) def want(rev): return ff.match(rev) and rev in wanted else: def want(rev): return rev in wanted for i, window in increasing_windows(0, len(revs)): nrevs = [rev for rev in revs[i:i + window] if want(rev)] for rev in sorted(nrevs): fns = fncache.get(rev) ctx = change(rev) if not fns: def fns_generator(): for f in ctx.files(): if match(f): yield f fns = fns_generator() prepare(ctx, fns) for rev in nrevs: yield change(rev) return iterate()
def walkchangerevs(repo, match, opts, prepare): '''Iterate over files and the revs in which they changed. Callers most commonly need to iterate backwards over the history in which they are interested. Doing so has awful (quadratic-looking) performance, so we use iterators in a "windowed" way. We walk a window of revisions in the desired order. Within the window, we first walk forwards to gather data, then in the desired order (usually backwards) to display it. This function returns an iterator yielding contexts. Before yielding each context, the iterator will first call the prepare function on each context in the window in forward order.''' def increasing_windows(start, end, windowsize=8, sizelimit=512): if start < end: while start < end: yield start, min(windowsize, end - start) start += windowsize if windowsize < sizelimit: windowsize *= 2 else: while start > end: yield start, min(windowsize, start - end - 1) start -= windowsize if windowsize < sizelimit: windowsize *= 2 follow = opts.get('follow') or opts.get('follow_first') if not len(repo): return [] if follow: defrange = '%s:0' % repo['.'].rev() else: defrange = '-1:0' revs = scmutil.revrange(repo, opts['rev'] or [defrange]) if not revs: return [] wanted = set() slowpath = match.anypats() or (match.files() and opts.get('removed')) fncache = {} change = util.cachefunc(repo.changectx) # First step is to fill wanted, the set of revisions that we want to yield. # When it does not induce extra cost, we also fill fncache for revisions in # wanted: a cache of filenames that were changed (ctx.files()) and that # match the file filtering conditions. if not slowpath and not match.files(): # No files, no patterns. Display all revs. wanted = set(revs) copies = [] if not slowpath: # We only have to read through the filelog to find wanted revisions minrev, maxrev = min(revs), max(revs) def filerevgen(filelog, last): """ Only files, no patterns. Check the history of each file. Examines filelog entries within minrev, maxrev linkrev range Returns an iterator yielding (linkrev, parentlinkrevs, copied) tuples in backwards order """ cl_count = len(repo) revs = [] for j in xrange(0, last + 1): linkrev = filelog.linkrev(j) if linkrev < minrev: continue # only yield rev for which we have the changelog, it can # happen while doing "hg log" during a pull or commit if linkrev >= cl_count: break parentlinkrevs = [] for p in filelog.parentrevs(j): if p != nullrev: parentlinkrevs.append(filelog.linkrev(p)) n = filelog.node(j) revs.append((linkrev, parentlinkrevs, follow and filelog.renamed(n))) return reversed(revs) def iterfiles(): for filename in match.files(): yield filename, None for filename_node in copies: yield filename_node for file_, node in iterfiles(): filelog = repo.file(file_) if not len(filelog): if node is None: # A zero count may be a directory or deleted file, so # try to find matching entries on the slow path. if follow: raise util.Abort( _('cannot follow nonexistent file: "%s"') % file_) slowpath = True break else: continue if node is None: last = len(filelog) - 1 else: last = filelog.rev(node) # keep track of all ancestors of the file ancestors = set([filelog.linkrev(last)]) # iterate from latest to oldest revision for rev, flparentlinkrevs, copied in filerevgen(filelog, last): if not follow: if rev > maxrev: continue else: # Note that last might not be the first interesting # rev to us: # if the file has been changed after maxrev, we'll # have linkrev(last) > maxrev, and we still need # to explore the file graph if rev not in ancestors: continue # XXX insert 1327 fix here if flparentlinkrevs: ancestors.update(flparentlinkrevs) fncache.setdefault(rev, []).append(file_) wanted.add(rev) if copied: copies.append(copied) if slowpath: # We have to read the changelog to match filenames against # changed files if follow: raise util.Abort(_('can only follow copies/renames for explicit ' 'filenames')) # The slow path checks files modified in every changeset. for i in sorted(revs): ctx = change(i) matches = filter(match, ctx.files()) if matches: fncache[i] = matches wanted.add(i) class followfilter(object): def __init__(self, onlyfirst=False): self.startrev = nullrev self.roots = set() self.onlyfirst = onlyfirst def match(self, rev): def realparents(rev): if self.onlyfirst: return repo.changelog.parentrevs(rev)[0:1] else: return filter(lambda x: x != nullrev, repo.changelog.parentrevs(rev)) if self.startrev == nullrev: self.startrev = rev return True if rev > self.startrev: # forward: all descendants if not self.roots: self.roots.add(self.startrev) for parent in realparents(rev): if parent in self.roots: self.roots.add(rev) return True else: # backwards: all parents if not self.roots: self.roots.update(realparents(self.startrev)) if rev in self.roots: self.roots.remove(rev) self.roots.update(realparents(rev)) return True return False # it might be worthwhile to do this in the iterator if the rev range # is descending and the prune args are all within that range for rev in opts.get('prune', ()): rev = repo.changelog.rev(repo.lookup(rev)) ff = followfilter() stop = min(revs[0], revs[-1]) for x in xrange(rev, stop - 1, -1): if ff.match(x): wanted.discard(x) # Now that wanted is correctly initialized, we can iterate over the # revision range, yielding only revisions in wanted. def iterate(): if follow and not match.files(): ff = followfilter(onlyfirst=opts.get('follow_first')) def want(rev): return ff.match(rev) and rev in wanted else: def want(rev): return rev in wanted for i, window in increasing_windows(0, len(revs)): nrevs = [rev for rev in revs[i:i + window] if want(rev)] for rev in sorted(nrevs): fns = fncache.get(rev) ctx = change(rev) if not fns: def fns_generator(): for f in ctx.files(): if match(f): yield f fns = fns_generator() prepare(ctx, fns) for rev in nrevs: yield change(rev) return iterate()