This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11830

errors: use detailed exit code in pathauditor
ClosedPublic

Authored by martinvonz on Nov 29 2021, 4:57 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG35f1ecd84bd0: errors: use detailed exit code in pathauditor

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

martinvonz created this revision.Nov 29 2021, 4:57 PM
Alphare accepted this revision.Nov 30 2021, 8:59 AM
This revision is now accepted and ready to land.Nov 30 2021, 8:59 AM
Alphare added a comment.Nov 30 2021, 10:02 AM

This doesn't pass on Windows. I'll amend those on-the-fly: https://foss.heptapod.net/mercurial/mercurial-devel/-/jobs/269958

martinvonz added a commit: rHG35f1ecd84bd0: errors: use detailed exit code in pathauditor.Nov 30 2021, 10:15 AM
Closed by commit rHG35f1ecd84bd0: errors: use detailed exit code in pathauditor (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 31202

mercurial/pathutil.py

path may contain a pattern (e.g. foodir/**.txt)""" path may contain a pattern (e.g. foodir/**.txt)"""
path = util.localpath(path) path = util.localpath(path)
normpath = self.normcase(path) normpath = self.normcase(path)
if normpath in self.audited: if normpath in self.audited:
return return
# AIX ignores "/" at end of path, others raise EISDIR. # AIX ignores "/" at end of path, others raise EISDIR.
if util.endswithsep(path): if util.endswithsep(path):
raise error.Abort(_(b"path ends in directory separator: %s") % path) raise error.InputError(
_(b"path ends in directory separator: %s") % path
)
parts = util.splitpath(path) parts = util.splitpath(path)
if ( if (
os.path.splitdrive(path)[0] os.path.splitdrive(path)[0]
or _lowerclean(parts[0]) in (b'.hg', b'.hg.', b'') or _lowerclean(parts[0]) in (b'.hg', b'.hg.', b'')
or pycompat.ospardir in parts or pycompat.ospardir in parts
): ):
raise error.Abort(_(b"path contains illegal component: %s") % path) raise error.InputError(
_(b"path contains illegal component: %s") % path
)
# Windows shortname aliases # Windows shortname aliases
for p in parts: for p in parts:
if b"~" in p: if b"~" in p:
first, last = p.split(b"~", 1) first, last = p.split(b"~", 1)
if last.isdigit() and first.upper() in [b"HG", b"HG8B6C"]: if last.isdigit() and first.upper() in [b"HG", b"HG8B6C"]:
raise error.Abort( raise error.InputError(
_(b"path contains illegal component: %s") % path _(b"path contains illegal component: %s") % path
) )
if b'.hg' in _lowerclean(path): if b'.hg' in _lowerclean(path):
lparts = [_lowerclean(p) for p in parts] lparts = [_lowerclean(p) for p in parts]
for p in b'.hg', b'.hg.': for p in b'.hg', b'.hg.':
if p in lparts[1:]: if p in lparts[1:]:
pos = lparts.index(p) pos = lparts.index(p)
base = os.path.join(*parts[:pos]) base = os.path.join(*parts[:pos])
raise error.Abort( raise error.InputError(
_(b"path '%s' is inside nested repo %r") _(b"path '%s' is inside nested repo %r")
% (path, pycompat.bytestr(base)) % (path, pycompat.bytestr(base))
) )
normparts = util.splitpath(normpath) normparts = util.splitpath(normpath)
assert len(parts) == len(normparts) assert len(parts) == len(normparts)
parts.pop() parts.pop()

tests/test-audit-path.t

The simple store doesn't escape paths robustly and can't store paths The simple store doesn't escape paths robustly and can't store paths
with periods, etc. So much of this test fails with it. with periods, etc. So much of this test fails with it.
#require no-reposimplestore #require no-reposimplestore
$ hg init $ hg init
audit of .hg audit of .hg
$ hg add .hg/00changelog.i $ hg add .hg/00changelog.i
abort: path contains illegal component: .hg/00changelog.i abort: path contains illegal component: .hg/00changelog.i
[255] [10]
#if symlink #if symlink
Symlinks Symlinks
$ mkdir a $ mkdir a
$ echo a > a/a $ echo a > a/a
$ hg ci -Ama $ hg ci -Ama
(run 'hg heads' to see heads, 'hg merge' to merge) (run 'hg heads' to see heads, 'hg merge' to merge)
attack .hg/test attack .hg/test
$ hg manifest -r0 $ hg manifest -r0
.hg/test .hg/test
$ hg update -Cr0 $ hg update -Cr0
abort: path contains illegal component: .hg/test abort: path contains illegal component: .hg/test
[255] [10]
attack foo/.hg/test attack foo/.hg/test
$ hg manifest -r1 $ hg manifest -r1
foo/.hg/test foo/.hg/test
$ hg update -Cr1 $ hg update -Cr1
abort: path 'foo/.hg/test' is inside nested repo 'foo' abort: path 'foo/.hg/test' is inside nested repo 'foo'
[255] [10]
attack back/test where back symlinks to .. attack back/test where back symlinks to ..
$ hg manifest -r2 $ hg manifest -r2
back back
back/test back/test
#if symlink #if symlink
$ hg update -Cr2 $ hg update -Cr2
attack ../test attack ../test
$ hg manifest -r3 $ hg manifest -r3
../test ../test
$ mkdir ../test $ mkdir ../test
$ echo data > ../test/file $ echo data > ../test/file
$ hg update -Cr3 $ hg update -Cr3
abort: path contains illegal component: ../test abort: path contains illegal component: ../test
[255] [10]
$ cat ../test/file $ cat ../test/file
data data
attack /tmp/test attack /tmp/test
$ hg manifest -r4 $ hg manifest -r4
/tmp/test /tmp/test
$ hg update -Cr4 $ hg update -Cr4
abort: path contains illegal component: /tmp/test abort: path contains illegal component: /tmp/test
[255] [10]
$ cd .. $ cd ..
Test symlink traversal on merge: Test symlink traversal on merge:
-------------------------------- --------------------------------
#if symlink #if symlink

tests/test-audit-subrepo.t

Test illegal name Test illegal name
----------------- -----------------
on commit: on commit:
$ hg init hgname $ hg init hgname
$ cd hgname $ cd hgname
$ mkdir sub $ mkdir sub
$ hg init sub/.hg $ hg init sub/.hg
$ echo 'sub/.hg = sub/.hg' >> .hgsub $ echo 'sub/.hg = sub/.hg' >> .hgsub
$ hg ci -qAm 'add subrepo "sub/.hg"' $ hg ci -qAm 'add subrepo "sub/.hg"'
abort: path 'sub/.hg' is inside nested repo 'sub' abort: path 'sub/.hg' is inside nested repo 'sub'
[255] [10]
prepare tampered repo (including the commit above): prepare tampered repo (including the commit above):
$ hg import --bypass -qm 'add subrepo "sub/.hg"' - <<'EOF' $ hg import --bypass -qm 'add subrepo "sub/.hg"' - <<'EOF'
> diff --git a/.hgsub b/.hgsub > diff --git a/.hgsub b/.hgsub
> new file mode 100644 > new file mode 100644
> --- /dev/null > --- /dev/null
> +++ b/.hgsub > +++ b/.hgsub
> @@ -0,0 +1,1 @@ > @@ -0,0 +1,1 @@
> +sub/.hg = sub/.hg > +sub/.hg = sub/.hg
> diff --git a/.hgsubstate b/.hgsubstate > diff --git a/.hgsubstate b/.hgsubstate
> new file mode 100644 > new file mode 100644
> --- /dev/null > --- /dev/null
> +++ b/.hgsubstate > +++ b/.hgsubstate
> @@ -0,0 +1,1 @@ > @@ -0,0 +1,1 @@
> +0000000000000000000000000000000000000000 sub/.hg > +0000000000000000000000000000000000000000 sub/.hg
> EOF > EOF
$ cd .. $ cd ..
on clone (and update): on clone (and update):
$ hg clone -q hgname hgname2 $ hg clone -q hgname hgname2
abort: path 'sub/.hg' is inside nested repo 'sub' abort: path 'sub/.hg' is inside nested repo 'sub'
[255] [10]
Test absolute path Test absolute path
------------------ ------------------
on commit: on commit:
$ hg init absolutepath $ hg init absolutepath
$ cd absolutepath $ cd absolutepath
$ hg init sub $ hg init sub
$ echo '/sub = sub' >> .hgsub $ echo '/sub = sub' >> .hgsub
$ hg ci -qAm 'add subrepo "/sub"' $ hg ci -qAm 'add subrepo "/sub"'
abort: path contains illegal component: /sub abort: path contains illegal component: /sub
[255] [10]
prepare tampered repo (including the commit above): prepare tampered repo (including the commit above):
$ hg import --bypass -qm 'add subrepo "/sub"' - <<'EOF' $ hg import --bypass -qm 'add subrepo "/sub"' - <<'EOF'
> diff --git a/.hgsub b/.hgsub > diff --git a/.hgsub b/.hgsub
> new file mode 100644 > new file mode 100644
> --- /dev/null > --- /dev/null
> +++ b/.hgsub > +++ b/.hgsub
> @@ -0,0 +1,1 @@ > @@ -0,0 +1,1 @@
> +/sub = sub > +/sub = sub
> diff --git a/.hgsubstate b/.hgsubstate > diff --git a/.hgsubstate b/.hgsubstate
> new file mode 100644 > new file mode 100644
> --- /dev/null > --- /dev/null
> +++ b/.hgsubstate > +++ b/.hgsubstate
> @@ -0,0 +1,1 @@ > @@ -0,0 +1,1 @@
> +0000000000000000000000000000000000000000 /sub > +0000000000000000000000000000000000000000 /sub
> EOF > EOF
$ cd .. $ cd ..
on clone (and update): on clone (and update):
$ hg clone -q absolutepath absolutepath2 $ hg clone -q absolutepath absolutepath2
abort: path contains illegal component: /sub abort: path contains illegal component: /sub
[255] [10]
Test root path Test root path
-------------- --------------
on commit: on commit:
$ hg init rootpath $ hg init rootpath
$ cd rootpath $ cd rootpath
$ hg init sub $ hg init sub
$ echo '/ = sub' >> .hgsub $ echo '/ = sub' >> .hgsub
$ hg ci -qAm 'add subrepo "/"' $ hg ci -qAm 'add subrepo "/"'
abort: path ends in directory separator: / abort: path ends in directory separator: /
[255] [10]
prepare tampered repo (including the commit above): prepare tampered repo (including the commit above):
$ hg import --bypass -qm 'add subrepo "/"' - <<'EOF' $ hg import --bypass -qm 'add subrepo "/"' - <<'EOF'
> diff --git a/.hgsub b/.hgsub > diff --git a/.hgsub b/.hgsub
> new file mode 100644 > new file mode 100644
> --- /dev/null > --- /dev/null
> +++ b/.hgsub > +++ b/.hgsub
> @@ -0,0 +1,1 @@ > @@ -0,0 +1,1 @@
> +/ = sub > +/ = sub
> diff --git a/.hgsubstate b/.hgsubstate > diff --git a/.hgsubstate b/.hgsubstate
> new file mode 100644 > new file mode 100644
> --- /dev/null > --- /dev/null
> +++ b/.hgsubstate > +++ b/.hgsubstate
> @@ -0,0 +1,1 @@ > @@ -0,0 +1,1 @@
> +0000000000000000000000000000000000000000 / > +0000000000000000000000000000000000000000 /
> EOF > EOF
$ cd .. $ cd ..
on clone (and update): on clone (and update):
$ hg clone -q rootpath rootpath2 $ hg clone -q rootpath rootpath2
abort: path ends in directory separator: / abort: path ends in directory separator: /
[255] [10]
Test empty path Test empty path
--------------- ---------------
on commit: on commit:
$ hg init emptypath $ hg init emptypath
$ cd emptypath $ cd emptypath
$ mkdir outerpath $ mkdir outerpath
$ cd outerpath $ cd outerpath
$ hg init main $ hg init main
$ cd main $ cd main
$ hg init ../sub $ hg init ../sub
$ echo '../sub = ../sub' >> .hgsub $ echo '../sub = ../sub' >> .hgsub
$ hg ci -qAm 'add subrepo "../sub"' $ hg ci -qAm 'add subrepo "../sub"'
abort: path contains illegal component: ../sub abort: path contains illegal component: ../sub
[255] [10]
prepare tampered repo (including the commit above): prepare tampered repo (including the commit above):
$ hg import --bypass -qm 'add subrepo "../sub"' - <<'EOF' $ hg import --bypass -qm 'add subrepo "../sub"' - <<'EOF'
> diff --git a/.hgsub b/.hgsub > diff --git a/.hgsub b/.hgsub
> new file mode 100644 > new file mode 100644
> --- /dev/null > --- /dev/null
> +++ b/.hgsub > +++ b/.hgsub
> @@ -0,0 +1,1 @@ > @@ -0,0 +1,1 @@
> +../sub = ../sub > +../sub = ../sub
> diff --git a/.hgsubstate b/.hgsubstate > diff --git a/.hgsubstate b/.hgsubstate
> new file mode 100644 > new file mode 100644
> --- /dev/null > --- /dev/null
> +++ b/.hgsubstate > +++ b/.hgsubstate
> @@ -0,0 +1,1 @@ > @@ -0,0 +1,1 @@
> +0000000000000000000000000000000000000000 ../sub > +0000000000000000000000000000000000000000 ../sub
> EOF > EOF
$ cd .. $ cd ..
on clone (and update): on clone (and update):
$ hg clone -q main main2 $ hg clone -q main main2
abort: path contains illegal component: ../sub abort: path contains illegal component: ../sub
[255] [10]
$ cd .. $ cd ..
Test variable expansion Test variable expansion
----------------------- -----------------------
Subrepository paths shouldn't be expanded, but we fail to handle them Subrepository paths shouldn't be expanded, but we fail to handle them
properly. Any local repository paths are expanded. properly. Any local repository paths are expanded.

tests/test-commit.t

$ "$PYTHON" evil-commit.py $ "$PYTHON" evil-commit.py
#if windows #if windows
$ hg co --clean tip $ hg co --clean tip
abort: path contains illegal component: .h\xe2\x80\x8cg\\hgrc (esc) abort: path contains illegal component: .h\xe2\x80\x8cg\\hgrc (esc)
[255] [255]
#else #else
$ hg co --clean tip $ hg co --clean tip
abort: path contains illegal component: .h\xe2\x80\x8cg/hgrc (esc) abort: path contains illegal component: .h\xe2\x80\x8cg/hgrc (esc)
[255] [10]
#endif #endif
$ hg rollback -f $ hg rollback -f
repository tip rolled back to revision 2 (undo commit) repository tip rolled back to revision 2 (undo commit)
$ cat > evil-commit.py <<EOF $ cat > evil-commit.py <<EOF
> from __future__ import absolute_import > from __future__ import absolute_import
> from mercurial import context, hg, ui as uimod > from mercurial import context, hg, ui as uimod
> notrc = b"HG~1/hgrc" > notrc = b"HG~1/hgrc"
> u = uimod.ui.load() > u = uimod.ui.load()
> r = hg.repository(u, b'.') > r = hg.repository(u, b'.')
> def filectxfn(repo, memctx, path): > def filectxfn(repo, memctx, path):
> return context.memfilectx(repo, memctx, path, > return context.memfilectx(repo, memctx, path,
> b'[hooks]\nupdate = echo owned') > b'[hooks]\nupdate = echo owned')
> c = context.memctx(r, [r[b'tip'].node(), r.nullid], > c = context.memctx(r, [r[b'tip'].node(), r.nullid],
> b'evil', [notrc], filectxfn, 0) > b'evil', [notrc], filectxfn, 0)
> r.commitctx(c) > r.commitctx(c)
> EOF > EOF
$ "$PYTHON" evil-commit.py $ "$PYTHON" evil-commit.py
$ hg co --clean tip $ hg co --clean tip
abort: path contains illegal component: HG~1/hgrc abort: path contains illegal component: HG~1/hgrc
[255] [10]
$ hg rollback -f $ hg rollback -f
repository tip rolled back to revision 2 (undo commit) repository tip rolled back to revision 2 (undo commit)
$ cat > evil-commit.py <<EOF $ cat > evil-commit.py <<EOF
> from __future__ import absolute_import > from __future__ import absolute_import
> from mercurial import context, hg, ui as uimod > from mercurial import context, hg, ui as uimod
> notrc = b"HG8B6C~2/hgrc" > notrc = b"HG8B6C~2/hgrc"
> u = uimod.ui.load() > u = uimod.ui.load()
> r = hg.repository(u, b'.') > r = hg.repository(u, b'.')
> def filectxfn(repo, memctx, path): > def filectxfn(repo, memctx, path):
> return context.memfilectx(repo, memctx, path, > return context.memfilectx(repo, memctx, path,
> b'[hooks]\nupdate = echo owned') > b'[hooks]\nupdate = echo owned')
> c = context.memctx(r, [r[b'tip'].node(), r.nullid], > c = context.memctx(r, [r[b'tip'].node(), r.nullid],
> b'evil', [notrc], filectxfn, 0) > b'evil', [notrc], filectxfn, 0)
> r.commitctx(c) > r.commitctx(c)
> EOF > EOF
$ "$PYTHON" evil-commit.py $ "$PYTHON" evil-commit.py
$ hg co --clean tip $ hg co --clean tip
abort: path contains illegal component: HG8B6C~2/hgrc abort: path contains illegal component: HG8B6C~2/hgrc
[255] [10]
$ cd .. $ cd ..
# test that an unmodified commit template message aborts # test that an unmodified commit template message aborts
$ hg init unmodified_commit_template $ hg init unmodified_commit_template
$ cd unmodified_commit_template $ cd unmodified_commit_template
$ echo foo > foo $ echo foo > foo

tests/test-import.t

$ cd inside $ cd inside
$ hg import - <<EOF $ hg import - <<EOF
> diff --git a/a b/b > diff --git a/a b/b
> rename from ../outside/foo > rename from ../outside/foo
> rename to bar > rename to bar
> EOF > EOF
applying patch from stdin applying patch from stdin
abort: path contains illegal component: ../outside/foo abort: path contains illegal component: ../outside/foo
[255] [10]
$ cd .. $ cd ..
test import with similarity and git and strip (issue295 et al.) test import with similarity and git and strip (issue295 et al.)
$ hg init sim $ hg init sim
$ cd sim $ cd sim
$ echo 'this is a test' > a $ echo 'this is a test' > a

tests/test-rename.t

$ hg update -C $ hg update -C
2 files updated, 0 files merged, 0 files removed, 0 files unresolved 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d1/c # The file was marked as added, so 'hg update' action was 'forget' $ rm d1/c # The file was marked as added, so 'hg update' action was 'forget'
check illegal path components check illegal path components
$ hg rename d1/d11/a1 .hg/foo $ hg rename d1/d11/a1 .hg/foo
abort: path contains illegal component: .hg/foo abort: path contains illegal component: .hg/foo
[255] [10]
$ hg status -C $ hg status -C
$ hg rename d1/d11/a1 ../foo $ hg rename d1/d11/a1 ../foo
abort: ../foo not under root '$TESTTMP' abort: ../foo not under root '$TESTTMP'
[255] [255]
$ hg status -C $ hg status -C
$ mv d1/d11/a1 .hg/foo $ mv d1/d11/a1 .hg/foo
$ hg rename --after d1/d11/a1 .hg/foo $ hg rename --after d1/d11/a1 .hg/foo
abort: path contains illegal component: .hg/foo abort: path contains illegal component: .hg/foo
[255] [10]
$ hg status -C $ hg status -C
! d1/d11/a1 ! d1/d11/a1
$ hg update -C $ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm .hg/foo $ rm .hg/foo
$ hg rename d1/d11/a1 .hg $ hg rename d1/d11/a1 .hg
abort: path contains illegal component: .hg/a1 abort: path contains illegal component: .hg/a1
[255] [10]
$ hg --config extensions.largefiles= rename d1/d11/a1 .hg $ hg --config extensions.largefiles= rename d1/d11/a1 .hg
The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !) The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
abort: path contains illegal component: .hg/a1 abort: path contains illegal component: .hg/a1
[255] [10]
$ hg status -C $ hg status -C
$ hg rename d1/d11/a1 .. $ hg rename d1/d11/a1 ..
abort: ../a1 not under root '$TESTTMP' abort: ../a1 not under root '$TESTTMP'
[255] [255]
$ hg --config extensions.largefiles= rename d1/d11/a1 .. $ hg --config extensions.largefiles= rename d1/d11/a1 ..
The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !) The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
abort: ../a1 not under root '$TESTTMP' abort: ../a1 not under root '$TESTTMP'
[255] [255]
$ hg status -C $ hg status -C
$ mv d1/d11/a1 .hg $ mv d1/d11/a1 .hg
$ hg rename --after d1/d11/a1 .hg $ hg rename --after d1/d11/a1 .hg
abort: path contains illegal component: .hg/a1 abort: path contains illegal component: .hg/a1
[255] [10]
$ hg status -C $ hg status -C
! d1/d11/a1 ! d1/d11/a1
$ hg update -C $ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm .hg/a1 $ rm .hg/a1
$ (cd d1/d11; hg rename ../../d2/b ../../.hg/foo) $ (cd d1/d11; hg rename ../../d2/b ../../.hg/foo)
abort: path contains illegal component: .hg/foo abort: path contains illegal component: .hg/foo
[255] [10]
$ hg status -C $ hg status -C
$ (cd d1/d11; hg rename ../../d2/b ../../../foo) $ (cd d1/d11; hg rename ../../d2/b ../../../foo)
abort: ../../../foo not under root '$TESTTMP' abort: ../../../foo not under root '$TESTTMP'
[255] [255]
$ hg status -C $ hg status -C
check that stat information such as mtime is preserved on rename - it's unclear check that stat information such as mtime is preserved on rename - it's unclear
whether the `touch` and `stat` commands are portable, so we mimic them using whether the `touch` and `stat` commands are portable, so we mimic them using

tests/test-walk.t

* matcher: * matcher:
<patternmatcher patterns='mammals(?:/|$)'> <patternmatcher patterns='mammals(?:/|$)'>
f mammals/Procyonidae/cacomistle Procyonidae/cacomistle f mammals/Procyonidae/cacomistle Procyonidae/cacomistle
f mammals/Procyonidae/coatimundi Procyonidae/coatimundi f mammals/Procyonidae/coatimundi Procyonidae/coatimundi
f mammals/Procyonidae/raccoon Procyonidae/raccoon f mammals/Procyonidae/raccoon Procyonidae/raccoon
f mammals/skunk skunk f mammals/skunk skunk
$ hg debugwalk -v .hg $ hg debugwalk -v .hg
abort: path 'mammals/.hg' is inside nested repo 'mammals' abort: path 'mammals/.hg' is inside nested repo 'mammals'
[255] [10]
$ hg debugwalk -v ../.hg $ hg debugwalk -v ../.hg
abort: path contains illegal component: .hg abort: path contains illegal component: .hg
[255] [10]
$ cd .. $ cd ..
$ hg debugwalk -v -Ibeans $ hg debugwalk -v -Ibeans
* matcher: * matcher:
<includematcher includes='beans(?:/|$)'> <includematcher includes='beans(?:/|$)'>
f beans/black beans/black f beans/black beans/black
f beans/borlotti beans/borlotti f beans/borlotti beans/borlotti
f beans/kidney beans/kidney f beans/kidney beans/kidney
$ hg debugwalk -v .. $ hg debugwalk -v ..
abort: .. not under root '$TESTTMP/t' abort: .. not under root '$TESTTMP/t'
[255] [255]
$ hg debugwalk -v beans/../.. $ hg debugwalk -v beans/../..
abort: beans/../.. not under root '$TESTTMP/t' abort: beans/../.. not under root '$TESTTMP/t'
[255] [255]
$ hg debugwalk -v .hg $ hg debugwalk -v .hg
abort: path contains illegal component: .hg abort: path contains illegal component: .hg
[255] [10]
$ hg debugwalk -v beans/../.hg $ hg debugwalk -v beans/../.hg
abort: path contains illegal component: .hg abort: path contains illegal component: .hg
[255] [10]
$ hg debugwalk -v beans/../.hg/data $ hg debugwalk -v beans/../.hg/data
abort: path contains illegal component: .hg/data abort: path contains illegal component: .hg/data
[255] [10]
$ hg debugwalk -v beans/.hg $ hg debugwalk -v beans/.hg
abort: path 'beans/.hg' is inside nested repo 'beans' abort: path 'beans/.hg' is inside nested repo 'beans'
[255] [10]
Test explicit paths and excludes: Test explicit paths and excludes:
$ hg debugwalk -v fennel -X fennel $ hg debugwalk -v fennel -X fennel
* matcher: * matcher:
<differencematcher <differencematcher
m1=<patternmatcher patterns='fennel(?:/|$)'>, m1=<patternmatcher patterns='fennel(?:/|$)'>,
m2=<includematcher includes='fennel(?:/|$)'>> m2=<includematcher includes='fennel(?:/|$)'>>