# # SConstruct file to build scons packages during development. # # See the README.rst file for an overview of how SCons is built and tested. copyright_years = '2001 - 2019' # This gets inserted into the man pages to reflect the month of release. month_year = 'December 2019' # # __COPYRIGHT__ # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # import fnmatch import os import os.path import sys import textwrap import bootstrap project = 'scons' default_version = '3.1.2' copyright = "Copyright (c) %s The SCons Foundation" % copyright_years # # We let the presence or absence of various utilities determine whether # or not we bother to build certain pieces of things. This should allow # people to still do SCons packaging work even if they don't have all # of the utilities installed # print("git :%s"%git) print("gzip :%s"%gzip) print("unzip :%s"%unzip) print("zip :%s"%zip_path) # # Adding some paths to sys.path, this is mainly needed # for the doc toolchain. # addpaths = [os.path.abspath(os.path.join(os.getcwd(), 'bin')), os.path.abspath(os.path.join(os.getcwd(), 'testing/framework'))] for a in addpaths: if a not in sys.path: sys.path.append(a) command_line = BuildCommandLine(default_version) command_line.process_command_line_vars() Default('.', command_line.build_dir) # Just make copies, don't symlink them. SetOption('duplicate', 'copy') packaging_flavors = [ ('tar-gz', "The normal .tar.gz file for end-user installation."), ('local-tar-gz', "A .tar.gz file for dropping into other software " + "for local use."), ('zip', "The normal .zip file for end-user installation."), ('local-zip', "A .zip file for dropping into other software " + "for local use."), ('src-tar-gz', "A .tar.gz file containing all the source " + "(including tests and documentation)."), ('src-zip', "A .zip file containing all the source " + "(including tests and documentation)."), ] test_tar_gz_dir = os.path.join(command_line.build_dir, "test-tar-gz") test_src_tar_gz_dir = os.path.join(command_line.build_dir, "test-src-tar-gz") test_local_tar_gz_dir = os.path.join(command_line.build_dir, "test-local-tar-gz") test_zip_dir = os.path.join(command_line.build_dir, "test-zip") test_src_zip_dir = os.path.join(command_line.build_dir, "test-src-zip") test_local_zip_dir = os.path.join(command_line.build_dir, "test-local-zip") unpack_tar_gz_dir = os.path.join(command_line.build_dir, "unpack-tar-gz") unpack_zip_dir = os.path.join(command_line.build_dir, "unpack-zip") if is_windows(): tar_hflag = '' python_project_subinst_dir = os.path.join("Lib", "site-packages", project) project_script_subinst_dir = 'Scripts' else: tar_hflag = 'h' python_project_subinst_dir = os.path.join("lib", project) project_script_subinst_dir = 'bin' indent_fmt = ' %-26s ' Help("""\ The following aliases build packages of various types, and unpack the contents into build/test-$PACKAGE subdirectories, which can be used by the runtest.py -p option to run tests against what's been actually packaged: """) aliases = sorted(packaging_flavors + [('doc', 'The SCons documentation.')]) for alias, help_text in aliases: tw = textwrap.TextWrapper( width=78, initial_indent=indent_fmt % alias, subsequent_indent=indent_fmt % '' + ' ', ) Help(tw.fill(help_text) + '\n') Help(""" The following command-line variables can be set: """) for variable, help_text in command_line.command_line_variables: tw = textwrap.TextWrapper( width=78, initial_indent=indent_fmt % variable, subsequent_indent=indent_fmt % '' + ' ', ) Help(tw.fill(help_text) + '\n') revaction = SCons_revision revbuilder = Builder(action=Action(SCons_revision, varlist=['COPYRIGHT', 'VERSION'])) env = Environment( ENV=command_line.ENV, BUILD=command_line.build_id, BUILDDIR=command_line.build_dir, BUILDSYS=command_line.build_system, COPYRIGHT=copyright, DATE=command_line.date, DEB_DATE=deb_date, DEVELOPER=command_line.developer, DISTDIR=os.path.join(command_line.build_dir, 'dist'), MONTH_YEAR=month_year, REVISION=command_line.revision, VERSION=command_line.version, TAR_HFLAG=tar_hflag, ZIP=zip_path, ZIPFLAGS='-r', UNZIP=unzip, UNZIPFLAGS='-o -d $UNPACK_ZIP_DIR', ZCAT=zcat, TEST_SRC_TAR_GZ_DIR=test_src_tar_gz_dir, TEST_SRC_ZIP_DIR=test_src_zip_dir, TEST_TAR_GZ_DIR=test_tar_gz_dir, TEST_ZIP_DIR=test_zip_dir, UNPACK_TAR_GZ_DIR=unpack_tar_gz_dir, UNPACK_ZIP_DIR=unpack_zip_dir, BUILDERS={'SCons_revision': revbuilder, 'SOElim': soelimbuilder}, PYTHON='"%s"' % sys.executable, PYTHONFLAGS='-tt', ) Version_values = [Value(command_line.version), Value(command_line.build_id)] # # Define SCons packages. # # In the original, more complicated packaging scheme, we were going # to have separate packages for: # # python-scons only the build engine # scons-script only the script # scons the script plus the build engine # # We're now only delivering a single "scons" package, but this is still # "built" as two sub-packages (the build engine and the script), so # the definitions remain here, even though we're not using them for # separate packages. # from distutils.sysconfig import get_python_lib python_scons = { 'pkg': 'python-' + project, 'src_subdir': 'engine', 'inst_subdir': get_python_lib(), 'files': ['LICENSE.txt', 'README.txt', 'setup.cfg', 'setup.py', ], 'filemap': { 'LICENSE.txt': '../LICENSE.txt' }, 'buildermap': {}, 'explicit_deps': { 'SCons/__init__.py': Version_values, }, } scons_script = { 'pkg': project + '-script', 'src_subdir': 'script', 'inst_subdir': 'bin', 'files': [ 'LICENSE.txt', 'README.txt', 'setup.cfg', 'setup.py', ], 'filemap': { 'LICENSE.txt': '../LICENSE.txt', 'scons': 'scons.py', 'sconsign': 'sconsign.py', 'scons-time': 'scons-time.py', 'scons-configure-cache': 'scons-configure-cache.py', }, 'buildermap': {}, 'explicit_deps': { 'scons': Version_values, 'sconsign': Version_values, }, } scons = { 'pkg': project, 'files': [ 'CHANGES.txt', 'LICENSE.txt', 'README.txt', 'RELEASE.txt', 'scons.1', 'sconsign.1', 'scons-time.1', 'script/scons.bat', 'setup.cfg', 'setup.py', ], 'filemap': { 'scons.1': '$BUILDDIR/doc/man/scons.1', 'sconsign.1': '$BUILDDIR/doc/man/sconsign.1', 'scons-time.1': '$BUILDDIR/doc/man/scons-time.1', }, 'buildermap': { 'scons.1': env.SOElim, 'sconsign.1': env.SOElim, 'scons-time.1': env.SOElim, }, 'subpkgs': [python_scons, scons_script], 'subinst_dirs': { 'python-' + project: python_project_subinst_dir, project + '-script': project_script_subinst_dir, }, } scripts = ['scons', 'sconsign', 'scons-time', 'scons-configure-cache'] src_deps = [] src_files = [] for p in [scons]: # # Initialize variables with the right directories for this package. # pkg = p['pkg'] pkg_version = "%s-%s" % (pkg, command_line.version) src = 'src' if 'src_subdir' in p: src = os.path.join(src, p['src_subdir']) build = os.path.join(command_line.build_dir, pkg) tar_gz = os.path.join(build, 'dist', "%s.tar.gz" % pkg_version) platform_tar_gz = os.path.join(build, 'dist', "%s.%s.tar.gz" % (pkg_version, platform)) zip = os.path.join(build, 'dist', "%s.zip" % pkg_version) platform_zip = os.path.join(build, 'dist', "%s.%s.zip" % (pkg_version, platform)) # # Update the environment with the relevant information # for this package. # # We can get away with calling setup.py using a directory path # like this because we put a preamble in it that will chdir() # to the directory in which setup.py exists. # setup_py = os.path.join(build, 'setup.py') env.Replace(PKG=pkg, PKG_VERSION=pkg_version, SETUP_PY='"%s"' % setup_py) Local(setup_py) # # Read up the list of source files from our MANIFEST.in. # This list should *not* include LICENSE.txt, MANIFEST, # README.txt, or setup.py. Make a copy of the list for the # destination files. # manifest_in = File(os.path.join(src, 'MANIFEST.in')).rstr() src_files = bootstrap.parseManifestLines(src, manifest_in) raw_files = src_files[:] dst_files = src_files[:] MANIFEST_in_list = [] if 'subpkgs' in p: # # This package includes some sub-packages. Read up their # MANIFEST.in files, and add them to our source and destination # file lists, modifying them as appropriate to add the # specified subdirs. # for sp in p['subpkgs']: ssubdir = sp['src_subdir'] isubdir = p['subinst_dirs'][sp['pkg']] MANIFEST_in = File(os.path.join(src, ssubdir, 'MANIFEST.in')).rstr() MANIFEST_in_list.append(MANIFEST_in) files = bootstrap.parseManifestLines(os.path.join(src, ssubdir), MANIFEST_in) raw_files.extend(files) src_files.extend([os.path.join(ssubdir, x) for x in files]) files = [os.path.join(isubdir, x) for x in files] dst_files.extend(files) for k, f in sp['filemap'].items(): if f: k = os.path.join(ssubdir, k) p['filemap'][k] = os.path.join(ssubdir, f) for f, deps in sp['explicit_deps'].items(): f = os.path.join(build, ssubdir, f) env.Depends(f, deps) # # Now that we have the "normal" source files, add those files # that are standard for each distribution. Note that we don't # add these to dst_files, because they don't get installed. # And we still have the MANIFEST to add. # src_files.extend(p['files']) # # Now run everything in src_file through the sed command we # concocted to expand __FILE__, __VERSION__, etc. # for b in src_files: s = p['filemap'].get(b, b) if not s[0] == '$' and not os.path.isabs(s): s = os.path.join(src, s) builder = p['buildermap'].get(b, env.SCons_revision) x = builder(os.path.join(build, b), s) Local(x) # # NOW, finally, we can create the MANIFEST, which we do # by having Python spit out the contents of the src_files # array we've carefully created. After we've added # MANIFEST itself to the array, of course. # src_files.append("MANIFEST") MANIFEST_in_list.append(os.path.join(src, 'MANIFEST.in')) def write_src_files(target, source, **kw): global src_files src_files.sort() with open(str(target[0]), 'w') as f: for file in src_files: f.write(file + "\n") return 0 env.Command(os.path.join(build, 'MANIFEST'), MANIFEST_in_list, write_src_files) # # Now go through and arrange to create whatever packages we can. # build_src_files = [os.path.join(build, x) for x in src_files] Local(*build_src_files) distutils_formats = [] distutils_targets = [] dist_distutils_targets = [] for target in distutils_targets: dist_target = env.Install('$DISTDIR', target) AddPostAction(dist_target, Chmod(dist_target, 0o644)) dist_distutils_targets += dist_target if not gzip: print("gzip not found in %s; skipping .tar.gz package for %s." % (os.environ['PATH'], pkg)) else: distutils_formats.append('gztar') src_deps.append(tar_gz) distutils_targets.extend([tar_gz, platform_tar_gz]) dist_tar_gz = env.Install('$DISTDIR', tar_gz) dist_platform_tar_gz = env.Install('$DISTDIR', platform_tar_gz) Local(dist_tar_gz, dist_platform_tar_gz) AddPostAction(dist_tar_gz, Chmod(dist_tar_gz, 0o644)) AddPostAction(dist_platform_tar_gz, Chmod(dist_platform_tar_gz, 0o644)) # # Unpack the tar.gz archive created by the distutils into # build/unpack-tar-gz/scons-{version}. # # We'd like to replace the last three lines with the following: # # tar zxf $SOURCES -C $UNPACK_TAR_GZ_DIR # # but that gives heartburn to Cygwin's tar, so work around it # with separate zcat-tar-rm commands. # unpack_tar_gz_files = [os.path.join(unpack_tar_gz_dir, pkg_version, x) for x in src_files] env.Command(unpack_tar_gz_files, dist_tar_gz, [ Delete(os.path.join(unpack_tar_gz_dir, pkg_version)), "$ZCAT $SOURCES > .temp", "tar xf .temp -C $UNPACK_TAR_GZ_DIR", Delete(".temp"), ]) # # Run setup.py in the unpacked subdirectory to "install" everything # into our build/test subdirectory. The runtest.py script will set # PYTHONPATH so that the tests only look under build/test-{package}, # and under testing/framework (for the testing modules TestCmd.py, TestSCons.py, # etc.). This makes sure that our tests pass with what # we really packaged, not because of something hanging around in # the development directory. # # We can get away with calling setup.py using a directory path # like this because we put a preamble in it that will chdir() # to the directory in which setup.py exists. # dfiles = [os.path.join(test_tar_gz_dir, x) for x in dst_files] env.Command(dfiles, unpack_tar_gz_files, [ Delete(os.path.join(unpack_tar_gz_dir, pkg_version, 'build')), Delete("$TEST_TAR_GZ_DIR"), '$PYTHON $PYTHONFLAGS "%s" install "--prefix=$TEST_TAR_GZ_DIR" --standalone-lib' % \ os.path.join(unpack_tar_gz_dir, pkg_version, 'setup.py'), ]) # # Generate portage files for submission to Gentoo Linux. # gentoo = os.path.join(build, 'gentoo') ebuild = os.path.join(gentoo, 'scons-%s.ebuild' % command_line.version) digest = os.path.join(gentoo, 'files', 'digest-scons-%s' % command_line.version) env.Command(ebuild, os.path.join('gentoo', 'scons.ebuild.in'), SCons_revision) def Digestify(target, source, env): import hashlib src = source[0].rfile() with open(str(src), 'rb') as f: contents = f.read() m = hashlib.md5() m.update(contents) sig = m.hexdigest() bytes = os.stat(str(src))[6] with open(str(target[0]), 'w') as f: f.write("MD5 %s %s %d\n" % (sig, src.name, bytes)) env.Command(digest, tar_gz, Digestify) if not zipit: print("zip not found; skipping .zip package for %s." % pkg) else: distutils_formats.append('zip') src_deps.append(zip) distutils_targets.extend([zip, platform_zip]) dist_zip = env.Install('$DISTDIR', zip) dist_platform_zip = env.Install('$DISTDIR', platform_zip) Local(dist_zip, dist_platform_zip) AddPostAction(dist_zip, Chmod(dist_zip, 0o644)) AddPostAction(dist_platform_zip, Chmod(dist_platform_zip, 0o644)) # # Unpack the zip archive created by the distutils into # build/unpack-zip/scons-{version}. # unpack_zip_files = [os.path.join(unpack_zip_dir, pkg_version, x) for x in src_files] env.Command(unpack_zip_files, dist_zip, [ Delete(os.path.join(unpack_zip_dir, pkg_version)), unzipit, ]) # # Run setup.py in the unpacked subdirectory to "install" everything # into our build/test subdirectory. The runtest.py script will set # PYTHONPATH so that the tests only look under build/test-{package}, # and under testing/framework (for the testing modules TestCmd.py, TestSCons.py, # etc.). This makes sure that our tests pass with what # we really packaged, not because of something hanging around in # the development directory. # # We can get away with calling setup.py using a directory path # like this because we put a preamble in it that will chdir() # to the directory in which setup.py exists. # dfiles = [os.path.join(test_zip_dir, x) for x in dst_files] env.Command(dfiles, unpack_zip_files, [ Delete(os.path.join(unpack_zip_dir, pkg_version, 'build')), Delete("$TEST_ZIP_DIR"), '$PYTHON $PYTHONFLAGS "%s" install "--prefix=$TEST_ZIP_DIR" --standalone-lib' % \ os.path.join(unpack_zip_dir, pkg_version, 'setup.py'), ]) # # Use the Python distutils to generate the appropriate packages. # commands = [ Delete(os.path.join(build, 'build', 'lib')), Delete(os.path.join(build, 'build', 'scripts')), ] if distutils_formats: commands.append(Delete(os.path.join(build, 'build', 'bdist.' + platform, 'dumb'))) for format in distutils_formats: commands.append("$PYTHON $PYTHONFLAGS $SETUP_PY bdist_dumb -f %s" % format) commands.append("$PYTHON $PYTHONFLAGS $SETUP_PY sdist --formats=%s" % \ ','.join(distutils_formats)) env.Command(distutils_targets, build_src_files, commands) # # Now create local packages for people who want to let people # build their SCons-buildable packages without having to # install SCons. # s_l_v = '%s-local-%s' % (pkg, command_line.version) local = pkg + '-local' build_dir_local = os.path.join(command_line.build_dir, local) build_dir_local_slv = os.path.join(command_line.build_dir, local, s_l_v) dist_local_tar_gz = os.path.join("$DISTDIR/%s.tar.gz" % s_l_v) dist_local_zip = os.path.join("$DISTDIR/%s.zip" % s_l_v) AddPostAction(dist_local_tar_gz, Chmod(dist_local_tar_gz, 0o644)) AddPostAction(dist_local_zip, Chmod(dist_local_zip, 0o644)) commands = [ Delete(build_dir_local), '$PYTHON $PYTHONFLAGS $SETUP_PY install "--install-script=%s" "--install-lib=%s" --no-install-man --no-compile --standalone-lib --no-version-script' % \ (build_dir_local, build_dir_local_slv), ] for script in scripts: # add .py extension for scons-local scripts on non-windows platforms if is_windows(): break local_script = os.path.join(build_dir_local, script) commands.append(Move(local_script + '.py', local_script)) rf = [x for x in raw_files if not x in scripts] rf = [os.path.join(s_l_v, x) for x in rf] for script in scripts: rf.append("%s.py" % script) local_targets = [os.path.join(build_dir_local, x) for x in rf] env.Command(local_targets, build_src_files, commands) scons_LICENSE = os.path.join(build_dir_local, 'scons-LICENSE') l = env.SCons_revision(scons_LICENSE, 'LICENSE-local') local_targets.append(l) Local(l) scons_README = os.path.join(build_dir_local, 'scons-README') l = env.SCons_revision(scons_README, 'README-local') local_targets.append(l) Local(l) if gzip: if is_windows(): # avoid problem with tar interpreting c:/ as a remote machine tar_cargs = '-cz --force-local -f' else: tar_cargs = '-czf' env.Command(dist_local_tar_gz, local_targets, "cd %s && tar %s $( ${TARGET.abspath} $) *" % (build_dir_local, tar_cargs)) unpack_targets = [os.path.join(test_local_tar_gz_dir, x) for x in rf] commands = [Delete(test_local_tar_gz_dir), Mkdir(test_local_tar_gz_dir), "cd %s && tar xzf $( ${SOURCE.abspath} $)" % test_local_tar_gz_dir] env.Command(unpack_targets, dist_local_tar_gz, commands) if zipit: env.Command(dist_local_zip, local_targets, zipit, CD=build_dir_local, PSV='.') unpack_targets = [os.path.join(test_local_zip_dir, x) for x in rf] commands = [Delete(test_local_zip_dir), Mkdir(test_local_zip_dir), unzipit] env.Command(unpack_targets, dist_local_zip, unzipit, UNPACK_ZIP_DIR=test_local_zip_dir) # # # # # Documentation. # Export('command_line', 'env', 'whereis', 'revaction') SConscript('doc/SConscript') # # If we're running in a Git working directory, pack up a complete # source archive from the project files and files in the change. # sfiles = [l.split()[-1] for l in command_line.git_status_lines] if command_line.git_status_lines: # slines = [l for l in git_status_lines if 'modified:' in l] # sfiles = [l.split()[-1] for l in slines] pass else: print("Not building in a Git tree; skipping building src package.") if sfiles: remove_patterns = [ '*.gitignore', '*.hgignore', 'www/*', ] for p in remove_patterns: sfiles = [s for s in sfiles if not fnmatch.fnmatch(s, p)] if sfiles: ps = "%s-src" % project psv = "%s-%s" % (ps, command_line.version) b_ps = os.path.join(command_line.build_dir, ps) b_psv = os.path.join(command_line.build_dir, psv) b_psv_stamp = b_psv + '-stamp' src_tar_gz = os.path.join(command_line.build_dir, 'dist', '%s.tar.gz' % psv) src_zip = os.path.join(command_line.build_dir, 'dist', '%s.zip' % psv) Local(src_tar_gz, src_zip) for file in sfiles: if file.endswith('jpg') or file.endswith('png'): # don't revision binary files. env.Install(os.path.dirname(os.path.join(b_ps, file)), file) else: env.SCons_revision(os.path.join(b_ps, file), file) b_ps_files = [os.path.join(b_ps, x) for x in sfiles] cmds = [ Delete(b_psv), Copy(b_psv, b_ps), Touch("$TARGET"), ] env.Command(b_psv_stamp, src_deps + b_ps_files, cmds) Local(*b_ps_files) if gzip: env.Command(src_tar_gz, b_psv_stamp, "tar cz${TAR_HFLAG} -f $TARGET -C build %s" % psv) # # Unpack the archive into build/unpack/scons-{version}. # unpack_tar_gz_files = [os.path.join(unpack_tar_gz_dir, psv, x) for x in sfiles] # # We'd like to replace the last three lines with the following: # # tar zxf $SOURCES -C $UNPACK_TAR_GZ_DIR # # but that gives heartburn to Cygwin's tar, so work around it # with separate zcat-tar-rm commands. env.Command(unpack_tar_gz_files, src_tar_gz, [ Delete(os.path.join(unpack_tar_gz_dir, psv)), "$ZCAT $SOURCES > .temp", "tar xf .temp -C $UNPACK_TAR_GZ_DIR", Delete(".temp"), ]) # # Run setup.py in the unpacked subdirectory to "install" everything # into our build/test subdirectory. The runtest.py script will set # PYTHONPATH so that the tests only look under build/test-{package}, # and under testing/framework (for the testing modules TestCmd.py, # TestSCons.py, etc.). This makes sure that our tests pass with # what we really packaged, not because of something hanging around # in the development directory. # # We can get away with calling setup.py using a directory path # like this because we put a preamble in it that will chdir() # to the directory in which setup.py exists. # dfiles = [os.path.join(test_src_tar_gz_dir, x) for x in dst_files] scons_lib_dir = os.path.join(unpack_tar_gz_dir, psv, 'src', 'engine') ENV = env.Dictionary('ENV').copy() ENV['SCONS_LIB_DIR'] = scons_lib_dir ENV['USERNAME'] = command_line.developer env.Command(dfiles, unpack_tar_gz_files, [ Delete(os.path.join(unpack_tar_gz_dir, psv, 'build', 'scons', 'build')), Delete("$TEST_SRC_TAR_GZ_DIR"), 'cd "%s" && $PYTHON $PYTHONFLAGS "%s" "%s" VERSION="$VERSION"' % \ (os.path.join(unpack_tar_gz_dir, psv), os.path.join('src', 'script', 'scons.py'), os.path.join('build', 'scons')), '$PYTHON $PYTHONFLAGS "%s" install "--prefix=$TEST_SRC_TAR_GZ_DIR" --standalone-lib' % \ os.path.join(unpack_tar_gz_dir, psv, 'build', 'scons', 'setup.py'), ], ENV=ENV) if zipit: env.Command(src_zip, b_psv_stamp, zipit, CD='build', PSV=psv) # # Unpack the archive into build/unpack/scons-{version}. # unpack_zip_files = [os.path.join(unpack_zip_dir, psv, x) for x in sfiles] env.Command(unpack_zip_files, src_zip, [ Delete(os.path.join(unpack_zip_dir, psv)), unzipit ]) # # Run setup.py in the unpacked subdirectory to "install" everything # into our build/test subdirectory. The runtest.py script will set # PYTHONPATH so that the tests only look under build/test-{package}, # and under testing/framework (for the testing modules TestCmd.py, # TestSCons.py, etc.). This makes sure that our tests pass with # what we really packaged, not because of something hanging # around in the development directory. # # We can get away with calling setup.py using a directory path # like this because we put a preamble in it that will chdir() # to the directory in which setup.py exists. # dfiles = [os.path.join(test_src_zip_dir, x) for x in dst_files] scons_lib_dir = os.path.join(unpack_zip_dir, psv, 'src', 'engine') ENV = env.Dictionary('ENV').copy() ENV['SCONS_LIB_DIR'] = scons_lib_dir ENV['USERNAME'] = command_line.developer env.Command(dfiles, unpack_zip_files, [ Delete(os.path.join(unpack_zip_dir, psv, 'build', 'scons', 'build')), Delete("$TEST_SRC_ZIP_DIR"), 'cd "%s" && $PYTHON $PYTHONFLAGS "%s" "%s" VERSION="$VERSION"' % \ (os.path.join(unpack_zip_dir, psv), os.path.join('src', 'script', 'scons.py'), os.path.join('build', 'scons')), '$PYTHON $PYTHONFLAGS "%s" install "--prefix=$TEST_SRC_ZIP_DIR" --standalone-lib' % \ os.path.join(unpack_zip_dir, psv, 'build', 'scons', 'setup.py'), ], ENV=ENV) for pf, help_text in packaging_flavors: Alias(pf, [ os.path.join(command_line.build_dir, 'test-' + pf), os.path.join(command_line.build_dir, 'testing/framework'), os.path.join(command_line.build_dir, 'runtest.py'), ])