setup.py: install packagescan before any mercurial modules is imported

Further the installation of packagescan over demandload is moved to the
packagescan module.

I added as well few more comments in the packagescan module to avoid
the wrong use of package scan in the future.

Reason:

mercurial.packagescan acts as fake mercurial.demandload during a py2exe
run.  Unfortunatly the import of mercurial.version in setup.py is done
before mercurial.packagescan is installed. This results in few imports
without mercurial.packagescan in charge and therefore not all dependend
modules are detected when running mercurial.packagescan.getmodules
later e.g.  winerror is missed.

mercurial/packagescan.py

@@ -1,80 +1,86 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 demandload
 import ihooks
 
-requiredmodules = {} # Will contain the modules imported by demandload
+# 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 """
     for m in modules.split():
         mod = None
         try:
             module, submodules = m.split(':')
             submodules = submodules.split(',')
         except:
             module = m
             submodules = []
         mod = __import__(module, scope, scope, submodules)
         scope[module] = mod
         requiredmodules[mod.__name__] = 1
 
-def getmodules(libpath,packagename):
+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)
     # 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)
-    # Install a fake demandload module
-    sys.modules['mercurial.demandload'] = sys.modules['mercurial.packagescan']
     # 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
-    includes = requiredmodules.keys()
-    return includes
+
+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,103 +1,103 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.
-    import mercurial.packagescan
     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(',')
-            self.includes += mercurial.packagescan.getmodules(self.build_lib,
-                                                              'mercurial')
-            self.includes += mercurial.packagescan.getmodules(self.build_lib,
-                                                              'hgext')
+            mercurial.packagescan.scan(self.build_lib,'mercurial')
+            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', '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)