Test basic extension support

  $ cat > foobar.py <<EOF

  > import os

  > from mercurial import commands, registrar

  > cmdtable = {}

  > command = registrar.command(cmdtable)

  > def uisetup(ui):

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

  >     ui.flush()

  > def reposetup(ui, repo):

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

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

  >     ui.flush()

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

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

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

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

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

  >     ui.write("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

  reposetup called for a

  ui == repo.ui

  Foo

  $ cd ..

  $ hg clone a b

  uisetup called

  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

  Bar

  $ echo 'foobar = !' >> $HGRCPATH

module/__init__.py-style

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

  $ cd a

  $ hg foo

  uisetup called

  reposetup called for a

  ui == repo.ui

  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

  > EOF

  $ cp foo.py bar.py

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

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

Command with no output, we just want to see the extensions loaded:

  $ hg paths

  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 hgweb's load order:

  $ cat > hgweb.cgi <<EOF

  > from mercurial import demandimport; demandimport.enable()

  > from mercurial.hgweb import hgweb

  > from mercurial.hgweb import wsgicgi

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

  > wsgicgi.launch(application)

  > EOF

  $ REQUEST_METHOD='GET' PATH_INFO='/' SCRIPT_NAME='' QUERY_STRING='' \

  >    SERVER_PORT='80' SERVER_NAME='localhost' 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

  $ 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

#if absimport

  $ 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 (glob)

#endif

#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 (glob)

#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 (glob)

#if no-py3k

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

  $ 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 (glob)

#endif

#if demandimport absimport

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 "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 = "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 = "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 = "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 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 "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 = "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 = "this is absextroot.relimportee"

  > EOF

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

  > from __future__ import absolute_import

  > from ... import relimportee

  > detail = "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 = []