This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5904

largefiles: use uipathfn instead of match.{rel,uipath}() (API)
ClosedPublic

Authored by martinvonz on Feb 8 2019, 2:15 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGf164076427b2: largefiles: use uipathfn instead of match.{rel,uipath}() (API)
Summary

All callers now pass in a uipathfn, so we can just use that instead of
choosing the right match function. This also means that when we make
add/remove respect ui.relative-paths, it will work for largefiles too.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

martinvonz created this revision.Feb 8 2019, 2:15 PM
martinvonz retitled this revision from largefiles: use uipathfn instead of match.{rel,uipath}() to largefiles: use uipathfn instead of match.{rel,uipath}() (API).Feb 8 2019, 3:18 PM
martinvonz updated this revision to Diff 13971.Feb 9 2019, 5:21 PM
martinvonz updated this revision to Diff 13976.Feb 9 2019, 5:25 PM
Closed by commit rHGf164076427b2: largefiles: use uipathfn instead of match.{rel,uipath}() (API) (authored by martinvonz). · Explain WhyFeb 9 2019, 10:40 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/largefiles/overrides.py (33 lines)

Diff 13971

hgext/largefiles/overrides.py

manifest or f in excluded) manifest or f in excluded)
m._files = [lf for lf in m._files if notlfile(lf)] m._files = [lf for lf in m._files if notlfile(lf)]
m._fileset = set(m._files) m._fileset = set(m._files)
m.always = lambda: False m.always = lambda: False
origmatchfn = m.matchfn origmatchfn = m.matchfn
m.matchfn = lambda f: notlfile(f) and origmatchfn(f) m.matchfn = lambda f: notlfile(f) and origmatchfn(f)
return m return m
def addlargefiles(ui, repo, isaddremove, matcher, **opts): def addlargefiles(ui, repo, isaddremove, matcher, uipathfn, **opts):
large = opts.get(r'large') large = opts.get(r'large')
lfsize = lfutil.getminsize( lfsize = lfutil.getminsize(
ui, lfutil.islfilesrepo(repo), opts.get(r'lfsize')) ui, lfutil.islfilesrepo(repo), opts.get(r'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 = []
m = matcher m = matcher
wctx = repo[None] wctx = repo[None]
for f in wctx.walk(matchmod.badmatch(m, lambda x, y: None)): for f in wctx.walk(matchmod.badmatch(m, lambda x, y: None)):
exact = m.exact(f) exact = m.exact(f)
lfile = lfutil.standin(f) in wctx lfile = lfutil.standin(f) in wctx
nfile = f in wctx nfile = f in wctx
exists = lfile or nfile exists = lfile or nfile
# addremove in core gets fancy with the name, add doesn't
if isaddremove:
name = m.uipath(f)
else:
name = m.rel(f)
# Don't warn the user when they attempt to add a normal tracked file. # Don't warn the user when they attempt to add a normal tracked file.
# The normal add code will do that for us. # The normal add code will do that for us.
if exact and exists: if exact and exists:
if lfile: if lfile:
ui.warn(_('%s already a largefile\n') % name) ui.warn(_('%s already a largefile\n') % uipathfn(f))
continue continue
if (exact or not exists) and not lfutil.isstandin(f): if (exact or not exists) and not lfutil.isstandin(f):
# In case the file was removed previously, but not committed # In case the file was removed previously, but not committed
# (issue3507) # (issue3507)
if not repo.wvfs.exists(f): if not repo.wvfs.exists(f):
continue continue
abovemin = (lfsize and abovemin = (lfsize and
repo.wvfs.lstat(f).st_size >= lfsize * 1024 * 1024) repo.wvfs.lstat(f).st_size >= lfsize * 1024 * 1024)
if large or abovemin or (lfmatcher and lfmatcher(f)): if large or abovemin or (lfmatcher and lfmatcher(f)):
lfnames.append(f) lfnames.append(f)
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') % uipathfn(f))
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 opts.get(r'dry_run'):
standins = [] standins = []
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, uipathfn, dryrun, **opts):
after = opts.get(r'after') after = opts.get(r'after')
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
if lfutil.standin(f) in manifest] if lfutil.standin(f) in manifest]
for list in (s.modified, s.added, for list in (s.modified, s.added,
s.deleted, s.clean)] s.deleted, s.clean)]
def warn(files, msg): def warn(files, msg):
for f in files: for f in files:
ui.warn(msg % m.rel(f)) ui.warn(msg % uipathfn(f))
return int(len(files) > 0) return int(len(files) > 0)
if after: if after:
remove = deleted remove = deleted
result = warn(modified + added + clean, result = warn(modified + added + clean,
_('not removing %s: file still exists\n')) _('not removing %s: file still exists\n'))
else: else:
remove = deleted + clean remove = deleted + clean
result = warn(modified, _('not removing %s: file is modified (use -f' result = warn(modified, _('not removing %s: file is modified (use -f'
' to force removal)\n')) ' to force removal)\n'))
result = warn(added, _('not removing %s: file has been marked for add' result = warn(added, _('not removing %s: file has been marked for add'
' (use forget to undo)\n')) or result ' (use forget to undo)\n')) or result
# Need to lock because standin files are deleted then removed from the # Need to lock because standin files are deleted then removed from the
# repository and we could race in-between. # repository and we could race in-between.
with repo.wlock(): with repo.wlock():
lfdirstate = lfutil.openlfdirstate(ui, repo) lfdirstate = lfutil.openlfdirstate(ui, repo)
for f in sorted(remove): for f in sorted(remove):
if ui.verbose or not m.exact(f): if ui.verbose or not m.exact(f):
# addremove in core gets fancy with the name, remove doesn't ui.status(_('removing %s\n') % uipathfn(f))
if isaddremove:
name = m.uipath(f)
else:
name = m.rel(f)
ui.status(_('removing %s\n') % name)
if not dryrun: if not dryrun:
if not after: if not after:
repo.wvfs.unlinkpath(f, ignoremissing=True) repo.wvfs.unlinkpath(f, ignoremissing=True)
if dryrun: if dryrun:
return result return result
return orig(ui, repo, *pats, **opts) return orig(ui, repo, *pats, **opts)
@eh.wrapfunction(cmdutil, 'add') @eh.wrapfunction(cmdutil, 'add')
def cmdutiladd(orig, ui, repo, matcher, prefix, uipathfn, explicitonly, **opts): def cmdutiladd(orig, ui, repo, matcher, prefix, uipathfn, 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, uipathfn, explicitonly, **opts) return orig(ui, repo, matcher, prefix, uipathfn, explicitonly, **opts)
ladded, lbad = addlargefiles(ui, repo, False, matcher, **opts) ladded, lbad = addlargefiles(ui, repo, False, matcher, uipathfn, **opts)
normalmatcher = composenormalfilematcher(matcher, repo[None].manifest(), normalmatcher = composenormalfilematcher(matcher, repo[None].manifest(),
ladded) ladded)
bad = orig(ui, repo, normalmatcher, prefix, uipathfn, explicitonly, **opts) bad = orig(ui, repo, normalmatcher, prefix, uipathfn, explicitonly, **opts)
bad.extend(f for f in lbad) bad.extend(f for f in lbad)
return bad return bad
@eh.wrapfunction(cmdutil, 'remove') @eh.wrapfunction(cmdutil, 'remove')
def cmdutilremove(orig, ui, repo, matcher, prefix, uipathfn, after, force, def cmdutilremove(orig, ui, repo, matcher, prefix, uipathfn, after, force,
subrepos, dryrun): subrepos, dryrun):
normalmatcher = composenormalfilematcher(matcher, repo[None].manifest()) normalmatcher = composenormalfilematcher(matcher, repo[None].manifest())
result = orig(ui, repo, normalmatcher, prefix, uipathfn, after, force, result = orig(ui, repo, normalmatcher, prefix, uipathfn, after, force,
subrepos, dryrun) subrepos, dryrun)
return removelargefiles(ui, repo, False, matcher, dryrun, after=after, return removelargefiles(ui, repo, False, matcher, uipathfn, dryrun,
force=force) or result after=after, force=force) or result
@eh.wrapfunction(subrepo.hgsubrepo, 'status') @eh.wrapfunction(subrepo.hgsubrepo, 'status')
def overridestatusfn(orig, repo, rev2, **opts): def overridestatusfn(orig, repo, rev2, **opts):
try: try:
repo._repo.lfstatus = True repo._repo.lfstatus = True
return orig(repo, rev2, **opts) return orig(repo, rev2, **opts)
finally: finally:
repo._repo.lfstatus = False repo._repo.lfstatus = False
# 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, uipathfn, opts.get('dry_run'),
**pycompat.strkwargs(opts)) **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, uipathfn,
**pycompat.strkwargs(opts)) **pycompat.strkwargs(opts))
# 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, uipathfn, opts) return orig(repo, matcher, prefix, uipathfn, opts)
# Calling purge with --all will cause the largefiles to be deleted. # Calling purge with --all will cause the largefiles to be deleted.