packagescan can't scan nested packages

mercurial/packagescan.py

@@ -1,113 +1,113 b''
 # packagescan.py - Helper module for identifing used modules.
 # Used for the py2exe distutil.
 # This module must be the first mercurial module imported in setup.py
 #
 # Copyright 2005 Volker Kleinfeld <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 import glob
 import os
 import sys
 import ihooks
 import types
 import string
 
 # Install this module as fake demandload module
 sys.modules['mercurial.demandload'] = sys.modules[__name__]
 
 # Requiredmodules contains the modules imported by demandload.
 # Please note that demandload can be invoked before the 
 # mercurial.packagescan.scan method is invoked in case a mercurial
 # module is imported.
 requiredmodules = {} 
 def demandload(scope, modules):
     """ fake demandload function that collects the required modules 
         foo            import foo
         foo bar        import foo, bar
         foo.bar        import foo.bar
         foo:bar        from foo import bar
         foo:bar,quux   from foo import bar, quux
         foo.bar:quux   from foo.bar import quux"""
 
     for m in modules.split():
         mod = None
         try:
             module, fromlist = m.split(':')
             fromlist = fromlist.split(',')
         except:
             module = m
             fromlist = []
         mod = __import__(module, scope, scope, fromlist)
         if fromlist == []:
             # mod is only the top package, but we need all packages
             comp = module.split('.')
             i = 1
             mn = comp[0]
             while True:
                 # mn and mod.__name__ might not be the same
                 scope[mn] = mod
                 requiredmodules[mod.__name__] = 1
                 if len(comp) == i: break
                 mod = getattr(mod,comp[i]) 
                 mn = string.join(comp[:i+1],'.')
                 i += 1
         else:
             # mod is the last package in the component list
             requiredmodules[mod.__name__] = 1
             for f in fromlist:
                 scope[f] = getattr(mod,f)
                 if type(scope[f]) == types.ModuleType:
                     requiredmodules[scope[f].__name__] = 1
 
 def scan(libpath,packagename):
     """ helper for finding all required modules of package <packagename> """
     # Use the package in the build directory
     libpath = os.path.abspath(libpath)
     sys.path.insert(0,libpath)
-    packdir = os.path.join(libpath,packagename)
+    packdir = os.path.join(libpath,packagename.replace('.', '/'))
     # A normal import would not find the package in
     # the build directory. ihook is used to force the import.
     # After the package is imported the import scope for
     # the following imports is settled.
     p = importfrom(packdir)
     globals()[packagename] = p
     sys.modules[packagename] = p
     # Fetch the python modules in the package
     cwd = os.getcwd()
     os.chdir(packdir)
     pymodulefiles = glob.glob('*.py')
     extmodulefiles = glob.glob('*.pyd')
     os.chdir(cwd)
     # Import all python modules and by that run the fake demandload
     for m in pymodulefiles:
         if m == '__init__.py': continue
         tmp = {}
         mname,ext = os.path.splitext(m)
         fullname = packagename+'.'+mname
         __import__(fullname,tmp,tmp)
         requiredmodules[fullname] = 1
     # Import all extension modules and by that run the fake demandload
     for m in extmodulefiles:
         tmp = {}
         mname,ext = os.path.splitext(m)
         fullname = packagename+'.'+mname
         __import__(fullname,tmp,tmp)
         requiredmodules[fullname] = 1
 
 def getmodules():
     return requiredmodules.keys()
 
 def importfrom(filename):
     """
     import module/package from a named file and returns the module.
     It does not check on sys.modules or includes the module in the scope.
     """
     loader = ihooks.BasicModuleLoader()
     path, file = os.path.split(filename)
     name, ext  = os.path.splitext(file)
     m = loader.find_module_in_dir(name, path)
     if not m:
         raise ImportError, name
     m = loader.load_module(name, m)
     return m

setup.py

@@ -1,104 +1,104 b''
 #!/usr/bin/env python
 #
 # This is the mercurial setup script.
 #
 # './setup.py install', or
 # './setup.py --help' for more options
 
 import sys
 if not hasattr(sys, 'version_info') or sys.version_info < (2, 3):
     raise SystemExit, "Mercurial requires python 2.3 or later."
 
 import glob
 from distutils.core import setup, Extension
 from distutils.command.install_data import install_data
 
 # mercurial.packagescan must be the first mercurial module imported
 import mercurial.packagescan
 import mercurial.version
 
 # py2exe needs to be installed to work
 try:
     import py2exe
 
     # Help py2exe to find win32com.shell
     try:
         import modulefinder
         import win32com
         for p in win32com.__path__[1:]: # Take the path to win32comext
             modulefinder.AddPackagePath("win32com", p)
         pn = "win32com.shell"
         __import__(pn)
         m = sys.modules[pn]
         for p in m.__path__[1:]:
             modulefinder.AddPackagePath(pn, p)
     except ImportError:
         pass
 
     # Due to the use of demandload py2exe is not finding the modules.
     # packagescan.getmodules creates a list of modules included in
     # the mercurial package plus depdent modules.
     from py2exe.build_exe import py2exe as build_exe
 
     class py2exe_for_demandload(build_exe):
         """ overwrites the py2exe command class for getting the build
         directory and for setting the 'includes' option."""
         def initialize_options(self):
             self.build_lib = None
             build_exe.initialize_options(self)
         def finalize_options(self):
             # Get the build directory, ie. where to search for modules.
             self.set_undefined_options('build',
                                        ('build_lib', 'build_lib'))
             # Sets the 'includes' option with the list of needed modules
             if not self.includes:
                 self.includes = []
             else:
                 self.includes = self.includes.split(',')
             mercurial.packagescan.scan(self.build_lib,'mercurial')
-            mercurial.packagescan.scan(self.build_lib,'mercurial/hgweb')
+            mercurial.packagescan.scan(self.build_lib,'mercurial.hgweb')
             mercurial.packagescan.scan(self.build_lib,'hgext')
             self.includes += mercurial.packagescan.getmodules()
             build_exe.finalize_options(self)
 except ImportError:
     py2exe_for_demandload = None
 
 
 # specify version string, otherwise 'hg identify' will be used:
 version = ''
 
 class install_package_data(install_data):
     def finalize_options(self):
         self.set_undefined_options('install',
                                    ('install_lib', 'install_dir'))
         install_data.finalize_options(self)
 
 mercurial.version.remember_version(version)
 cmdclass = {'install_data': install_package_data}
 py2exe_opts = {}
 if py2exe_for_demandload is not None:
     cmdclass['py2exe'] = py2exe_for_demandload
     py2exe_opts['console'] = ['hg']
 setup(name='mercurial',
         version=mercurial.version.get_version(),
         author='Matt Mackall',
         author_email='[e-mail]',
         url='http://selenic.com/mercurial',
         description='Scalable distributed SCM',
         license='GNU GPL',
         packages=['mercurial', 'mercurial.hgweb', 'hgext'],
         ext_modules=[Extension('mercurial.mpatch', ['mercurial/mpatch.c']),
                     Extension('mercurial.bdiff', ['mercurial/bdiff.c'])],
         data_files=[('mercurial/templates',
                     ['templates/map'] +
                     glob.glob('templates/map-*') +
                     glob.glob('templates/*.tmpl')),
                     ('mercurial/templates/static',
                     glob.glob('templates/static/*'))],
         cmdclass=cmdclass,
         scripts=['hg', 'hgmerge'],
         options=dict(bdist_mpkg=dict(zipdist=True,
                                     license='COPYING',
                                     readme='contrib/macosx/Readme.html',
                                     welcome='contrib/macosx/Welcome.html')),
         **py2exe_opts)