Test basic extension support

  $ cat > foobar.py <<EOF

  > import os

  > from mercurial import commands, registrar

  > cmdtable = {}

  > command = registrar.command(cmdtable)

  > configtable = {}

  > configitem = registrar.configitem(configtable)

  > configitem(b'tests', b'foo', default=b"Foo")

  > def uisetup(ui):

  >     ui.debug(b"uisetup called [debug]\\n")

  >     ui.write(b"uisetup called\\n")

  >     ui.status(b"uisetup called [status]\\n")

  >     ui.flush()

  > def reposetup(ui, repo):

  >     ui.write(b"reposetup called for %s\\n" % os.path.basename(repo.root))

  >     ui.write(b"ui %s= repo.ui\\n" % (ui == repo.ui and b"=" or b"!"))

  >     ui.flush()

  > @command(b'foo', [], b'hg foo')

  > def foo(ui, *args, **kwargs):

  >     foo = ui.config(b'tests', b'foo')

  >     ui.write(foo)

  >     ui.write(b"\\n")

  > @command(b'bar', [], b'hg bar', norepo=True)

  > def bar(ui, *args, **kwargs):

  >     ui.write(b"Bar\\n")

  > EOF

  $ abspath=`pwd`/foobar.py

  $ mkdir barfoo

  $ cp foobar.py barfoo/__init__.py

  $ barfoopath=`pwd`/barfoo

  $ hg init a

  $ cd a

  $ echo foo > file

  $ hg add file

  $ hg commit -m 'add file'

  $ echo '[extensions]' >> $HGRCPATH

  $ echo "foobar = $abspath" >> $HGRCPATH

  $ hg foo

  uisetup called

  uisetup called [status]

  reposetup called for a

  ui == repo.ui

  reposetup called for a (chg !)

  ui == repo.ui (chg !)

  Foo

  $ hg foo --quiet

  uisetup called (no-chg !)

  reposetup called for a (chg !)

  ui == repo.ui

  Foo

  $ hg foo --debug

  uisetup called [debug] (no-chg !)

  uisetup called (no-chg !)

  uisetup called [status] (no-chg !)

  reposetup called for a (chg !)

  ui == repo.ui

  Foo

  $ cd ..

  $ hg clone a b

  uisetup called (no-chg !)

  uisetup called [status] (no-chg !)

  reposetup called for a

  ui == repo.ui

  reposetup called for b

  ui == repo.ui

  updating to branch default

  1 files updated, 0 files merged, 0 files removed, 0 files unresolved

  $ hg bar

  uisetup called (no-chg !)

  uisetup called [status] (no-chg !)

  Bar

  $ echo 'foobar = !' >> $HGRCPATH

module/__init__.py-style

  $ echo "barfoo = $barfoopath" >> $HGRCPATH

  $ cd a

  $ hg foo

  uisetup called

  uisetup called [status]

  reposetup called for a

  ui == repo.ui

  reposetup called for a (chg !)

  ui == repo.ui (chg !)

  Foo

  $ echo 'barfoo = !' >> $HGRCPATH

Check that extensions are loaded in phases:

  $ cat > foo.py <<EOF

  > import os

  > name = os.path.basename(__file__).rsplit('.', 1)[0]

  > print("1) %s imported" % name)

  > def uisetup(ui):

  >     print("2) %s uisetup" % name)

  > def extsetup():

  >     print("3) %s extsetup" % name)

  > def reposetup(ui, repo):

  >    print("4) %s reposetup" % name)

  > 

  > bytesname = name.encode('utf-8')

  > # custom predicate to check registration of functions at loading

  > from mercurial import (

  >     registrar,

  >     smartset,

  > )

  > revsetpredicate = registrar.revsetpredicate()

  > @revsetpredicate(bytesname, safe=True) # safe=True for query via hgweb

  > def custompredicate(repo, subset, x):

  >     return smartset.baseset([r for r in subset if r in {0}])

  > EOF

  $ cp foo.py bar.py

  $ echo 'foo = foo.py' >> $HGRCPATH

  $ echo 'bar = bar.py' >> $HGRCPATH

Check normal command's load order of extensions and registration of functions

  $ hg log -r "foo() and bar()" -q

  1) foo imported

  1) bar imported

  2) foo uisetup

  2) bar uisetup

  3) foo extsetup

  3) bar extsetup

  4) foo reposetup

  4) bar reposetup

  0:c24b9ac61126

Check hgweb's load order of extensions and registration of functions

  $ cat > hgweb.cgi <<EOF

  > #!$PYTHON

  > from mercurial import demandimport; demandimport.enable()

  > from mercurial.hgweb import hgweb

  > from mercurial.hgweb import wsgicgi

  > application = hgweb(b'.', b'test repo')

  > wsgicgi.launch(application)

  > EOF

  $ . "$TESTDIR/cgienv"

  $ PATH_INFO='/' SCRIPT_NAME='' "$PYTHON" hgweb.cgi \

  >    | grep '^[0-9]) ' # ignores HTML output

  1) foo imported

  1) bar imported

  2) foo uisetup

  2) bar uisetup

  3) foo extsetup

  3) bar extsetup

  4) foo reposetup

  4) bar reposetup

(check that revset predicate foo() and bar() are available)

#if msys

  $ PATH_INFO='//shortlog'

#else

  $ PATH_INFO='/shortlog'

#endif

  $ export PATH_INFO

  $ SCRIPT_NAME='' QUERY_STRING='rev=foo() and bar()' "$PYTHON" hgweb.cgi \

  >     | grep '<a href="/rev/[0-9a-z]*">'

     <a href="/rev/c24b9ac61126">add file</a>

  $ echo 'foo = !' >> $HGRCPATH

  $ echo 'bar = !' >> $HGRCPATH

Check "from __future__ import absolute_import" support for external libraries

#if windows

  $ PATHSEP=";"

#else

  $ PATHSEP=":"

#endif

  $ export PATHSEP

  $ mkdir $TESTTMP/libroot

  $ echo "s = 'libroot/ambig.py'" > $TESTTMP/libroot/ambig.py

  $ mkdir $TESTTMP/libroot/mod

  $ touch $TESTTMP/libroot/mod/__init__.py

  $ echo "s = 'libroot/mod/ambig.py'" > $TESTTMP/libroot/mod/ambig.py

  $ cat > $TESTTMP/libroot/mod/ambigabs.py <<EOF

  > from __future__ import absolute_import

  > import ambig # should load "libroot/ambig.py"

  > s = ambig.s

  > EOF

  $ cat > loadabs.py <<EOF

  > import mod.ambigabs as ambigabs

  > def extsetup():

  >     print('ambigabs.s=%s' % ambigabs.s)

  > EOF

  $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}/libroot; hg --config extensions.loadabs=loadabs.py root)

  ambigabs.s=libroot/ambig.py

  $TESTTMP/a

#if no-py3k

  $ cat > $TESTTMP/libroot/mod/ambigrel.py <<EOF

  > import ambig # should load "libroot/mod/ambig.py"

  > s = ambig.s

  > EOF

  $ cat > loadrel.py <<EOF

  > import mod.ambigrel as ambigrel

  > def extsetup():

  >     print('ambigrel.s=%s' % ambigrel.s)

  > EOF

  $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}/libroot; hg --config extensions.loadrel=loadrel.py root)

  ambigrel.s=libroot/mod/ambig.py

  $TESTTMP/a

#endif

Check absolute/relative import of extension specific modules

  $ mkdir $TESTTMP/extroot

  $ cat > $TESTTMP/extroot/bar.py <<EOF

  > s = 'this is extroot.bar'

  > EOF

  $ mkdir $TESTTMP/extroot/sub1

  $ cat > $TESTTMP/extroot/sub1/__init__.py <<EOF

  > s = 'this is extroot.sub1.__init__'

  > EOF

  $ cat > $TESTTMP/extroot/sub1/baz.py <<EOF

  > s = 'this is extroot.sub1.baz'

  > EOF

  $ cat > $TESTTMP/extroot/__init__.py <<EOF

  > s = 'this is extroot.__init__'

  > import foo

  > def extsetup(ui):

  >     ui.write('(extroot) ', foo.func(), '\n')

  >     ui.flush()

  > EOF

  $ cat > $TESTTMP/extroot/foo.py <<EOF

  > # test absolute import

  > buf = []

  > def func():

  >     # "not locals" case

  >     import extroot.bar

  >     buf.append('import extroot.bar in func(): %s' % extroot.bar.s)

  >     return '\n(extroot) '.join(buf)

  > # "fromlist == ('*',)" case

  > from extroot.bar import *

  > buf.append('from extroot.bar import *: %s' % s)

  > # "not fromlist" and "if '.' in name" case

  > import extroot.sub1.baz

  > buf.append('import extroot.sub1.baz: %s' % extroot.sub1.baz.s)

  > # "not fromlist" and NOT "if '.' in name" case

  > import extroot

  > buf.append('import extroot: %s' % extroot.s)

  > # NOT "not fromlist" and NOT "level != -1" case

  > from extroot.bar import s

  > buf.append('from extroot.bar import s: %s' % s)

  > EOF

  $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}; hg --config extensions.extroot=$TESTTMP/extroot root)

  (extroot) from extroot.bar import *: this is extroot.bar

  (extroot) import extroot.sub1.baz: this is extroot.sub1.baz

  (extroot) import extroot: this is extroot.__init__

  (extroot) from extroot.bar import s: this is extroot.bar

  (extroot) import extroot.bar in func(): this is extroot.bar

  $TESTTMP/a

#if no-py3k

  $ rm "$TESTTMP"/extroot/foo.*

  $ rm -Rf "$TESTTMP/extroot/__pycache__"

  $ cat > $TESTTMP/extroot/foo.py <<EOF

  > # test relative import

  > buf = []

  > def func():

  >     # "not locals" case

  >     import bar

  >     buf.append('import bar in func(): %s' % bar.s)

  >     return '\n(extroot) '.join(buf)

  > # "fromlist == ('*',)" case

  > from bar import *

  > buf.append('from bar import *: %s' % s)

  > # "not fromlist" and "if '.' in name" case

  > import sub1.baz

  > buf.append('import sub1.baz: %s' % sub1.baz.s)

  > # "not fromlist" and NOT "if '.' in name" case

  > import sub1

  > buf.append('import sub1: %s' % sub1.s)

  > # NOT "not fromlist" and NOT "level != -1" case

  > from bar import s

  > buf.append('from bar import s: %s' % s)

  > EOF

  $ hg --config extensions.extroot=$TESTTMP/extroot root

  (extroot) from bar import *: this is extroot.bar

  (extroot) import sub1.baz: this is extroot.sub1.baz

  (extroot) import sub1: this is extroot.sub1.__init__

  (extroot) from bar import s: this is extroot.bar

  (extroot) import bar in func(): this is extroot.bar

  $TESTTMP/a

#endif

#if demandimport

Examine whether module loading is delayed until actual referring, even

though module is imported with "absolute_import" feature.

Files below in each packages are used for described purpose:

- "called": examine whether "from MODULE import ATTR" works correctly

- "unused": examine whether loading is delayed correctly

- "used":   examine whether "from PACKAGE import MODULE" works correctly

Package hierarchy is needed to examine whether demand importing works

as expected for "from SUB.PACK.AGE import MODULE".

Setup "external library" to be imported with "absolute_import"

feature.

  $ mkdir -p $TESTTMP/extlibroot/lsub1/lsub2

  $ touch $TESTTMP/extlibroot/__init__.py

  $ touch $TESTTMP/extlibroot/lsub1/__init__.py

  $ touch $TESTTMP/extlibroot/lsub1/lsub2/__init__.py

  $ cat > $TESTTMP/extlibroot/lsub1/lsub2/called.py <<EOF

  > def func():

  >     return b"this is extlibroot.lsub1.lsub2.called.func()"

  > EOF

  $ cat > $TESTTMP/extlibroot/lsub1/lsub2/unused.py <<EOF

  > raise Exception("extlibroot.lsub1.lsub2.unused is loaded unintentionally")

  > EOF

  $ cat > $TESTTMP/extlibroot/lsub1/lsub2/used.py <<EOF

  > detail = b"this is extlibroot.lsub1.lsub2.used"

  > EOF

Setup sub-package of "external library", which causes instantiation of

demandmod in "recurse down the module chain" code path. Relative

importing with "absolute_import" feature isn't tested, because "level

>=1 " doesn't cause instantiation of demandmod.

  $ mkdir -p $TESTTMP/extlibroot/recursedown/abs

  $ cat > $TESTTMP/extlibroot/recursedown/abs/used.py <<EOF

  > detail = b"this is extlibroot.recursedown.abs.used"

  > EOF

  $ cat > $TESTTMP/extlibroot/recursedown/abs/__init__.py <<EOF

  > from __future__ import absolute_import

  > from extlibroot.recursedown.abs.used import detail

  > EOF

  $ mkdir -p $TESTTMP/extlibroot/recursedown/legacy

  $ cat > $TESTTMP/extlibroot/recursedown/legacy/used.py <<EOF

  > detail = b"this is extlibroot.recursedown.legacy.used"

  > EOF

  $ cat > $TESTTMP/extlibroot/recursedown/legacy/__init__.py <<EOF

  > # legacy style (level == -1) import

  > from extlibroot.recursedown.legacy.used import detail

  > EOF

  $ cat > $TESTTMP/extlibroot/recursedown/__init__.py <<EOF

  > from __future__ import absolute_import

  > from extlibroot.recursedown.abs import detail as absdetail

  > from .legacy import detail as legacydetail

  > EOF

Setup package that re-exports an attribute of its submodule as the same

name. This leaves 'shadowing.used' pointing to 'used.detail', but still

the submodule 'used' should be somehow accessible. (issue5617)

  $ mkdir -p $TESTTMP/extlibroot/shadowing

  $ cat > $TESTTMP/extlibroot/shadowing/used.py <<EOF

  > detail = b"this is extlibroot.shadowing.used"

  > EOF

  $ cat > $TESTTMP/extlibroot/shadowing/proxied.py <<EOF

  > from __future__ import absolute_import

  > from extlibroot.shadowing.used import detail

  > EOF

  $ cat > $TESTTMP/extlibroot/shadowing/__init__.py <<EOF

  > from __future__ import absolute_import

  > from .used import detail as used

  > EOF

Setup extension local modules to be imported with "absolute_import"

feature.

  $ mkdir -p $TESTTMP/absextroot/xsub1/xsub2

  $ touch $TESTTMP/absextroot/xsub1/__init__.py

  $ touch $TESTTMP/absextroot/xsub1/xsub2/__init__.py

  $ cat > $TESTTMP/absextroot/xsub1/xsub2/called.py <<EOF

  > def func():

  >     return b"this is absextroot.xsub1.xsub2.called.func()"

  > EOF

  $ cat > $TESTTMP/absextroot/xsub1/xsub2/unused.py <<EOF

  > raise Exception("absextroot.xsub1.xsub2.unused is loaded unintentionally")

  > EOF

  $ cat > $TESTTMP/absextroot/xsub1/xsub2/used.py <<EOF

  > detail = b"this is absextroot.xsub1.xsub2.used"

  > EOF

Setup extension local modules to examine whether demand importing

works as expected in "level > 1" case.

  $ cat > $TESTTMP/absextroot/relimportee.py <<EOF

  > detail = b"this is absextroot.relimportee"

  > EOF

  $ cat > $TESTTMP/absextroot/xsub1/xsub2/relimporter.py <<EOF

  > from __future__ import absolute_import

  > from ... import relimportee

  > detail = b"this relimporter imports %r" % (relimportee.detail)

  > EOF

Setup modules, which actually import extension local modules at

runtime.

  $ cat > $TESTTMP/absextroot/absolute.py << EOF

  > from __future__ import absolute_import

  > 

  > # import extension local modules absolutely (level = 0)

  > from absextroot.xsub1.xsub2 import used, unused

  > from absextroot.xsub1.xsub2.called import func

  > 

  > def getresult():

  >     result = []

  >     result.append(used.detail)

  >     result.append(func())

  >     return result

  > EOF

  $ cat > $TESTTMP/absextroot/relative.py << EOF

  > from __future__ import absolute_import

  > 

  > # import extension local modules relatively (level == 1)

  > from .xsub1.xsub2 import used, unused

  > from .xsub1.xsub2.called import func

  > 

  > # import a module, which implies "importing with level > 1"

  > from .xsub1.xsub2 import relimporter

  > 

  > def getresult():

  >     result = []

  >     result.append(used.detail)

  >     result.append(func())

  >     result.append(relimporter.detail)

  >     return result

  > EOF

Setup main procedure of extension.

  $ cat > $TESTTMP/absextroot/__init__.py <<EOF

  > from __future__ import absolute_import

  > from mercurial import registrar

  > cmdtable = {}

  > command = registrar.command(cmdtable)

  > 

  > # "absolute" and "relative" shouldn't be imported before actual

  > # command execution, because (1) they import same modules, and (2)

  > # preceding import (= instantiate "demandmod" object instead of

  > # real "module" object) might hide problem of succeeding import.

  > 

  > @command(b'showabsolute', [], norepo=True)

  > def showabsolute(ui, *args, **opts):

  >     from absextroot import absolute

  >     ui.write(b'ABS: %s\n' % '\nABS: '.join(absolute.getresult()))

  > 

  > @command(b'showrelative', [], norepo=True)

  > def showrelative(ui, *args, **opts):

  >     from . import relative

  >     ui.write(b'REL: %s\n' % '\nREL: '.join(relative.getresult()))

  > 

  > # import modules from external library

  > from extlibroot.lsub1.lsub2 import used as lused, unused as lunused

  > from extlibroot.lsub1.lsub2.called import func as lfunc

  > from extlibroot.recursedown import absdetail, legacydetail

  > from extlibroot.shadowing import proxied

  > 

  > def uisetup(ui):

  >     result = []

  >     result.append(lused.detail)

  >     result.append(lfunc())

  >     result.append(absdetail)

  >     result.append(legacydetail)

  >     result.append(proxied.detail)

  >     ui.write(b'LIB: %s\n' % '\nLIB: '.join(result))

  > EOF

Examine module importing.