Re: Mk4py build & test Q

#! /usr/bin/env python

from distutils.core import setup, Extension, Command
from distutils.command.build import build
from distutils.command.build_ext import build_ext
from distutils.command.config import config
from distutils.msvccompiler import MSVCCompiler
from distutils import sysconfig
import string
import sys
import os

mkobjs = ['column', 'custom', 'derived', 'fileio', 'field',
          'format', 'handler', 'persist', 'remap', 'std',
          'store', 'string', 'table', 'univ', 'view', 'viewx']

mksrc = [os.path.join("..", "src", "%s.cpp" % x) for x in mkobjs]

class configure(Command):
    def initialize_options (self):
        self.configure_path=os.path.abspath("../unix/configure")
        self.build_temp = None
        
    def finalize_options (self):
        if self.build_temp is None:
            self.build_temp = self.get_finalized_command('build').build_temp
            bc = self.get_finalized_command('build_ext')
            if sys.platform=='win32':
                # instead of running configure use ../win/config.h
                bc.include_dirs.append('../win')
##                 if bc.compiler=='mingw32':
##                       bc.libraries.append('stdc++')
            else:
                bc.include_dirs.append(self.build_temp)

          
    def run (self):
        if sys.platform=='win32':
            return
        
        if os.path.exists(os.path.join(self.build_temp, "config.h")):
            return

        self.mkpath(self.build_temp)
        cwd = os.getcwd()
        
        try:
            os.chdir(self.build_temp)
            res=os.system(self.configure_path)
            if res!=0:
                raise SystemExit("configure failed")
        finally:
            os.chdir(cwd)

class build_mk(build):
    def initialize_options(self):
        # build in builds directory by default, unless specified otherwise
        build.initialize_options(self)
        self.build_base = '../builds'

class build_mkext(build_ext):
    def run(self):
        self.run_command('configure')
        build_ext.run(self)
        
    def finalize_options(self):
        # force use of C++ compiler (helps on some platforms)
        import os
        cc = os.environ.get('CXX', sysconfig.get_config_var('CXX'))
        if not cc:
            cc = sysconfig.get_config_var('CCC') # Python 1.5.2
        if cc:
            os.environ['CC'] = cc

        build_ext.finalize_options(self)

    def build_extension(self, ext):
        # work around linker problem with MacPython 2.3
        if sys.platform == 'darwin':
            try:
                self.compiler.linker_so.remove("-Wl,-x")
            except: pass
        # work around linker problem with Linux, Python 2.2 and earlier:
        # despite setting $CC above, still uses Python compiler
        if sys.platform == 'linux2':
            try:
                ext.libraries.append("stdc++")
            except: pass
        if ext.name == "Mk4py":
            if isinstance(self.compiler, MSVCCompiler):
                suffix = '.obj'
                if self.debug:
                    prefix = '../builds/msvc60/mklib/Debug/'
                else:
                    prefix = '../builds/msvc60/mklib/Release/'
            else:
                suffix = '.o'
                prefix = '../builds/'
            for i in range(len(ext.extra_objects)):
                nm = ext.extra_objects[i]
                if nm in mkobjs:
                    if string.find(nm, '.') == -1:
                        nm = nm + suffix
                    nm = prefix + nm
                    ext.extra_objects[i] = nm
        build_ext.build_extension(self, ext)
    
class test_regrtest(Command):
    # Original version of this class posted
    # by Berthold Hoellmann to [email protected]
    description = "test the distribution prior to install"

    user_options = [
        ('build-base=', 'b',
         "base build directory (default: 'build.build-base')"),
        ('build-purelib=', None,
         "build directory for platform-neutral distributions"),
        ('build-platlib=', None,
         "build directory for platform-specific distributions"),
        ('build-lib=', None,
         "build directory for all distribution (defaults to either " +
         "build-purelib or build-platlib"),
        ('test-dir=', None,
         "directory that contains the test definitions"),
        ('test-options=', None,
         "command-line options to pass to test.regrtest")
        ]

    def initialize_options(self):
        self.build_base = None
        # these are decided only after 'build_base' has its final value
        # (unless overridden by the user or client)
        self.build_purelib = None
        self.build_platlib = None
        self.test_dir = 'test'
        self.test_options = None
        
    def finalize_options(self):
        build = self.distribution.get_command_obj('build')
        build_options = ('build_base', 'build_purelib', 'build_platlib')
        for option in build_options:
            val = getattr(self, option)
            if val:
                setattr(build, option, getattr(self, option))
        build.ensure_finalized()
        for option in build_options:
            setattr(self, option, getattr(build, option))

    def run(self):
        
        # Invoke the 'build' command to "build" pure Python modules
        # (ie. copy 'em into the build tree)
        self.run_command('build')

        # remember old sys.path to restore it afterwards
        old_path = sys.path[:]

        # extend sys.path
        sys.path.insert(0, self.build_purelib)
        sys.path.insert(0, self.build_platlib)
        sys.path.insert(0, self.test_dir)
        
        # Use test.regrtest, unlike the original version of this class
        import test.regrtest

	# jcw 2004-04-26 - why do I need to add these here to find the tests?
	#import leaktest - not very portable
	import test_inttypes
	import test_stringtype
	#import test_hash - doesn't work
	# jcw end

        test.regrtest.STDTESTS = []
        test.regrtest.NOTTESTS = []

        if self.test_options:
            sys.argv[1:] = string.split(self.test_options, ' ')
        else:
            del sys.argv[1:]

        # remove stale modules
        del sys.modules['metakit']
        try:
            del sys.modules['Mk4py']
        except:
            pass

        self.announce("running tests")
        test.regrtest.main(testdir=self.test_dir)

        # restore sys.path
        sys.path = old_path[:]

try:
    import metakit
except:
    metakit = sys.modules['metakit']

setup(name             = metakit.__name__,
      version          = metakit.__version__,
      description      = metakit.__description__,
      long_description = metakit.__doc__,
      author           = metakit.__author__,
      author_email     = metakit.__email__,
      url              = metakit.__url__,
      maintainer       = metakit.__author__,
      maintainer_email = metakit.__email__,
      license          = metakit.__license__,
      keywords         = ['database'],
      py_modules       = ['metakit'],
      cmdclass         = {'build': build_mk, 'build_ext': build_mkext,
                          'test': test_regrtest, #'config': config_mk,
                          'configure': configure},
      ext_modules      = [Extension("Mk4py",
                                    sources=["PyProperty.cpp",
                                             "PyRowRef.cpp",
                                             "PyStorage.cpp",
                                             "PyView.cpp",
                                             "scxx/PWOImp.cpp",
                                             ]+mksrc,
                                    include_dirs=["scxx",
                                                  "../include"],
                                    define_macros=[("HAVE_CONFIG_H", 1), ("q4_CHECK", 1)],

                                    #extra_objects=mkobjs,
                                    )]
      )

## Local Variables:
## compile-command: "python setup.py build -b ../builds"
## End: