This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5901

add: pass around uipathfn and use instead of m.rel() (API)
ClosedPublic

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

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGf8b18583049f: add: pass around uipathfn and use instead of m.rel() (API)
Summary

For now, the uipathfn we pass around always prints relative paths just
like before, so this should have no effect. Well, there's one little
change: I also made the "skipping missing subrepository: %s\n" message
relative.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Revision Contents
Changeset List

Diff 13982

hgext/largefiles/overrides.py

('', 'lfsize', '', _('add all files above this size (in megabytes) ' ('', 'lfsize', '', _('add all files above this size (in megabytes) '
'as largefiles (default: 10)'))]) 'as largefiles (default: 10)'))])
def overrideadd(orig, ui, repo, *pats, **opts): def overrideadd(orig, ui, repo, *pats, **opts):
if opts.get(r'normal') and opts.get(r'large'): if opts.get(r'normal') and opts.get(r'large'):
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)
@eh.wrapfunction(cmdutil, 'add') @eh.wrapfunction(cmdutil, 'add')
def cmdutiladd(orig, ui, repo, matcher, prefix, 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, 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, **opts)
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, 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, after, force, subrepos, def cmdutilremove(orig, ui, repo, matcher, prefix, after, force, subrepos,
dryrun): dryrun):
normalmatcher = composenormalfilematcher(matcher, repo[None].manifest()) normalmatcher = composenormalfilematcher(matcher, repo[None].manifest())

mercurial/cmdutil.py

for rev in nrevs: for rev in nrevs:
yield change(rev) yield change(rev)
if stopiteration: if stopiteration:
break break
return iterate() return iterate()
def add(ui, repo, match, prefix, explicitonly, **opts): def add(ui, repo, match, prefix, uipathfn, explicitonly, **opts):
bad = [] bad = []
badfn = lambda x, y: bad.append(x) or match.bad(x, y) badfn = lambda x, y: bad.append(x) or match.bad(x, y)
names = [] names = []
wctx = repo[None] wctx = repo[None]
cca = None cca = None
abort, warn = scmutil.checkportabilityalert(ui) abort, warn = scmutil.checkportabilityalert(ui)
if abort or warn: if abort or warn:
cca = scmutil.casecollisionauditor(ui, abort, repo.dirstate) cca = scmutil.casecollisionauditor(ui, abort, repo.dirstate)
match = repo.narrowmatch(match, includeexact=True) match = repo.narrowmatch(match, includeexact=True)
badmatch = matchmod.badmatch(match, badfn) badmatch = matchmod.badmatch(match, badfn)
dirstate = repo.dirstate dirstate = repo.dirstate
# We don't want to just call wctx.walk here, since it would return a lot of # We don't want to just call wctx.walk here, since it would return a lot of
# clean files, which we aren't interested in and takes time. # clean files, which we aren't interested in and takes time.
for f in sorted(dirstate.walk(badmatch, subrepos=sorted(wctx.substate), for f in sorted(dirstate.walk(badmatch, subrepos=sorted(wctx.substate),
unknown=True, ignored=False, full=False)): unknown=True, ignored=False, full=False)):
exact = match.exact(f) exact = match.exact(f)
if exact or not explicitonly and f not in wctx and repo.wvfs.lexists(f): if exact or not explicitonly and f not in wctx and repo.wvfs.lexists(f):
if cca: if cca:
cca(f) cca(f)
names.append(f) names.append(f)
if ui.verbose or not exact: if ui.verbose or not exact:
ui.status(_('adding %s\n') % match.rel(f), ui.status(_('adding %s\n') % uipathfn(f),
label='ui.addremove.added') label='ui.addremove.added')
for subpath in sorted(wctx.substate): for subpath in sorted(wctx.substate):
sub = wctx.sub(subpath) sub = wctx.sub(subpath)
try: try:
submatch = matchmod.subdirmatcher(subpath, match) submatch = matchmod.subdirmatcher(subpath, match)
subprefix = repo.wvfs.reljoin(prefix, subpath) subprefix = repo.wvfs.reljoin(prefix, subpath)
subuipathfn = scmutil.subdiruipathfn(subpath, uipathfn)
if opts.get(r'subrepos'): if opts.get(r'subrepos'):
bad.extend(sub.add(ui, submatch, subprefix, False, **opts)) bad.extend(sub.add(ui, submatch, subprefix, subuipathfn, False,
**opts))
else: else:
bad.extend(sub.add(ui, submatch, subprefix, True, **opts)) bad.extend(sub.add(ui, submatch, subprefix, subuipathfn, True,
**opts))
except error.LookupError: except error.LookupError:
ui.status(_("skipping missing subrepository: %s\n") ui.status(_("skipping missing subrepository: %s\n")
% match.rel(subpath)) % uipathfn(subpath))
if not opts.get(r'dry_run'): if not opts.get(r'dry_run'):
rejected = wctx.add(names, prefix) rejected = wctx.add(names, prefix)
bad.extend(f for f in rejected if f in match.files()) bad.extend(f for f in rejected if f in match.files())
return bad return bad
def addwebdirpath(repo, serverpath, webconf): def addwebdirpath(repo, serverpath, webconf):
webconf[serverpath] = repo.root webconf[serverpath] = repo.root

mercurial/commands.py

$ hg status $ hg status
A bar.c A bar.c
? foo.c ? foo.c
Returns 0 if all files are successfully added. Returns 0 if all files are successfully added.
""" """
m = scmutil.match(repo[None], pats, pycompat.byteskwargs(opts)) m = scmutil.match(repo[None], pats, pycompat.byteskwargs(opts))
rejected = cmdutil.add(ui, repo, m, "", False, **opts) uipathfn = scmutil.getuipathfn(repo, forcerelativevalue=True)
rejected = cmdutil.add(ui, repo, m, "", uipathfn, False, **opts)
return rejected and 1 or 0 return rejected and 1 or 0
@command('addremove', @command('addremove',
similarityopts + subrepoopts + walkopts + dryrunopts, similarityopts + subrepoopts + walkopts + dryrunopts,
_('[OPTION]... [FILE]...'), _('[OPTION]... [FILE]...'),
helpcategory=command.CATEGORY_WORKING_DIRECTORY, helpcategory=command.CATEGORY_WORKING_DIRECTORY,
inferrepo=True) inferrepo=True)
def addremove(ui, repo, *pats, **opts): def addremove(ui, repo, *pats, **opts):

mercurial/scmutil.py

# scmutil.py - Mercurial core utility functions # scmutil.py - Mercurial core utility functions
# #
# Copyright Matt Mackall <mpm@selenic.com> # Copyright Matt Mackall <mpm@selenic.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
import glob import glob
import hashlib import hashlib
import os import os
import posixpath
import re import re
import subprocess import subprocess
import weakref import weakref
from .i18n import _ from .i18n import _
from .node import ( from .node import (
bin, bin,
hex, hex,
if relative: if relative:
cwd = repo.getcwd() cwd = repo.getcwd()
pathto = repo.pathto pathto = repo.pathto
return lambda f: pathto(f, cwd) return lambda f: pathto(f, cwd)
else: else:
return lambda f: f return lambda f: f
def subdiruipathfn(subpath, uipathfn):
'''Create a new uipathfn that treats the file as relative to subpath.'''
return lambda f: uipathfn(posixpath.join(subpath, f))
def expandpats(pats): def expandpats(pats):
'''Expand bare globs when running on windows. '''Expand bare globs when running on windows.
On posix we assume it already has already been done by sh.''' On posix we assume it already has already been done by sh.'''
if not util.expandglobs: if not util.expandglobs:
return list(pats) return list(pats)
ret = [] ret = []
for kindpat in pats: for kindpat in pats:
kind, pat = matchmod._patsplit(kindpat, None) kind, pat = matchmod._patsplit(kindpat, None)

mercurial/subrepo.py

def push(self, opts): def push(self, opts):
"""perform whatever action is analogous to 'hg push' """perform whatever action is analogous to 'hg push'
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, uipathfn, explicitonly, **opts):
return [] return []
def addremove(self, matcher, prefix, opts): def addremove(self, matcher, prefix, opts):
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
defpushpath = _abssource(self._repo, True, abort=False) defpushpath = _abssource(self._repo, True, abort=False)
addpathconfig('default', defpath) addpathconfig('default', defpath)
if defpath != defpushpath: if defpath != defpushpath:
addpathconfig('default-push', defpushpath) addpathconfig('default-push', defpushpath)
self._repo.vfs.write('hgrc', util.tonativeeol(''.join(lines))) self._repo.vfs.write('hgrc', util.tonativeeol(''.join(lines)))
@annotatesubrepoerror @annotatesubrepoerror
def add(self, ui, match, prefix, explicitonly, **opts): def add(self, ui, match, prefix, uipathfn, explicitonly, **opts):
return cmdutil.add(ui, self._repo, match, prefix, explicitonly, **opts) return cmdutil.add(ui, self._repo, match, prefix, uipathfn,
explicitonly, **opts)
@annotatesubrepoerror @annotatesubrepoerror
def addremove(self, m, prefix, opts): def addremove(self, m, prefix, opts):
# 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) opts = copy.copy(opts)
opts['subrepos'] = True opts['subrepos'] = True
return ret[1] == 0 return ret[1] == 0
else: else:
self.ui.warn(_('no branch checked out in subrepository "%s"\n' self.ui.warn(_('no branch checked out in subrepository "%s"\n'
'cannot push revision %s\n') % 'cannot push revision %s\n') %
(self._relpath, self._state[1])) (self._relpath, self._state[1]))
return False return False
@annotatesubrepoerror @annotatesubrepoerror
def add(self, ui, match, prefix, explicitonly, **opts): def add(self, ui, match, prefix, uipathfn, explicitonly, **opts):
if self._gitmissing(): if self._gitmissing():
return [] return []
s = self.status(None, unknown=True, clean=True) s = self.status(None, unknown=True, clean=True)
tracked = set() tracked = set()
# dirstates 'amn' warn, 'r' is added again # dirstates 'amn' warn, 'r' is added again
for l in (s.modified, s.added, s.deleted, s.clean): for l in (s.modified, s.added, s.deleted, s.clean):
tracked.update(l) tracked.update(l)
# Unknown files not of interest will be rejected by the matcher # Unknown files not of interest will be rejected by the matcher
files = s.unknown files = s.unknown
files.extend(match.files()) files.extend(match.files())
rejected = [] rejected = []
files = [f for f in sorted(set(files)) if match(f)] files = [f for f in sorted(set(files)) if match(f)]
for f in files: for f in files:
exact = match.exact(f) exact = match.exact(f)
command = ["add"] command = ["add"]
if exact: if exact:
command.append("-f") #should be added, even if ignored command.append("-f") #should be added, even if ignored
if ui.verbose or not exact: if ui.verbose or not exact:
ui.status(_('adding %s\n') % match.rel(f)) ui.status(_('adding %s\n') % uipathfn(f))
if f in tracked: # hg prints 'adding' even if already tracked if f in tracked: # hg prints 'adding' even if already tracked
if exact: if exact:
rejected.append(f) rejected.append(f)
continue continue
if not opts.get(r'dry_run'): if not opts.get(r'dry_run'):
self._gitcommand(command + [f]) self._gitcommand(command + [f])
for f in rejected: for f in rejected:
ui.warn(_("%s already tracked!\n") % match.rel(f)) ui.warn(_("%s already tracked!\n") % uipathfn(f))
return rejected return rejected
@annotatesubrepoerror @annotatesubrepoerror
def remove(self): def remove(self):
if self._gitmissing(): if self._gitmissing():
return return
if self.dirty(): if self.dirty():