2 # SConstruct file to build scons packages during development.
4 # See the README file for an overview of how SCons is built and tested.
7 copyright_years = '2001, 2002, 2003'
12 # Permission is hereby granted, free of charge, to any person obtaining
13 # a copy of this software and associated documentation files (the
14 # "Software"), to deal in the Software without restriction, including
15 # without limitation the rights to use, copy, modify, merge, publish,
16 # distribute, sublicense, and/or sell copies of the Software, and to
17 # permit persons to whom the Software is furnished to do so, subject to
18 # the following conditions:
20 # The above copyright notice and this permission notice shall be included
21 # in all copies or substantial portions of the Software.
23 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
24 # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
25 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
27 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
28 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
29 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
42 default_version = '0.11'
43 copyright = "Copyright (c) %s Steven Knight" % copyright_years
48 # An internal "whereis" routine to figure out if a given program
49 # is available on this system.
52 for dir in string.split(os.environ['PATH'], os.pathsep):
53 f = os.path.join(dir, file)
59 if stat.S_IMODE(st[stat.ST_MODE]) & 0111:
64 # We let the presence or absence of various utilities determine
65 # whether or not we bother to build certain pieces of things.
66 # This should allow people to still do SCons work even if they
67 # don't have Aegis or RPM installed, for example.
69 aegis = whereis('aegis')
70 aesub = whereis('aesub')
71 dh_builddeb = whereis('dh_builddeb')
72 fakeroot = whereis('fakeroot')
73 gzip = whereis('gzip')
74 rpmbuild = whereis('rpmbuild') or whereis('rpm')
75 unzip = whereis('unzip')
79 # Now grab the information that we "build" into the files.
82 date = ARGUMENTS['date']
84 date = time.strftime("%Y/%m/%d %H:%M:%S", time.localtime(time.time()))
86 if ARGUMENTS.has_key('developer'):
87 developer = ARGUMENTS['developer']
88 elif os.environ.has_key('USERNAME'):
89 developer = os.environ['USERNAME']
90 elif os.environ.has_key('LOGNAME'):
91 developer = os.environ['LOGNAME']
92 elif os.environ.has_key('USER'):
93 developer = os.environ['USER']
95 if ARGUMENTS.has_key('build_system'):
96 build_system = ARGUMENTS['build_system']
98 build_system = string.split(socket.gethostname(), '.')[0]
100 if ARGUMENTS.has_key('version'):
101 revision = ARGUMENTS['version']
103 revision = os.popen(aesub + " \\$version", "r").read()[:-1]
105 revision = default_version
107 a = string.split(revision, '.')
113 revision = string.join(arr, '.')
115 # Here's how we'd turn the calculated $revision into our package $version.
116 # This makes it difficult to coordinate with other files (debian/changelog
117 # and rpm/scons.spec) that hard-code the version number, so just go with
118 # the flow for now and hard code it here, too.
122 # if str[0] == 'C' or str[0] == 'D':
124 # while len(str) > 2 and str[0] == '0':
127 #arr = map(lambda x, xxx=xxx: xxx(x), arr)
128 #version = string.join(arr, '.')
129 version = default_version
131 build_id = string.replace(revision, version + '.', '')
133 if ARGUMENTS.has_key('change'):
134 change = ARGUMENTS['change']
136 change = os.popen(aesub + " \\$change", "r").read()[:-1]
138 change = default_version
140 python_ver = sys.version[0:3]
142 platform = distutils.util.get_platform()
144 ENV = { 'PATH' : os.environ['PATH'] }
145 for key in ['AEGIS_PROJECT', 'PYTHONPATH']:
146 if os.environ.has_key(key):
147 ENV[key] = os.environ[key]
149 lib_project = os.path.join("lib", project)
151 cwd_build = os.path.join(os.getcwd(), "build")
153 test_deb_dir = os.path.join(cwd_build, "test-deb")
154 test_rpm_dir = os.path.join(cwd_build, "test-rpm")
155 test_tar_gz_dir = os.path.join(cwd_build, "test-tar-gz")
156 test_src_tar_gz_dir = os.path.join(cwd_build, "test-src-tar-gz")
157 test_local_tar_gz_dir = os.path.join(cwd_build, "test-local-tar-gz")
158 test_zip_dir = os.path.join(cwd_build, "test-zip")
159 test_src_zip_dir = os.path.join(cwd_build, "test-src-zip")
160 test_local_zip_dir = os.path.join(cwd_build, "test-local-zip")
162 unpack_tar_gz_dir = os.path.join(cwd_build, "unpack-tar-gz")
163 unpack_zip_dir = os.path.join(cwd_build, "unpack-zip")
165 if platform == "win32":
167 python_project_subinst_dir = None
168 project_script_subinst_dir = 'Scripts'
171 python_project_subinst_dir = lib_project
172 project_script_subinst_dir = 'bin'
178 # Figure out if we can handle .zip files.
185 def zipit(env, target, source):
186 print "Zipping %s:" % str(target[0])
187 def visit(arg, dirname, names):
189 path = os.path.join(dirname, name)
190 if os.path.isfile(path):
192 zf = zipfile.ZipFile(str(target[0]), 'w')
195 try: os.path.walk(env['PSV'], visit, zf)
196 finally: os.chdir(olddir)
199 def unzipit(env, target, source):
200 print "Unzipping %s:" % str(source[0])
201 zf = zipfile.ZipFile(str(source[0]), 'r')
202 for name in zf.namelist():
203 dest = os.path.join(env['UNPACK_ZIP_DIR'], name)
204 dir = os.path.dirname(dest)
210 # if the file exists, then delete it before writing
211 # to it so that we don't end up trying to write to a symlink:
212 if os.path.isfile(dest) or os.path.islink(dest):
214 if not os.path.isdir(dest):
215 open(dest, 'w').write(zf.read(name))
219 zipit = "cd $CD && $ZIP $ZIPFLAGS $( ${TARGET.abspath} $) $PSV"
220 unzipit = "$UNZIP $UNZIPFLAGS $SOURCES"
222 def SCons_revision(target, source, env):
223 """Interpolate specific values from the environment into a file.
225 This is used to copy files into a tree that gets packaged up
226 into the source file package.
232 for line in inf.readlines():
233 # Note: We construct the __*__ substitution strings here
234 # so that they don't get replaced when this file gets
235 # copied into the tree for packaging.
236 line = string.replace(line, '__BUILD' + '__', env['BUILD'])
237 line = string.replace(line, '__BUILDSYS' + '__', env['BUILDSYS'])
238 line = string.replace(line, '__COPYRIGHT' + '__', env['COPYRIGHT'])
239 line = string.replace(line, '__DATE' + '__', env['DATE'])
240 line = string.replace(line, '__DEVELOPER' + '__', env['DEVELOPER'])
241 line = string.replace(line, '__FILE' + '__', str(source[0]))
242 line = string.replace(line, '__REVISION' + '__', env['REVISION'])
243 line = string.replace(line, '__VERSION' + '__', env['VERSION'])
247 os.chmod(t, os.stat(s)[0])
249 revbuilder = Builder(action = Action(SCons_revision, varlist=['VERSION']))
255 BUILDSYS = build_system,
256 COPYRIGHT = copyright,
258 DEVELOPER = developer,
263 TAR_HFLAG = tar_hflag,
268 UNZIPFLAGS = '-o -d $UNPACK_ZIP_DIR',
273 RPM2CPIO = 'rpm2cpio',
275 TEST_DEB_DIR = test_deb_dir,
276 TEST_RPM_DIR = test_rpm_dir,
277 TEST_SRC_TAR_GZ_DIR = test_src_tar_gz_dir,
278 TEST_SRC_ZIP_DIR = test_src_zip_dir,
279 TEST_TAR_GZ_DIR = test_tar_gz_dir,
280 TEST_ZIP_DIR = test_zip_dir,
282 UNPACK_TAR_GZ_DIR = unpack_tar_gz_dir,
283 UNPACK_ZIP_DIR = unpack_zip_dir,
285 BUILDERS = { 'SCons_revision' : revbuilder },
287 PYTHON = sys.executable
291 # Define SCons packages.
293 # In the original, more complicated packaging scheme, we were going
294 # to have separate packages for:
296 # python-scons only the build engine
297 # scons-script only the script
298 # scons the script plus the build engine
300 # We're now only delivering a single "scons" package, but this is still
301 # "built" as two sub-packages (the build engine and the script), so
302 # the definitions remain here, even though we're not using them for
307 'pkg' : 'python-' + project,
308 'src_subdir' : 'engine',
309 'inst_subdir' : os.path.join('lib', 'python1.5', 'site-packages'),
322 'files' : [ 'LICENSE.txt',
329 'LICENSE.txt' : '../LICENSE.txt'
334 # The original packaging scheme would have have required us to push
335 # the Python version number into the package name (python1.5-scons,
336 # python2.0-scons, etc.), which would have required a definition
337 # like the following. Leave this here in case we ever decide to do
338 # this in the future, but note that this would require some modification
339 # to src/engine/setup.py before it would really work.
342 # 'pkg' : 'python2-' + project,
343 # 'src_subdir' : 'engine',
344 # 'inst_subdir' : os.path.join('lib', 'python2.1', 'site-packages'),
347 # 'debian/changelog',
349 # 'debian/copyright',
364 # 'LICENSE.txt' : '../LICENSE.txt',
370 'pkg' : project + '-script',
371 'src_subdir' : 'script',
372 'inst_subdir' : 'bin',
393 'LICENSE.txt' : '../LICENSE.txt',
394 'scons' : 'scons.py',
417 'os_spawnv_fix.diff',
425 'scons.1' : '../doc/man/scons.1',
428 'subpkgs' : [ python_scons, scons_script ],
431 'python-' + project : python_project_subinst_dir,
432 project + '-script' : project_script_subinst_dir,
441 # Initialize variables with the right directories for this package.
444 pkg_version = "%s-%s" % (pkg, version)
447 if p.has_key('src_subdir'):
448 src = os.path.join(src, p['src_subdir'])
450 build = os.path.join('build', pkg)
452 tar_gz = os.path.join(build, 'dist', "%s.tar.gz" % pkg_version)
453 platform_tar_gz = os.path.join(build,
455 "%s.%s.tar.gz" % (pkg_version, platform))
456 zip = os.path.join(build, 'dist', "%s.zip" % pkg_version)
457 platform_zip = os.path.join(build,
459 "%s.%s.zip" % (pkg_version, platform))
460 win32_exe = os.path.join(build, 'dist', "%s.win32.exe" % pkg_version)
463 # Update the environment with the relevant information
466 # We can get away with calling setup.py using a directory path
467 # like this because we put a preamble in it that will chdir()
468 # to the directory in which setup.py exists.
470 setup_py = os.path.join(build, 'setup.py')
471 env.Update(PKG = pkg,
472 PKG_VERSION = pkg_version,
477 # Read up the list of source files from our MANIFEST.in.
478 # This list should *not* include LICENSE.txt, MANIFEST,
479 # README.txt, or setup.py. Make a copy of the list for the
482 manifest_in = File(os.path.join(src, 'MANIFEST.in')).rstr()
483 src_files = map(lambda x: x[:-1],
484 open(manifest_in).readlines())
485 raw_files = src_files[:]
486 dst_files = src_files[:]
488 MANIFEST_in_list = []
490 if p.has_key('subpkgs'):
492 # This package includes some sub-packages. Read up their
493 # MANIFEST.in files, and add them to our source and destination
494 # file lists, modifying them as appropriate to add the
497 for sp in p['subpkgs']:
498 ssubdir = sp['src_subdir']
499 isubdir = p['subinst_dirs'][sp['pkg']]
500 MANIFEST_in = File(os.path.join(src, ssubdir, 'MANIFEST.in')).rstr()
501 MANIFEST_in_list.append(MANIFEST_in)
502 f = map(lambda x: x[:-1], open(MANIFEST_in).readlines())
504 src_files.extend(map(lambda x, s=ssubdir: os.path.join(s, x), f))
506 f = map(lambda x, i=isubdir: os.path.join(i, x), f)
508 for k in sp['filemap'].keys():
511 k = os.path.join(sp['src_subdir'], k)
512 p['filemap'][k] = os.path.join(sp['src_subdir'], f)
515 # Now that we have the "normal" source files, add those files
516 # that are standard for each distribution. Note that we don't
517 # add these to dst_files, because they don't get installed.
518 # And we still have the MANIFEST to add.
520 src_files.extend(p['files'])
523 # Now run everything in src_file through the sed command we
524 # concocted to expand __FILE__, __VERSION__, etc.
527 s = p['filemap'].get(b, b)
528 env.SCons_revision(os.path.join(build, b), os.path.join(src, s))
531 # NOW, finally, we can create the MANIFEST, which we do
532 # by having Python spit out the contents of the src_files
533 # array we've carefully created. After we've added
534 # MANIFEST itself to the array, of course.
536 src_files.append("MANIFEST")
537 MANIFEST_in_list.append(os.path.join(src, 'MANIFEST.in'))
539 def write_src_files(target, source, **kw):
542 f = open(str(target[0]), 'wb')
543 for file in src_files:
547 env.Command(os.path.join(build, 'MANIFEST'),
552 # Now go through and arrange to create whatever packages we can.
554 build_src_files = map(lambda x, b=build: os.path.join(b, x), src_files)
555 apply(Local, build_src_files, {})
557 distutils_formats = []
559 distutils_targets = [ win32_exe ]
561 install_targets = distutils_targets[:]
565 distutils_formats.append('gztar')
567 src_deps.append(tar_gz)
569 distutils_targets.extend([ tar_gz, platform_tar_gz ])
570 install_targets.extend([ tar_gz, platform_tar_gz ])
573 # Unpack the tar.gz archive created by the distutils into
574 # build/unpack-tar-gz/scons-{version}.
576 # We'd like to replace the last three lines with the following:
578 # tar zxf $SOURCES -C $UNPACK_TAR_GZ_DIR
580 # but that gives heartburn to Cygwin's tar, so work around it
581 # with separate zcat-tar-rm commands.
583 unpack_tar_gz_files = map(lambda x, u=unpack_tar_gz_dir, pv=pkg_version:
584 os.path.join(u, pv, x),
586 env.Command(unpack_tar_gz_files, tar_gz, [
587 "rm -rf %s" % os.path.join(unpack_tar_gz_dir, pkg_version),
588 "$ZCAT $SOURCES > .temp",
589 "tar xf .temp -C $UNPACK_TAR_GZ_DIR",
594 # Run setup.py in the unpacked subdirectory to "install" everything
595 # into our build/test subdirectory. The runtest.py script will set
596 # PYTHONPATH so that the tests only look under build/test-{package},
597 # and under etc (for the testing modules TestCmd.py, TestSCons.py,
598 # and unittest.py). This makes sure that our tests pass with what
599 # we really packaged, not because of something hanging around in
600 # the development directory.
602 # We can get away with calling setup.py using a directory path
603 # like this because we put a preamble in it that will chdir()
604 # to the directory in which setup.py exists.
606 dfiles = map(lambda x, d=test_tar_gz_dir: os.path.join(d, x), dst_files)
607 env.Command(dfiles, unpack_tar_gz_files, [
608 "rm -rf %s" % os.path.join(unpack_tar_gz_dir, pkg_version, 'build'),
609 "rm -rf $TEST_TAR_GZ_DIR",
610 "$PYTHON %s install --prefix=$TEST_TAR_GZ_DIR" % \
611 os.path.join(unpack_tar_gz_dir, pkg_version, 'setup.py'),
616 distutils_formats.append('zip')
620 distutils_targets.extend([ zip, platform_zip ])
621 install_targets.extend([ zip, platform_zip ])
624 # Unpack the zip archive created by the distutils into
625 # build/unpack-zip/scons-{version}.
627 unpack_zip_files = map(lambda x, u=unpack_zip_dir, pv=pkg_version:
628 os.path.join(u, pv, x),
631 env.Command(unpack_zip_files, zip, unzipit)
634 # Run setup.py in the unpacked subdirectory to "install" everything
635 # into our build/test subdirectory. The runtest.py script will set
636 # PYTHONPATH so that the tests only look under build/test-{package},
637 # and under etc (for the testing modules TestCmd.py, TestSCons.py,
638 # and unittest.py). This makes sure that our tests pass with what
639 # we really packaged, not because of something hanging around in
640 # the development directory.
642 # We can get away with calling setup.py using a directory path
643 # like this because we put a preamble in it that will chdir()
644 # to the directory in which setup.py exists.
646 dfiles = map(lambda x, d=test_zip_dir: os.path.join(d, x), dst_files)
647 env.Command(dfiles, unpack_zip_files, [
648 "rm -rf %s" % os.path.join(unpack_zip_dir, pkg_version, 'build'),
649 "rm -rf $TEST_ZIP_DIR",
650 "$PYTHON %s install --prefix=$TEST_ZIP_DIR" % \
651 os.path.join(unpack_zip_dir, pkg_version, 'setup.py'),
655 topdir = os.path.join(os.getcwd(), build, 'build',
656 'bdist.' + platform, 'rpm')
658 BUILDdir = os.path.join(topdir, 'BUILD', pkg + '-' + version)
659 RPMSdir = os.path.join(topdir, 'RPMS', 'noarch')
660 SOURCESdir = os.path.join(topdir, 'SOURCES')
661 SPECSdir = os.path.join(topdir, 'SPECS')
662 SRPMSdir = os.path.join(topdir, 'SRPMS')
664 specfile = os.path.join(SPECSdir, "%s-1.spec" % pkg_version)
665 sourcefile = os.path.join(SOURCESdir, "%s.tar.gz" % pkg_version);
666 noarch_rpm = os.path.join(RPMSdir, "%s-1.noarch.rpm" % pkg_version)
667 src_rpm = os.path.join(SRPMSdir, "%s-1.src.rpm" % pkg_version)
669 env.InstallAs(specfile, os.path.join('rpm', "%s.spec" % pkg))
670 env.InstallAs(sourcefile, tar_gz)
672 targets = [ noarch_rpm, src_rpm ]
673 cmd = "$RPMBUILD --define '_topdir $(%s$)' -ba $SOURCES" % topdir
674 if not os.path.isdir(BUILDdir):
675 cmd = ("$( mkdir -p %s; $)" % BUILDdir) + cmd
676 env.Command(targets, specfile, cmd)
677 env.Depends(targets, sourcefile)
679 install_targets.extend(targets)
681 dfiles = map(lambda x, d=test_rpm_dir: os.path.join(d, 'usr', x),
685 "$RPM2CPIO $SOURCES | (cd $TEST_RPM_DIR && cpio -id)")
687 if dh_builddeb and fakeroot:
688 # Our Debian packaging builds directly into build/dist,
689 # so we don't need to add the .debs to install_targets.
690 deb = os.path.join('build', 'dist', "%s_%s-1_all.deb" % (pkg, version))
691 for d in p['debian_deps']:
692 b = env.SCons_revision(os.path.join(build, d), d)
695 env.Command(deb, build_src_files, [
696 "cd %s && fakeroot make -f debian/rules PYTHON=$PYTHON BUILDDEB_OPTIONS=--destdir=../../build/dist binary" % build,
699 old = os.path.join('lib', 'scons', '')
700 new = os.path.join('lib', 'python2.1', 'site-packages', '')
701 def xxx(s, old=old, new=new):
702 if s[:len(old)] == old:
703 s = new + s[len(old):]
704 return os.path.join('usr', s)
705 dfiles = map(lambda x, t=test_deb_dir: os.path.join(t, x),
709 "dpkg --fsys-tarfile $SOURCES | (cd $TEST_DEB_DIR && tar -xf -)")
712 # Use the Python distutils to generate the appropriate packages.
715 "rm -rf %s" % os.path.join(build, 'build', 'lib'),
716 "rm -rf %s" % os.path.join(build, 'build', 'scripts'),
719 if distutils_formats:
720 commands.append("rm -rf %s" % os.path.join(build,
724 for format in distutils_formats:
725 commands.append("$PYTHON $SETUP_PY bdist_dumb -f %s" % format)
727 commands.append("$PYTHON $SETUP_PY sdist --formats=%s" % \
728 string.join(distutils_formats, ','))
730 commands.append("$PYTHON $SETUP_PY bdist_wininst")
732 env.Command(distutils_targets, build_src_files, commands)
735 # Now create local packages for people who want to let people
736 # build their SCons-buildable packages without having to
739 s_l_v = '%s-local-%s' % (pkg, version)
741 local = os.path.join('build', pkg + '-local')
742 cwd_local = os.path.join(os.getcwd(), local)
743 cwd_local_slv = os.path.join(os.getcwd(), local, s_l_v)
745 local_tar_gz = os.path.join('build', 'dist', "%s.tar.gz" % s_l_v)
746 local_zip = os.path.join('build', 'dist', "%s.zip" % s_l_v)
750 "$PYTHON $SETUP_PY install --install-script=%s --install-lib=%s --no-compile" % \
751 (cwd_local, cwd_local_slv),
752 "mv %s/scons %s/scons.py" % (local, local),
755 rf = filter(lambda x: x != "scons", raw_files)
756 rf = map(lambda x, slv=s_l_v: os.path.join(slv, x), rf)
757 rf.append("scons.py")
758 local_targets = map(lambda x, s=local: os.path.join(s, x), rf)
760 env.Command(local_targets, build_src_files, commands)
762 scons_LICENSE = os.path.join(local, 'scons-LICENSE')
763 env.SCons_revision(scons_LICENSE, 'LICENSE-local')
764 local_targets.append(scons_LICENSE)
766 scons_README = os.path.join(local, 'scons-README')
767 env.SCons_revision(scons_README, 'README-local')
768 local_targets.append(scons_README)
771 env.Command(local_tar_gz,
773 "cd %s && tar czf $( ${TARGET.abspath} $) *" % local)
775 unpack_targets = map(lambda x, d=test_local_tar_gz_dir:
778 commands = ["rm -rf %s" % test_local_tar_gz_dir,
779 "mkdir %s" % test_local_tar_gz_dir,
780 "cd %s && tar xzf $( ${SOURCE.abspath} $)" % test_local_tar_gz_dir]
782 env.Command(unpack_targets, local_tar_gz, commands)
785 zipenv = env.Copy(CD = local, PSV = '.')
786 zipenv.Command(local_zip, local_targets, zipit)
788 unpack_targets = map(lambda x, d=test_local_zip_dir:
791 commands = ["rm -rf %s" % test_local_zip_dir,
792 "mkdir %s" % test_local_zip_dir,
795 zipenv = env.Copy(UNPACK_ZIP_DIR = test_local_zip_dir)
796 zipenv.Command(unpack_targets, local_zip, unzipit)
799 # And, lastly, install the appropriate packages in the
800 # appropriate subdirectory.
802 b_d_files = env.Install(os.path.join('build', 'dist'), install_targets)
810 SConscript('etc/SConscript')
815 BuildDir('build/doc', 'doc')
817 Export('env', 'whereis')
819 SConscript('build/doc/SConscript')
822 # If we're running in the actual Aegis project, pack up a complete
823 # source archive from the project files and files in the change,
824 # so we can share it with helpful developers who don't use Aegis.
829 cmd = "aegis -list -unf -c %s cf 2>/dev/null" % change
830 for line in map(lambda x: x[:-1], os.popen(cmd, "r").readlines()):
831 a = string.split(line)
835 cmd = "aegis -list -terse pf 2>/dev/null"
836 pf = map(lambda x: x[:-1], os.popen(cmd, "r").readlines())
837 cmd = "aegis -list -terse cf 2>/dev/null"
838 cf = map(lambda x: x[:-1], os.popen(cmd, "r").readlines())
844 sfiles = filter(lambda x: x[-9:] != '.aeignore' and x[-9:] != '.sconsign',
848 ps = "%s-src" % project
849 psv = "%s-%s" % (ps, version)
850 b_ps = os.path.join('build', ps)
851 b_psv = os.path.join('build', psv)
852 b_psv_stamp = b_psv + '-stamp'
854 src_tar_gz = os.path.join('build', 'dist', '%s.tar.gz' % psv)
855 src_zip = os.path.join('build', 'dist', '%s.zip' % psv)
857 Local(src_tar_gz, src_zip)
860 env.SCons_revision(os.path.join(b_ps, file), file)
862 b_ps_files = map(lambda x, d=b_ps: os.path.join(d, x), sfiles)
865 "cp -rp %s %s" % (b_ps, b_psv),
866 "find %s -name .sconsign -exec rm {} \\;" % b_psv,
870 env.Command(b_psv_stamp, src_deps + b_ps_files, cmds)
872 apply(Local, b_ps_files, {})
876 env.Command(src_tar_gz, b_psv_stamp,
877 "tar cz${TAR_HFLAG} -f $TARGET -C build %s" % psv)
880 # Unpack the archive into build/unpack/scons-{version}.
882 unpack_tar_gz_files = map(lambda x, u=unpack_tar_gz_dir, psv=psv:
883 os.path.join(u, psv, x),
887 # We'd like to replace the last three lines with the following:
889 # tar zxf $SOURCES -C $UNPACK_TAR_GZ_DIR
891 # but that gives heartburn to Cygwin's tar, so work around it
892 # with separate zcat-tar-rm commands.
893 env.Command(unpack_tar_gz_files, src_tar_gz, [
894 "rm -rf %s" % os.path.join(unpack_tar_gz_dir, psv),
895 "$ZCAT $SOURCES > .temp",
896 "tar xf .temp -C $UNPACK_TAR_GZ_DIR",
901 # Run setup.py in the unpacked subdirectory to "install" everything
902 # into our build/test subdirectory. The runtest.py script will set
903 # PYTHONPATH so that the tests only look under build/test-{package},
904 # and under etc (for the testing modules TestCmd.py, TestSCons.py,
905 # and unittest.py). This makes sure that our tests pass with what
906 # we really packaged, not because of something hanging around in
907 # the development directory.
909 # We can get away with calling setup.py using a directory path
910 # like this because we put a preamble in it that will chdir()
911 # to the directory in which setup.py exists.
913 dfiles = map(lambda x, d=test_src_tar_gz_dir: os.path.join(d, x),
915 ENV = env.Dictionary('ENV')
916 ENV['SCONS_LIB_DIR'] = os.path.join(unpack_tar_gz_dir, psv, 'src', 'engine')
917 ENV['USERNAME'] = developer
918 env.Copy(ENV = ENV).Command(dfiles, unpack_tar_gz_files, [
919 "rm -rf %s" % os.path.join(unpack_tar_gz_dir,
924 "rm -rf $TEST_SRC_TAR_GZ_DIR",
925 "cd %s && $PYTHON %s %s" % \
926 (os.path.join(unpack_tar_gz_dir, psv),
927 os.path.join('src', 'script', 'scons.py'),
928 os.path.join('build', 'scons')),
929 "$PYTHON %s install --prefix=$TEST_SRC_TAR_GZ_DIR" % \
930 os.path.join(unpack_tar_gz_dir,
939 zipenv = env.Copy(CD = 'build', PSV = psv)
940 zipenv.Command(src_zip, b_psv_stamp, zipit)
943 # Unpack the archive into build/unpack/scons-{version}.
945 unpack_zip_files = map(lambda x, u=unpack_zip_dir, psv=psv:
946 os.path.join(u, psv, x),
949 env.Command(unpack_zip_files, src_zip, unzipit)
952 # Run setup.py in the unpacked subdirectory to "install" everything
953 # into our build/test subdirectory. The runtest.py script will set
954 # PYTHONPATH so that the tests only look under build/test-{package},
955 # and under etc (for the testing modules TestCmd.py, TestSCons.py,
956 # and unittest.py). This makes sure that our tests pass with what
957 # we really packaged, not because of something hanging around in
958 # the development directory.
960 # We can get away with calling setup.py using a directory path
961 # like this because we put a preamble in it that will chdir()
962 # to the directory in which setup.py exists.
964 dfiles = map(lambda x, d=test_src_zip_dir: os.path.join(d, x),
966 ENV = env.Dictionary('ENV')
967 ENV['SCONS_LIB_DIR'] = os.path.join(unpack_zip_dir, psv, 'src', 'engine')
968 ENV['USERNAME'] = developer
969 env.Copy(ENV = ENV).Command(dfiles, unpack_zip_files, [
970 "rm -rf %s" % os.path.join(unpack_zip_dir,
975 "rm -rf $TEST_SRC_ZIP_DIR",
976 "cd %s && $PYTHON %s %s" % \
977 (os.path.join(unpack_zip_dir, psv),
978 os.path.join('src', 'script', 'scons.py'),
979 os.path.join('build', 'scons')),
980 "$PYTHON %s install --prefix=$TEST_SRC_ZIP_DIR" % \
981 os.path.join(unpack_zip_dir,