def _includeunknownfiles(repo, pats, opts, extra):
s = repo.status(match=scmutil.match(repo[None], pats, opts), unknown=True)
if s.unknown:
extra["shelve_unknown"] = "\0".join(s.unknown)
repo[None].add(s.unknown)
def _prefetch(self, revs, base=None, pats=None, opts=None, matcher=None):
fallbackpath = self.fallbackpath
if fallbackpath:
# If we know a rev is on the server, we should fetch the server
# version of those files, since our local file versions might
# become obsolete if the local commits are stripped.
with progress.spinner(self.ui, _("finding outgoing revisions")):
localrevs = self.revs("outgoing(%s)", fallbackpath)
if base is not None and base != nullrev:
serverbase = list(
self.revs("first(reverse(::%s) - %ld)", base, localrevs)
)
if serverbase:
base = serverbase[0]
else:
localrevs = self
mfl = self.manifestlog
if base is not None:
mfdict = mfl[self[base].manifestnode()].read()
skip = set(iteritems(mfdict))
else:
skip = set()
# Copy the skip set to start large and avoid constant resizing,
# and since it's likely to be very similar to the prefetch set.
files = skip.copy()
serverfiles = skip.copy()
visited = set()
visited.add(nullid)
with progress.bar(self.ui, _("prefetching"), total=len(revs)) as prog:
for rev in sorted(revs):
ctx = self[rev]
if pats:
m = scmutil.match(ctx, pats, opts)
if matcher is None:
matcher = self.maybesparsematch(rev)
mfnode = ctx.manifestnode()
mfctx = mfl[mfnode]
# Decompressing manifests is expensive.
# When possible, only read the deltas.
p1, p2 = mfctx.parents
if p1 in visited and p2 in visited:
mfdict = mfctx.readnew()
else:
mfdict = mfctx.read()
diff = iteritems(mfdict)
if pats:
diff = (pf for pf in diff if m(pf[0]))
if matcher:
diff = (pf for pf in diff if matcher(pf[0]))
if rev not in localrevs:
serverfiles.update(diff)
else:
files.update(diff)
visited.add(mfctx.node())
prog.value += 1
files.difference_update(skip)
serverfiles.difference_update(skip)
# Fetch files known to be on the server
if serverfiles:
results = [(path, hex(fnode)) for (path, fnode) in serverfiles]
self.fileservice.prefetch(results, force=True)
# Fetch files that may or may not be on the server
if files:
results = [(path, hex(fnode)) for (path, fnode) in files]
self.fileservice.prefetch(results)
def interactivecommitfunc(ui, repo, *pats, **opts):
match = scmutil.match(repo["."], pats, {})
message = opts["message"]
return commitfunc(ui, repo, message, match, opts)
def absorb(ui, repo, stack=None, targetctx=None, pats=None, opts=None):
"""pick fixup chunks from targetctx, apply them to stack.
if targetctx is None, the working copy context will be used.
if stack is None, the current draft stack will be used.
return fixupstate.
"""
if stack is None:
limit = ui.configint("absorb", "maxstacksize", 50)
stack = getdraftstack(repo["."], limit)
if limit and len(stack) >= limit:
ui.warn(
_("absorb: only the recent %d changesets will " "be analysed\n") % limit
)
if not stack:
raise error.Abort(_("no changeset to change"))
if targetctx is None: # default to working copy
targetctx = repo[None]
if pats is None:
pats = ()
if opts is None:
opts = {}
state = fixupstate(stack, ui=ui, opts=opts)
matcher = scmutil.match(targetctx, pats, opts)
if opts.get("interactive"):
diff = patch.diff(repo, stack[-1], targetctx, matcher)
origchunks = patch.parsepatch(diff)
chunks = cmdutil.recordfilter(ui, origchunks)[0]
targetctx = overlaydiffcontext(stack[-1], chunks)
fm = None
if not (ui.quiet and opts.get("apply_changes")) and not opts.get("edit_lines"):
fm = ui.formatter("absorb", opts)
state.diffwith(targetctx, matcher, fm)
if fm is not None and state.ctxaffected:
fm.startitem()
count = len(state.ctxaffected)
fm.write(
"count",
_n("\n%d changeset affected\n", "\n%d changesets affected\n", count),
count,
)
fm.data(linetype="summary")
for ctx in reversed(stack):
if ctx not in state.ctxaffected:
continue
fm.startitem()
fm.context(ctx=ctx)
fm.data(linetype="changeset")
fm.write("node", "%-7.7s ", ctx.hex(), label="absorb.node")
descfirstline = ctx.description().splitlines()[0]
fm.write("descfirstline", "%s\n", descfirstline, label="absorb.description")
fm.end()
if not opts.get("edit_lines") and not any(
f.fixups for f in state.fixupmap.values()
):
ui.write(_("nothing to absorb\n"))
elif not opts.get("dry_run"):
if not opts.get("apply_changes"):
if ui.promptchoice("apply changes (yn)? $$ &Yes $$ &No", default=0):
raise error.Abort(_("absorb cancelled\n"))
state.apply()
state.commit()
state.printchunkstats()
return state
def perfwalk(ui, repo, *pats, **opts):
timer, fm = gettimer(ui, opts)
m = scmutil.match(repo[None], pats, {})
timer(lambda: len(
list(set().union(*repo.dirstate.status(m, False, True, False)))))
fm.end()
def _amend(orig, ui, repo, old, extra, pats, opts):
"""Wraps amend to collect copytrace data on amend
If a file is created in one commit, modified in a subsequent commit, and
then renamed or copied by amending the original commit, restacking the
commits that modify the file will fail:
file modified here B B' restack of B to B' will fail
| :
file created here A --> A' file renamed in amended commit
| /
o --
This function collects information about copies and renames from amend
commits, and saves it for use during rebases onto the amend commit. This
lets rebases onto files that been renamed or copied in an amend commit
work without conflicts.
This function collects the copytrace information from the working copy and
stores it against the amended commit in a separate dbm file. Later,
in _domergecopies, this information will be merged with the rebase
copytrace data to incorporate renames and copies made during the amend.
"""
# Check if amend copytracing has been disabled.
if not ui.configbool("copytrace", "enableamendcopytrace"):
return orig(ui, repo, old, extra, pats, opts)
# Need to get the amend-copies before calling the command because files from
# the working copy will be used during the amend.
wctx = repo[None]
# Find the amend-copies.
matcher = scmutil.match(wctx, pats, opts)
amend_copies = copiesmod.pathcopies(old, wctx, matcher)
# Finally, invoke the command.
node = orig(ui, repo, old, extra, pats, opts)
amended_ctx = repo[node]
# Store the amend-copies against the amended context.
if amend_copies:
db, error = opendbm(repo, "c")
if db is None:
# Database locked, can't record these amend-copies.
ui.log("copytrace", "Failed to open amendcopytrace db: %s" % error)
return node
# Merge in any existing amend copies from any previous amends.
try:
orig_data = db[old.node()]
except KeyError:
orig_data = "{}"
except error as e:
ui.log(
"copytrace",
"Failed to read key %s from amendcopytrace db: %s" %
(old.hex(), e),
)
return node
orig_encoded = json.loads(orig_data)
orig_amend_copies = dict(
(k.decode("base64"), v.decode("base64"))
for (k, v) in pycompat.iteritems(orig_encoded))
# Copytrace information is not valid if it refers to a file that
# doesn't exist in a commit. We need to update or remove entries
# that refer to files that might have only existed in the previous
# amend commit.
#
# Find chained copies and renames (a -> b -> c) and collapse them to
# (a -> c). Delete the entry for b if this was a rename.
for dst, src in pycompat.iteritems(amend_copies):
if src in orig_amend_copies:
amend_copies[dst] = orig_amend_copies[src]
if src not in amended_ctx:
del orig_amend_copies[src]
# Copy any left over copies from the previous context.
for dst, src in pycompat.iteritems(orig_amend_copies):
if dst not in amend_copies:
amend_copies[dst] = src
# Write out the entry for the new amend commit.
encoded = dict((k.encode("base64"), v.encode("base64"))
for (k, v) in pycompat.iteritems(amend_copies))
db[node] = json.dumps(encoded)
try:
db.close()
except Exception as e:
# Database corruption. Not much we can do, so just log.
ui.log("copytrace", "Failed to close amendcopytrace db: %s" % e)
return node
def _prefetch(self, revs, base=None, pats=None, opts=None, matcher=None):
fallbackpath = self.fallbackpath
if fallbackpath:
# If we know a rev is on the server, we should fetch the server
# version of those files, since our local file versions might
# become obsolete if the local commits are stripped.
localrevs = self.revs("draft()")
if base is not None and base != nullrev:
serverbase = list(
self.revs("first(reverse(::%s) - %ld)", base, localrevs)
)
if serverbase:
base = serverbase[0]
else:
localrevs = self
mfl = self.manifestlog
if base is not None:
mfdict = mfl[self[base].manifestnode()].read()
skip = set(iteritems(mfdict))
else:
skip = set()
# Copy the skip set to start large and avoid constant resizing,
# and since it's likely to be very similar to the prefetch set.
files = skip.copy()
serverfiles = skip.copy()
visited = set()
visited.add(nullid)
with progress.bar(self.ui, _("prefetching"), total=len(revs)) as prog:
for rev in sorted(revs):
ctx = self[rev]
if pats:
m = scmutil.match(ctx, pats, opts)
elif matcher is None:
matcher = self.maybesparsematch(rev)
mfnode = ctx.manifestnode()
mfctx = mfl[mfnode]
mf = mfctx.read()
diff = []
if pats:
diff.extend(iteritems(mf.matches(m)))
if matcher:
diff.extend(iteritems(mf.matches(matcher)))
if not pats and not matcher:
diff.extend(iteritems(mf))
if rev not in localrevs:
serverfiles.update(diff)
else:
files.update(diff)
visited.add(mfctx.node())
prog.value += 1
files.difference_update(skip)
serverfiles.difference_update(skip)
# Fetch files known to be on the server
if serverfiles:
results = [(path, hex(fnode)) for (path, fnode) in serverfiles]
self.fileservice.prefetch(results, force=True)
# Fetch files that may or may not be on the server
if files:
results = [(path, hex(fnode)) for (path, fnode) in files]
self.fileservice.prefetch(results)