demandimport: delay loading for "from a import b" with absolute_import
Before this patch, "from a import b" doesn't delay loading module "b",
if absolute_import is enabled, even though "from . import b" does.
For example:
- it is assumed that extension X has "from P import M" for module M
under package P with absolute_import feature
- if importing module M is already delayed before loading extension
X, loading module M in extension X is delayed until actually
referring
util, cmdutil, scmutil or so of Mercurial itself should be
imported by "from . import M" style before loading extension X
- otherwise, module M is loaded immediately at loading extension X,
even if extension X itself isn't used at that "hg" command invocation
Some minor modules (e.g. filemerge or so) of Mercurial itself
aren't imported by "from . import M" style before loading
extension X. And of course, external libraries aren't, too.
This might cause startup performance problem of hg command, because
many bundled extensions already enable absolute_import feature.
To delay loading module for "from a import b" with absolute_import
feature, this patch does below in "from a (or .a) import b" with
absolute_import case:
1. import root module of "name" by system built-in __import__
(referred as _origimport)
2. recurse down the module chain for hierarchical "name"
This logic can be shared with non absolute_import
case. Therefore, this patch also centralizes it into chainmodules().
3. and fall through to process elements in "fromlist" for the leaf
module of "name"
Processing elements in "fromlist" is executed in the code path
after "if _pypy: .... else: ..." clause. Therefore, this patch
replaces "if _pypy:" with "elif _pypy:" to share it.
At 4f1144c3c72b introducing original "work around" for "from a import
b" case, elements in "fromlist" were imported with "level=level". But
"level" might be grater than 1 (e.g. level=2 in "from .. import b"
case) at demandimport() invocation, and importing direct sub-module in
"fromlist" with level grater than 1 causes unexpected result.
IMHO, this seems main reason of "errors for unknown reason" described
in 4f1144c3c72b, and we don't have to worry about it, because this
issue was already fixed by 78d05778907b.
This is reason why this patch removes "errors for unknown reasons"
comment.
$ echo "[extensions]" >> $HGRCPATH
$ echo "mq=" >> $HGRCPATH
$ hg init
$ hg qinit
$ echo x > x
$ hg ci -Ama
adding x
$ hg qnew a.patch
$ echo a > a
$ hg add a
$ hg qrefresh
$ hg qnew b.patch
$ echo b > b
$ hg add b
$ hg qrefresh
$ hg qnew c.patch
$ echo c > c
$ hg add c
$ hg qrefresh
$ hg qpop -a
popping c.patch
popping b.patch
popping a.patch
patch queue now empty
should fail
$ hg qguard does-not-exist.patch +bleh
abort: no patch named does-not-exist.patch
[255]
should fail
$ hg qguard +fail
abort: no patches applied
[255]
$ hg qpush
applying a.patch
now at: a.patch
should guard a.patch
$ hg qguard +a
should print +a
$ hg qguard
a.patch: +a
$ hg qpop
popping a.patch
patch queue now empty
should fail
$ hg qpush a.patch
cannot push 'a.patch' - guarded by '+a'
[1]
$ hg qguard a.patch
a.patch: +a
should push b.patch
$ hg qpush
applying b.patch
now at: b.patch
$ hg qpop
popping b.patch
patch queue now empty
test selection of an empty guard
$ hg qselect ""
abort: guard cannot be an empty string
[255]
$ hg qselect a
number of unguarded, unapplied patches has changed from 2 to 3
should push a.patch
$ hg qpush
applying a.patch
now at: a.patch
$ hg qguard -- c.patch -a
should print -a
$ hg qguard c.patch
c.patch: -a
should skip c.patch
$ hg qpush -a
applying b.patch
skipping c.patch - guarded by '-a'
now at: b.patch
$ hg qnext
all patches applied
[1]
should display b.patch
$ hg qtop
b.patch
$ hg qguard -n c.patch
should push c.patch
$ hg qpush -a
applying c.patch
now at: c.patch
$ hg qpop -a
popping c.patch
popping b.patch
popping a.patch
patch queue now empty
$ hg qselect -n
guards deactivated
number of unguarded, unapplied patches has changed from 3 to 2
should push all
$ hg qpush -a
applying b.patch
applying c.patch
now at: c.patch
$ hg qpop -a
popping c.patch
popping b.patch
patch queue now empty
$ hg qguard a.patch +1
$ hg qguard b.patch +2
$ hg qselect 1
number of unguarded, unapplied patches has changed from 1 to 2
should push a.patch, not b.patch
$ hg qpush
applying a.patch
now at: a.patch
$ hg qpush
applying c.patch
now at: c.patch
$ hg qpop -a
popping c.patch
popping a.patch
patch queue now empty
$ hg qselect 2
should push b.patch
$ hg qpush
applying b.patch
now at: b.patch
$ hg qpush -a
applying c.patch
now at: c.patch
$ hg qprev
b.patch
Used to be an issue with holes in the patch sequence
So, put one hole on the base and ask for topmost patch.
$ hg qtop
c.patch
$ hg qpop -a
popping c.patch
popping b.patch
patch queue now empty
$ hg qselect 1 2
number of unguarded, unapplied patches has changed from 2 to 3
should push a.patch, b.patch
$ hg qpush
applying a.patch
now at: a.patch
$ hg qpush
applying b.patch
now at: b.patch
$ hg qpop -a
popping b.patch
popping a.patch
patch queue now empty
$ hg qguard -- a.patch +1 +2 -3
$ hg qselect 1 2 3
number of unguarded, unapplied patches has changed from 3 to 2
list patches and guards
$ hg qguard -l
a.patch: +1 +2 -3
b.patch: +2
c.patch: unguarded
have at least one patch applied to test coloring
$ hg qpush
applying b.patch
now at: b.patch
list patches and guards with color
$ hg --config extensions.color= qguard --config color.mode=ansi \
> -l --color=always
\x1b[0;30;1ma.patch\x1b[0m: \x1b[0;33m+1\x1b[0m \x1b[0;33m+2\x1b[0m \x1b[0;31m-3\x1b[0m (esc)
\x1b[0;34;1;4mb.patch\x1b[0m: \x1b[0;33m+2\x1b[0m (esc)
\x1b[0;30;1mc.patch\x1b[0m: \x1b[0;32munguarded\x1b[0m (esc)
should pop b.patch
$ hg qpop
popping b.patch
patch queue now empty
list series
$ hg qseries -v
0 G a.patch
1 U b.patch
2 U c.patch
list guards
$ hg qselect
1
2
3
should push b.patch
$ hg qpush
applying b.patch
now at: b.patch
$ hg qpush -a
applying c.patch
now at: c.patch
$ hg qselect -n --reapply -v
guards deactivated
popping guarded patches
popping c.patch
popping b.patch
patch queue now empty
reapplying unguarded patches
skipping a.patch - guarded by '+1' '+2'
skipping b.patch - guarded by '+2'
skipping a.patch - guarded by '+1' '+2'
skipping b.patch - guarded by '+2'
applying c.patch
patching file c
adding c
committing files:
c
committing manifest
committing changelog
now at: c.patch
guards in series file: +1 +2 -3
$ hg qselect -s
+1
+2
-3
should show c.patch
$ hg qapplied
c.patch
$ hg qrename a.patch new.patch
should show :
new.patch: +1 +2 -3
b.patch: +2
c.patch: unguarded
$ hg qguard -l
new.patch: +1 +2 -3
b.patch: +2
c.patch: unguarded
$ hg qnew d.patch
$ hg qpop
popping d.patch
now at: c.patch
should show new.patch and b.patch as Guarded, c.patch as Applied
and d.patch as Unapplied
$ hg qseries -v
0 G new.patch
1 G b.patch
2 A c.patch
3 U d.patch
qseries again, but with color
$ hg --config extensions.color= --config color.mode=ansi qseries -v --color=always
0 G \x1b[0;30;1mnew.patch\x1b[0m (esc)
1 G \x1b[0;30;1mb.patch\x1b[0m (esc)
2 A \x1b[0;34;1;4mc.patch\x1b[0m (esc)
3 U \x1b[0;30;1md.patch\x1b[0m (esc)
$ hg qguard d.patch +2
new.patch, b.patch: Guarded. c.patch: Applied. d.patch: Guarded.
$ hg qseries -v
0 G new.patch
1 G b.patch
2 A c.patch
3 G d.patch
$ qappunappv()
> {
> for command in qapplied "qapplied -v" qunapplied "qunapplied -v"; do
> echo % hg $command
> hg $command
> done
> }
$ hg qpop -a
popping c.patch
patch queue now empty
$ hg qguard -l
new.patch: +1 +2 -3
b.patch: +2
c.patch: unguarded
d.patch: +2
$ qappunappv
% hg qapplied
% hg qapplied -v
% hg qunapplied
c.patch
% hg qunapplied -v
0 G new.patch
1 G b.patch
2 U c.patch
3 G d.patch
$ hg qselect 1
number of unguarded, unapplied patches has changed from 1 to 2
$ qappunappv
% hg qapplied
% hg qapplied -v
% hg qunapplied
new.patch
c.patch
% hg qunapplied -v
0 U new.patch
1 G b.patch
2 U c.patch
3 G d.patch
$ hg qpush -a
applying new.patch
skipping b.patch - guarded by '+2'
applying c.patch
skipping d.patch - guarded by '+2'
now at: c.patch
$ qappunappv
% hg qapplied
new.patch
c.patch
% hg qapplied -v
0 A new.patch
1 G b.patch
2 A c.patch
% hg qunapplied
% hg qunapplied -v
3 G d.patch
$ hg qselect 2
number of unguarded, unapplied patches has changed from 0 to 1
$ qappunappv
% hg qapplied
new.patch
c.patch
% hg qapplied -v
0 A new.patch
1 U b.patch
2 A c.patch
% hg qunapplied
d.patch
% hg qunapplied -v
3 U d.patch
$ for patch in `hg qseries`; do
> echo % hg qapplied $patch
> hg qapplied $patch
> echo % hg qunapplied $patch
> hg qunapplied $patch
> done
% hg qapplied new.patch
new.patch
% hg qunapplied new.patch
b.patch
d.patch
% hg qapplied b.patch
new.patch
% hg qunapplied b.patch
d.patch
% hg qapplied c.patch
new.patch
c.patch
% hg qunapplied c.patch
d.patch
% hg qapplied d.patch
new.patch
c.patch
% hg qunapplied d.patch
hg qseries -m: only b.patch should be shown
the guards file was not ignored in the past
$ hg qdelete -k b.patch
$ hg qseries -m
b.patch
hg qseries -m with color
$ hg --config extensions.color= --config color.mode=ansi qseries -m --color=always
\x1b[0;31;1mb.patch\x1b[0m (esc)
excercise corner cases in "qselect --reapply"
$ hg qpop -a
popping c.patch
popping new.patch
patch queue now empty
$ hg qguard -- new.patch -not-new
$ hg qguard -- c.patch -not-c
$ hg qguard -- d.patch -not-d
$ hg qpush -a
applying new.patch
applying c.patch
applying d.patch
patch d.patch is empty
now at: d.patch
$ hg qguard -l
new.patch: -not-new
c.patch: -not-c
d.patch: -not-d
$ hg qselect --reapply not-d
popping guarded patches
popping d.patch
now at: c.patch
reapplying unguarded patches
cannot push 'd.patch' - guarded by '-not-d'
$ hg qser -v
0 A new.patch
1 A c.patch
2 G d.patch
$ hg qselect --reapply -n
guards deactivated
$ hg qpush
applying d.patch
patch d.patch is empty
now at: d.patch
$ hg qser -v
0 A new.patch
1 A c.patch
2 A d.patch
$ hg qselect --reapply not-c
popping guarded patches
popping d.patch
popping c.patch
now at: new.patch
reapplying unguarded patches
applying d.patch
patch d.patch is empty
now at: d.patch
$ hg qser -v
0 A new.patch
1 G c.patch
2 A d.patch
$ hg qselect --reapply not-new
popping guarded patches
popping d.patch
popping new.patch
patch queue now empty
reapplying unguarded patches
applying c.patch
applying d.patch
patch d.patch is empty
now at: d.patch
$ hg qser -v
0 G new.patch
1 A c.patch
2 A d.patch
test that qselect shows "number of guarded, applied patches" correctly
$ hg qimport -q -e b.patch
adding b.patch to series file
$ hg qguard -- b.patch -not-b
$ hg qpop -a -q
patch queue now empty
$ hg qunapplied -v
0 G new.patch
1 U c.patch
2 U d.patch
3 U b.patch
$ hg qselect not-new not-c
number of unguarded, unapplied patches has changed from 3 to 2
$ hg qpush -q -a
patch d.patch is empty
now at: b.patch
$ hg qapplied -v
0 G new.patch
1 G c.patch
2 A d.patch
3 A b.patch
$ hg qselect --none
guards deactivated
$ hg qselect not-new not-c not-d
number of guarded, applied patches has changed from 0 to 1
test that "qselect --reapply" reapplies patches successfully when the
already applied patch becomes unguarded and it follows the already
guarded (= not yet applied) one.
$ hg qpop -q -a
patch queue now empty
$ hg qselect not-new not-c
number of unguarded, unapplied patches has changed from 1 to 2
$ hg qpush -q -a
patch d.patch is empty
now at: b.patch
$ hg qapplied -v
0 G new.patch
1 G c.patch
2 A d.patch
3 A b.patch
$ hg qselect -q --reapply not-c not-b
now at: d.patch
cannot push 'b.patch' - guarded by '-not-b'
$ hg qseries -v
0 U new.patch
1 G c.patch
2 A d.patch
3 G b.patch
test that "qselect --reapply" checks applied patches correctly when no
applied patches becomes guarded but some of unapplied ones become
unguarded.
$ hg qpop -q -a
patch queue now empty
$ hg qselect not-new not-c not-d
number of unguarded, unapplied patches has changed from 2 to 1
$ hg qpush -q -a
now at: b.patch
$ hg qapplied -v
0 G new.patch
1 G c.patch
2 G d.patch
3 A b.patch
$ hg qselect -q --reapply not-new not-c
$ hg qseries -v
0 G new.patch
1 G c.patch
2 U d.patch
3 A b.patch