This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3000

addremove: remove dry_run, similarity from scmutil.addremove
ClosedPublic

Authored by khanchi97 on Mar 31 2018, 2:27 PM.

Details

Reviewers
yuja
Group Reviewers
hg-reviewers
Commits
rHG14cd5290c4e6: addremove: remove dry_run, similarity from scmutil.addremove (API)

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

khanchi97 created this revision.Mar 31 2018, 2:27 PM
khanchi97 added a subscriber: yuja.Mar 31 2018, 2:37 PM

I ran all the tests those are related to addremove and they are passing.

yuja requested changes to this revision.Mar 31 2018, 9:56 PM

Sorry, I didn't notice that the opts dict carries extra options other
than subrepos, dry_run, and similarity. Because of that, my idea of
dropping opts turns out to be worse than the current state.

Maybe we can get rid of dry_run and similarity instead, but we'll
have to be careful since the default similarity value varies on command.

mercurial/commands.py
252

Oops, largefiles options in core.

This revision now requires changes to proceed.Mar 31 2018, 9:56 PM
khanchi97 retitled this revision from addremove: remove opts from scmutil.addremove to addremove: remove dry_run, similarity from scmutil.addremove.Apr 1 2018, 6:44 AM
khanchi97 updated this revision to Diff 7500.
khanchi97 added a comment.Apr 1 2018, 9:54 AM

okay, so I have sent another revision which removes dry_run and
similarity from scmutil.addremove

yuja requested changes to this revision.Apr 2 2018, 10:53 AM

Other than that, the patch looks good to me. Thanks!

contrib/perf.py
427–428

Here opts['dry_run'] must be set.

This revision now requires changes to proceed.Apr 2 2018, 10:53 AM
khanchi97 updated this revision to Diff 7523.Apr 2 2018, 5:26 PM
khanchi97 updated this revision to Diff 7524.Apr 2 2018, 5:29 PM
yuja accepted this revision.Apr 3 2018, 8:19 AM
This revision is now accepted and ready to land.Apr 3 2018, 8:19 AM
Closed by commit rHG14cd5290c4e6: addremove: remove dry_run, similarity from scmutil.addremove (API) (authored by khanchi97). · Explain WhyApr 3 2018, 8:48 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 7476

contrib/perf.py

# False)))) # False))))
timer, fm = gettimer(ui, opts) timer, fm = gettimer(ui, opts)
timer(lambda: sum(map(len, repo.status(unknown=opts['unknown'])))) timer(lambda: sum(map(len, repo.status(unknown=opts['unknown']))))
fm.end() fm.end()
@command('perfaddremove', formatteropts) @command('perfaddremove', formatteropts)
def perfaddremove(ui, repo, **opts): def perfaddremove(ui, repo, **opts):
timer, fm = gettimer(ui, opts) timer, fm = gettimer(ui, opts)
subrepos = opts.get('subrepos')
try: try:
oldquiet = repo.ui.quiet oldquiet = repo.ui.quiet
repo.ui.quiet = True repo.ui.quiet = True
matcher = scmutil.match(repo[None]) matcher = scmutil.match(repo[None])
timer(lambda: scmutil.addremove(repo, matcher, "", dry_run=True)) timer(lambda: scmutil.addremove(repo, matcher, "",
subrepos, dry_run=True))
yujaUnsubmitted
Not Done

Here opts['dry_run'] must be set.

yuja: Here opts['dry_run'] must be set.
finally: finally:
repo.ui.quiet = oldquiet repo.ui.quiet = oldquiet
fm.end() fm.end()
def clearcaches(cl): def clearcaches(cl):
# behave somewhat consistently across internal API changes # behave somewhat consistently across internal API changes
if util.safehasattr(cl, 'clearcaches'): if util.safehasattr(cl, 'clearcaches'):
cl.clearcaches() cl.clearcaches()

hgext/largefiles/overrides.py

installmatchandpatsfn was called. No-op if scmutil.matchandpats installmatchandpatsfn was called. No-op if scmutil.matchandpats
is its original function. is its original function.
Note that n calls to installmatchandpatsfn will require n calls Note that n calls to installmatchandpatsfn will require n calls
to restore the original matchfn.''' to restore the original matchfn.'''
scmutil.matchandpats = getattr(scmutil.matchandpats, 'oldmatchandpats', scmutil.matchandpats = getattr(scmutil.matchandpats, 'oldmatchandpats',
scmutil.matchandpats) scmutil.matchandpats)
def addlargefiles(ui, repo, isaddremove, matcher, **opts): def addlargefiles(ui, repo, isaddremove, matcher, dry_run, large, lfsize):
large = opts.get(r'large')
lfsize = lfutil.getminsize( lfsize = lfutil.getminsize(
ui, lfutil.islfilesrepo(repo), opts.get(r'lfsize')) ui, lfutil.islfilesrepo(repo), lfsize)
lfmatcher = None lfmatcher = None
if lfutil.islfilesrepo(repo): if lfutil.islfilesrepo(repo):
lfpats = ui.configlist(lfutil.longname, 'patterns') lfpats = ui.configlist(lfutil.longname, 'patterns')
if lfpats: if lfpats:
lfmatcher = matchmod.match(repo.root, '', list(lfpats)) lfmatcher = matchmod.match(repo.root, '', list(lfpats))
lfnames = [] lfnames = []
if ui.verbose or not exact: if ui.verbose or not exact:
ui.status(_('adding %s as a largefile\n') % name) ui.status(_('adding %s as a largefile\n') % name)
bad = [] bad = []
# Need to lock, otherwise there could be a race condition between # Need to lock, otherwise there could be a race condition between
# when standins are created and added to the repo. # when standins are created and added to the repo.
with repo.wlock(): with repo.wlock():
if not opts.get(r'dry_run'): if not dry_run:
standins = [] standins = []
lfdirstate = lfutil.openlfdirstate(ui, repo) lfdirstate = lfutil.openlfdirstate(ui, repo)
for f in lfnames: for f in lfnames:
standinname = lfutil.standin(f) standinname = lfutil.standin(f)
lfutil.writestandin(repo, standinname, hash='', lfutil.writestandin(repo, standinname, hash='',
executable=lfutil.getexecutable(repo.wjoin(f))) executable=lfutil.getexecutable(repo.wjoin(f)))
standins.append(standinname) standins.append(standinname)
if lfdirstate[f] == 'r': if lfdirstate[f] == 'r':
lfdirstate.normallookup(f) lfdirstate.normallookup(f)
else: else:
lfdirstate.add(f) lfdirstate.add(f)
lfdirstate.write() lfdirstate.write()
bad += [lfutil.splitstandin(f) bad += [lfutil.splitstandin(f)
for f in repo[None].add(standins) for f in repo[None].add(standins)
if f in m.files()] if f in m.files()]
added = [f for f in lfnames if f not in bad] added = [f for f in lfnames if f not in bad]
return added, bad return added, bad
def removelargefiles(ui, repo, isaddremove, matcher, dryrun, **opts): def removelargefiles(ui, repo, isaddremove, matcher, dryrun=None,
after = opts.get(r'after') after=None, force=None):
m = composelargefilematcher(matcher, repo[None].manifest()) m = composelargefilematcher(matcher, repo[None].manifest())
try: try:
repo.lfstatus = True repo.lfstatus = True
s = repo.status(match=m, clean=not isaddremove) s = repo.status(match=m, clean=not isaddremove)
finally: finally:
repo.lfstatus = False repo.lfstatus = False
manifest = repo[None].manifest() manifest = repo[None].manifest()
modified, added, deleted, clean = [[f for f in list modified, added, deleted, clean = [[f for f in list
raise error.Abort(_('--normal cannot be used with --large')) raise error.Abort(_('--normal cannot be used with --large'))
return orig(ui, repo, *pats, **opts) return orig(ui, repo, *pats, **opts)
def cmdutiladd(orig, ui, repo, matcher, prefix, explicitonly, **opts): def cmdutiladd(orig, ui, repo, matcher, prefix, explicitonly, **opts):
# The --normal flag short circuits this override # The --normal flag short circuits this override
if opts.get(r'normal'): if opts.get(r'normal'):
return orig(ui, repo, matcher, prefix, explicitonly, **opts) return orig(ui, repo, matcher, prefix, explicitonly, **opts)
ladded, lbad = addlargefiles(ui, repo, False, matcher, **opts) large, lfsize = opts.get(r'large'), opts.get(r'lfsize')
dry_run = opts.get(r'dry_run')
ladded, lbad = addlargefiles(ui, repo, False, matcher,
dry_run, large, lfsize)
normalmatcher = composenormalfilematcher(matcher, repo[None].manifest(), normalmatcher = composenormalfilematcher(matcher, repo[None].manifest(),
ladded) ladded)
bad = orig(ui, repo, normalmatcher, prefix, explicitonly, **opts) bad = orig(ui, repo, normalmatcher, prefix, explicitonly, **opts)
bad.extend(f for f in lbad) bad.extend(f for f in lbad)
return bad return bad
def cmdutilremove(orig, ui, repo, matcher, prefix, after, force, subrepos, def cmdutilremove(orig, ui, repo, matcher, prefix, after, force, subrepos,
def overridesummary(orig, ui, repo, *pats, **opts): def overridesummary(orig, ui, repo, *pats, **opts):
try: try:
repo.lfstatus = True repo.lfstatus = True
orig(ui, repo, *pats, **opts) orig(ui, repo, *pats, **opts)
finally: finally:
repo.lfstatus = False repo.lfstatus = False
def scmutiladdremove(orig, repo, matcher, prefix, opts=None, dry_run=None, def scmutiladdremove(orig, repo, matcher, prefix, subrepos, dry_run=None,
similarity=None): after=None, large=None, lfsize=None, similarity=None):
if opts is None:
opts = {}
if not lfutil.islfilesrepo(repo): if not lfutil.islfilesrepo(repo):
return orig(repo, matcher, prefix, opts, dry_run, similarity) return orig(repo, matcher, prefix, subrepos, dry_run,
similarity=similarity)
# Get the list of missing largefiles so we can remove them # Get the list of missing largefiles so we can remove them
lfdirstate = lfutil.openlfdirstate(repo.ui, repo) lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
unsure, s = lfdirstate.status(matchmod.always(repo.root, repo.getcwd()), unsure, s = lfdirstate.status(matchmod.always(repo.root, repo.getcwd()),
subrepos=[], ignored=False, clean=False, subrepos=[], ignored=False, clean=False,
unknown=False) unknown=False)
# Call into the normal remove code, but the removing of the standin, we want # Call into the normal remove code, but the removing of the standin, we want
# to have handled by original addremove. Monkey patching here makes sure # to have handled by original addremove. Monkey patching here makes sure
# we don't remove the standin in the largefiles code, preventing a very # we don't remove the standin in the largefiles code, preventing a very
# confused state later. # confused state later.
if s.deleted: if s.deleted:
m = copy.copy(matcher) m = copy.copy(matcher)
# The m._files and m._map attributes are not changed to the deleted list # The m._files and m._map attributes are not changed to the deleted list
# because that affects the m.exact() test, which in turn governs whether # because that affects the m.exact() test, which in turn governs whether
# or not the file name is printed, and how. Simply limit the original # or not the file name is printed, and how. Simply limit the original
# matches to those in the deleted status list. # matches to those in the deleted status list.
matchfn = m.matchfn matchfn = m.matchfn
m.matchfn = lambda f: f in s.deleted and matchfn(f) m.matchfn = lambda f: f in s.deleted and matchfn(f)
removelargefiles(repo.ui, repo, True, m, opts.get('dry_run'), removelargefiles(repo.ui, repo, True, m, dry_run, after=after)
**pycompat.strkwargs(opts))
# Call into the normal add code, and any files that *should* be added as # Call into the normal add code, and any files that *should* be added as
# largefiles will be # largefiles will be
added, bad = addlargefiles(repo.ui, repo, True, matcher, added, bad = addlargefiles(repo.ui, repo, True, matcher, large=large,
**pycompat.strkwargs(opts)) lfsize=lfsize, dry_run=dry_run)
# Now that we've handled largefiles, hand off to the original addremove # Now that we've handled largefiles, hand off to the original addremove
# function to take care of the rest. Make sure it doesn't do anything with # function to take care of the rest. Make sure it doesn't do anything with
# largefiles by passing a matcher that will ignore them. # largefiles by passing a matcher that will ignore them.
matcher = composenormalfilematcher(matcher, repo[None].manifest(), added) matcher = composenormalfilematcher(matcher, repo[None].manifest(), added)
return orig(repo, matcher, prefix, opts, dry_run, similarity) return orig(repo, matcher, prefix, subrepos, dry_run,
similarity=similarity)
# Calling purge with --all will cause the largefiles to be deleted. # Calling purge with --all will cause the largefiles to be deleted.
# Override repo.status to prevent this from happening. # Override repo.status to prevent this from happening.
def overridepurge(orig, ui, repo, *dirs, **opts): def overridepurge(orig, ui, repo, *dirs, **opts):
# XXX Monkey patching a repoview will not work. The assigned attribute will # XXX Monkey patching a repoview will not work. The assigned attribute will
# be set on the unfiltered repo, but we will only lookup attributes in the # be set on the unfiltered repo, but we will only lookup attributes in the
# unfiltered repo if the lookup in the repoview object itself fails. As the # unfiltered repo if the lookup in the repoview object itself fails. As the
# monkey patched method exists on the repoview class the lookup will not # monkey patched method exists on the repoview class the lookup will not

mercurial/cmdutil.py

return err return err
def commit(ui, repo, commitfunc, pats, opts): def commit(ui, repo, commitfunc, pats, opts):
'''commit the specified files or all outstanding changes''' '''commit the specified files or all outstanding changes'''
date = opts.get('date') date = opts.get('date')
if date: if date:
opts['date'] = dateutil.parsedate(date) opts['date'] = dateutil.parsedate(date)
message = logmessage(ui, opts) message = logmessage(ui, opts)
subrepos = opts.get('subrepos')
matcher = scmutil.match(repo[None], pats, opts) matcher = scmutil.match(repo[None], pats, opts)
dsguard = None dsguard = None
# extract addremove carefully -- this function can be called from a command # extract addremove carefully -- this function can be called from a command
# that doesn't support addremove # that doesn't support addremove
if opts.get('addremove'): if opts.get('addremove'):
dsguard = dirstateguard.dirstateguard(repo, 'commit') dsguard = dirstateguard.dirstateguard(repo, 'commit')
with dsguard or util.nullcontextmanager(): with dsguard or util.nullcontextmanager():
if dsguard: if dsguard:
if scmutil.addremove(repo, matcher, "", opts) != 0: if scmutil.addremove(repo, matcher, "", subrepos) != 0:
raise error.Abort( raise error.Abort(
_("failed to mark all new/missing files as added/removed")) _("failed to mark all new/missing files as added/removed"))
return commitfunc(ui, repo, message, matcher, opts) return commitfunc(ui, repo, message, matcher, opts)
def samefile(f, ctx1, ctx2): def samefile(f, ctx1, ctx2):
if f in ctx1.manifest(): if f in ctx1.manifest():
a = ctx1.filectx(f) a = ctx1.filectx(f)
files = set([fn for st in repo.status(base, old)[:3] files = set([fn for st in repo.status(base, old)[:3]
for fn in st]) for fn in st])
else: else:
files = set(old.files()) files = set(old.files())
# add/remove the files to the working copy if the "addremove" option # add/remove the files to the working copy if the "addremove" option
# was specified. # was specified.
matcher = scmutil.match(wctx, pats, opts) matcher = scmutil.match(wctx, pats, opts)
subrepos = opts.get('subrepos')
if (opts.get('addremove') if (opts.get('addremove')
and scmutil.addremove(repo, matcher, "", opts)): and scmutil.addremove(repo, matcher, "", subrepos)):
raise error.Abort( raise error.Abort(
_("failed to mark all new/missing files as added/removed")) _("failed to mark all new/missing files as added/removed"))
# Check subrepos. This depends on in-place wctx._status update in # Check subrepos. This depends on in-place wctx._status update in
# subrepo.precommit(). To minimize the risk of this hack, we do # subrepo.precommit(). To minimize the risk of this hack, we do
# nothing if .hgsub does not exist. # nothing if .hgsub does not exist.
if '.hgsub' in wctx or '.hgsub' in old: if '.hgsub' in wctx or '.hgsub' in old:
subs, commitsubs, newsubstate = subrepoutil.precommit( subs, commitsubs, newsubstate = subrepoutil.precommit(

mercurial/commands.py

$ hg status -C $ hg status -C
A foo.c A foo.c
foobar.c foobar.c
R foobar.c R foobar.c
Returns 0 if all files are successfully added. Returns 0 if all files are successfully added.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
dry_run = opts.get('dry_run')
subrepos, after = opts.get('subrepos'), opts.get('after')
large, lfsize = opts.get('large'), opts.get('lfsize')
yujaUnsubmitted
Not Done

Oops, largefiles options in core.

yuja: Oops, largefiles options in core.
try: try:
sim = float(opts.get('similarity') or 100) sim = float(opts.get('similarity') or 100)
except ValueError: except ValueError:
raise error.Abort(_('similarity must be a number')) raise error.Abort(_('similarity must be a number'))
if sim < 0 or sim > 100: if sim < 0 or sim > 100:
raise error.Abort(_('similarity must be between 0 and 100')) raise error.Abort(_('similarity must be between 0 and 100'))
matcher = scmutil.match(repo[None], pats, opts) matcher = scmutil.match(repo[None], pats, opts)
return scmutil.addremove(repo, matcher, "", opts, similarity=sim / 100.0) return scmutil.addremove(repo, matcher, "", subrepos, dry_run,
after, large, lfsize, similarity=sim / 100.0)
@command('^annotate|blame', @command('^annotate|blame',
[('r', 'rev', '', _('annotate the specified revision'), _('REV')), [('r', 'rev', '', _('annotate the specified revision'), _('REV')),
('', 'follow', None, ('', 'follow', None,
_('follow copies/renames and list the filename (DEPRECATED)')), _('follow copies/renames and list the filename (DEPRECATED)')),
('', 'no-follow', None, _("don't follow copies and renames")), ('', 'no-follow', None, _("don't follow copies and renames")),
('a', 'text', None, _('treat all files as text')), ('a', 'text', None, _('treat all files as text')),
('u', 'user', None, _('list the author (long with -v)')), ('u', 'user', None, _('list the author (long with -v)')),

mercurial/scmutil.py

obsolete.createmarkers(repo, rels, operation=operation, obsolete.createmarkers(repo, rels, operation=operation,
metadata=metadata) metadata=metadata)
else: else:
from . import repair # avoid import cycle from . import repair # avoid import cycle
tostrip = list(replacements) tostrip = list(replacements)
if tostrip: if tostrip:
repair.delayedstrip(repo.ui, repo, tostrip, operation) repair.delayedstrip(repo.ui, repo, tostrip, operation)
def addremove(repo, matcher, prefix, opts=None, dry_run=None, similarity=None): def addremove(repo, matcher, prefix, subrepos, dry_run=None,
if opts is None: after=None, large=None, lfsize=None, similarity=None):
opts = {}
m = matcher m = matcher
if dry_run is None:
dry_run = opts.get('dry_run')
if similarity is None:
similarity = float(opts.get('similarity') or 0)
ret = 0 ret = 0
join = lambda f: os.path.join(prefix, f) join = lambda f: os.path.join(prefix, f)
wctx = repo[None] wctx = repo[None]
for subpath in sorted(wctx.substate): for subpath in sorted(wctx.substate):
submatch = matchmod.subdirmatcher(subpath, m) submatch = matchmod.subdirmatcher(subpath, m)
if opts.get('subrepos') or m.exact(subpath) or any(submatch.files()): if subrepos or m.exact(subpath) or any(submatch.files()):
sub = wctx.sub(subpath) sub = wctx.sub(subpath)
try: try:
if sub.addremove(submatch, prefix, opts, dry_run, similarity): if sub.addremove(submatch, prefix, subrepos, dry_run, after,
large, lfsize, similarity):
ret = 1 ret = 1
except error.LookupError: except error.LookupError:
repo.ui.status(_("skipping missing subrepository: %s\n") repo.ui.status(_("skipping missing subrepository: %s\n")
% join(subpath)) % join(subpath))
rejected = [] rejected = []
def badfn(f, msg): def badfn(f, msg):
if f in m.files(): if f in m.files():

mercurial/subrepo.py

This may be a no-op on some systems. This may be a no-op on some systems.
""" """
raise NotImplementedError raise NotImplementedError
def add(self, ui, match, prefix, explicitonly, **opts): def add(self, ui, match, prefix, explicitonly, **opts):
return [] return []
def addremove(self, matcher, prefix, opts, dry_run, similarity): def addremove(self, matcher, prefix, subrepos, dry_run=None,
after=None, large=None, lfsize=None, similarity=None):
self.ui.warn("%s: %s" % (prefix, _("addremove is not supported"))) self.ui.warn("%s: %s" % (prefix, _("addremove is not supported")))
return 1 return 1
def cat(self, match, fm, fntemplate, prefix, **opts): def cat(self, match, fm, fntemplate, prefix, **opts):
return 1 return 1
def status(self, rev2, **opts): def status(self, rev2, **opts):
return scmutil.status([], [], [], [], [], [], []) return scmutil.status([], [], [], [], [], [], [])
@annotatesubrepoerror @annotatesubrepoerror
def add(self, ui, match, prefix, explicitonly, **opts): def add(self, ui, match, prefix, explicitonly, **opts):
return cmdutil.add(ui, self._repo, match, return cmdutil.add(ui, self._repo, match,
self.wvfs.reljoin(prefix, self._path), self.wvfs.reljoin(prefix, self._path),
explicitonly, **opts) explicitonly, **opts)
@annotatesubrepoerror @annotatesubrepoerror
def addremove(self, m, prefix, opts, dry_run, similarity): def addremove(self, m, prefix, subrepos, dry_run=None, after=None,
large=None, lfsize=None, similarity=None):
# In the same way as sub directories are processed, once in a subrepo, # In the same way as sub directories are processed, once in a subrepo,
# always entry any of its subrepos. Don't corrupt the options that will # always entry any of its subrepos. Don't corrupt the options that will
# be used to process sibling subrepos however. # be used to process sibling subrepos however.
opts = copy.copy(opts) subrepos = True
opts['subrepos'] = True
return scmutil.addremove(self._repo, m, return scmutil.addremove(self._repo, m,
self.wvfs.reljoin(prefix, self._path), opts, self.wvfs.reljoin(prefix, self._path),
dry_run, similarity) subrepos, dry_run, after, large, lfsize,
similarity)
@annotatesubrepoerror @annotatesubrepoerror
def cat(self, match, fm, fntemplate, prefix, **opts): def cat(self, match, fm, fntemplate, prefix, **opts):
rev = self._state[1] rev = self._state[1]
ctx = self._repo[rev] ctx = self._repo[rev]
return cmdutil.cat(self.ui, self._repo, ctx, match, fm, fntemplate, return cmdutil.cat(self.ui, self._repo, ctx, match, fm, fntemplate,
prefix, **opts) prefix, **opts)