try:
import distutils.core
import distutils.command.install
+ import distutils.command.install_data
import distutils.command.install_lib
import distutils.command.install_scripts
import distutils.command.build_scripts
sys.exit(1)
_install = distutils.command.install.install
+_install_data = distutils.command.install_data.install_data
_install_lib = distutils.command.install_lib.install_lib
_install_scripts = distutils.command.install_scripts.install_scripts
_build_scripts = distutils.command.build_scripts.build_scripts
+install_doc = 1
standard_lib = 0
standalone_lib = 0
version_lib = 0
installed_lib_dir = None
+installed_man_pages_dir = None
installed_scripts_dir = None
def set_explicitly(name, args):
class install(_install):
user_options = _install.user_options + [
+ ('no-install-doc', None,
+ "do not install SCons man pages"),
('standard-lib', None,
"install SCons library in standard Python location"),
('standalone-lib', None,
"install SCons library in version-specific directory")
]
boolean_options = _install.boolean_options + [
+ 'no-install-doc',
'standard-lib',
'standalone-lib',
'version-lib'
def initialize_options(self):
_install.initialize_options(self)
+ self.no_install_doc = 0
self.standard_lib = 0
self.standalone_lib = 0
self.version_lib = 0
def finalize_options(self):
_install.finalize_options(self)
- global standard_lib, standalone_lib, version_lib
+ global install_doc, standard_lib, standalone_lib, version_lib
+ if self.no_install_doc:
+ install_doc = 0
standard_lib = self.standard_lib
standalone_lib = self.standalone_lib
version_lib = self.version_lib
_build_scripts.finalize_options(self)
self.build_dir = os.path.join('build', 'scripts')
+class install_data(_install_data):
+ def initialize_options(self):
+ _install_data.initialize_options(self)
+ global install_doc
+ self.install_doc = install_doc
+ def finalize_options(self):
+ _install_data.finalize_options(self)
+ if self.install_doc:
+ global installed_man_pages_dir
+ installed_man_pages_dir = self.install_dir + '/man/man1'
+ else:
+ self.data_files = []
+
arguments = {
'name' : "scons",
'version' : "__VERSION__",
'scripts' : ['script/scons', 'script/sconsign'],
'cmdclass' : {'install' : install,
'install_lib' : install_lib,
+ 'install_data' : install_data,
'install_scripts' : install_scripts,
'build_scripts' : build_scripts}
}
-try:
- if sys.platform == 'win32' or sys.argv[1] == "bdist_wininst":
- arguments['data_files'] = [('.', ["script/scons.bat"])]
-except IndexError:
- pass
+is_win32 = 0
+if not sys.platform == 'win32':
+ try:
+ if sys.argv[1] == 'bdist_wininst':
+ is_win32 = 1
+ except IndexError:
+ pass
+else:
+ is_win32 = 1
+
+if is_win32:
+ arguments['data_files'] = [('.', ["script/scons.bat"])]
+else:
+ arguments['data_files'] = [('man/man1', ["scons.1", "sconsign.1"])]
apply(distutils.core.setup, (), arguments)
if installed_lib_dir:
print "Installed SCons library modules into %s" % installed_lib_dir
+if installed_man_pages_dir:
+ print "Installed SCons man pages into %s" % installed_man_pages_dir
if installed_scripts_dir:
- print "Installed SCons script into %s" % installed_scripts_dir
+ print "Installed SCons scripts into %s" % installed_scripts_dir
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
"""
-Test how the setup.py script installs SCons (specifically, its libraries).
+Test how the setup.py script installs SCons.
Note that this is an installation test, not a functional test, so the
name of this script doesn't end in *Tests.py.
import string
import sys
+#try:
+# version = os.environ['SCONS_VERSION']
+#except KeyError:
+# version = '__VERSION__'
+version = '0.96'
+
+scons_version = 'scons-%s' % version
+
import TestSCons
python = TestSCons.python
class MyTestSCons(TestSCons.TestSCons):
- def installed(self, lib):
+
+ scripts = [
+ 'scons',
+ 'sconsign',
+ ]
+
+ man_pages = [
+ 'scons.1',
+ 'sconsign.1',
+ ]
+
+ def __init__(self):
+ TestSCons.TestSCons.__init__(self)
+ self.root = self.workpath('root')
+ self.prefix = self.root + sys.prefix
+
+ self.lib_dir = os.path.join(self.prefix, 'lib')
+ self.standard_lib = os.path.join(self.lib_dir,
+ 'python%s' % sys.version[:3],
+ 'site-packages/')
+ self.standalone_lib = os.path.join(self.lib_dir, 'scons')
+ self.version_lib = os.path.join(self.lib_dir, scons_version)
+
+ self.bin_dir = os.path.join(self.prefix, 'bin')
+
+ self.man_dir = os.path.join(self.prefix, 'man', 'man1')
+
+ def run(self, *args, **kw):
+ kw['chdir'] = scons_version
+ kw['program'] = python
+ kw['stderr'] = None
+ return apply(TestSCons.TestSCons.run, (self,)+args, kw)
+
+ def must_have_installed_lib(self, lib):
lines = string.split(self.stdout(), '\n')
- return ('Installed SCons library modules into %s' % lib) in lines
+ line = 'Installed SCons library modules into %s' % lib
+ self.fail_test(not line in lines)
+
+ def must_have_installed_scripts(self):
+ lines = string.split(self.stdout(), '\n')
+ line = 'Installed SCons scripts into %s' % self.bin_dir
+ self.fail_test(not line in lines)
+ for script in self.scripts:
+ self.must_exist([self.bin_dir, script])
+
+ def must_have_installed_man_pages(self):
+ lines = string.split(self.stdout(), '\n')
+ line = 'Installed SCons man pages into %s' % self.man_dir
+ self.fail_test(not line in lines)
+ for mp in self.man_pages:
+ self.must_exist([self.man_dir, mp])
try:
cwd = os.environ['SCONS_CWD']
except KeyError:
cwd = os.getcwd()
-#try:
-# version = os.environ['SCONS_VERSION']
-#except KeyError:
-# version = '__VERSION__'
-version = '0.96'
-
-scons_version = 'scons-%s' % version
-
tar_gz = os.path.join(cwd, 'build', 'dist', '%s.tar.gz' % scons_version)
-test = MyTestSCons()
-
if not os.path.isfile(tar_gz):
print "Did not find an SCons package `%s'." % tar_gz
print "Cannot test package installation."
test.no_result(1)
-test.subdir('root', 'prefix')
-
-root = test.workpath('root')
-prefix = test.workpath('prefix')
+test = MyTestSCons()
-lib_dir = os.path.join(root + sys.prefix, 'lib')
-standard_lib = os.path.join(lib_dir,
- 'python%s' % sys.version[:3],
- 'site-packages/')
-standalone_lib = os.path.join(lib_dir, 'scons')
-version_lib = os.path.join(lib_dir, scons_version)
+test.subdir(test.root)
+# Unpack the .tar.gz file. This should create the scons_version/
+# subdirectory from which we execute the setup.py script therein.
os.system("gunzip -c %s | tar xf -" % tar_gz)
-# Verify that a virgin installation installs the standalone library.
-test.run(chdir = scons_version,
- program = python,
- arguments = 'setup.py install --root=%s' % root,
- stderr = None)
-test.fail_test(not test.installed(standalone_lib))
+# Verify that a virgin installation installs the standalone library,
+# the scripts and the man pages.
+test.run(arguments = 'setup.py install --root=%s' % test.root)
+test.must_have_installed_lib(test.standalone_lib)
+test.must_have_installed_scripts()
+test.must_have_installed_man_pages()
# Verify that --standard-lib installs into the Python standard library.
-test.run(chdir = scons_version,
- program = python,
- arguments = 'setup.py install --root=%s --standard-lib' % root,
- stderr = None)
-lines = string.split(test.stdout(), '\n')
-test.fail_test(not test.installed(standard_lib))
+test.run(arguments = 'setup.py install --root=%s --standard-lib' % test.root)
+test.must_have_installed_lib(test.standard_lib)
# Verify that --standalone-lib installs the standalone library.
-test.run(chdir = scons_version,
- program = python,
- arguments = 'setup.py install --root=%s --standalone-lib' % root,
- stderr = None)
-test.fail_test(not test.installed(standalone_lib))
+test.run(arguments = 'setup.py install --root=%s --standalone-lib' % test.root)
+test.must_have_installed_lib(test.standalone_lib)
# Verify that --version-lib installs into a version-specific library directory.
-test.run(chdir = scons_version,
- program = python,
- arguments = 'setup.py install --root=%s --version-lib' % root,
- stderr = None)
-test.fail_test(not test.installed(version_lib))
+test.run(arguments = 'setup.py install --root=%s --version-lib' % test.root)
+test.must_have_installed_lib(test.version_lib)
# Now that all of the libraries are in place,
# verify that a default installation finds the version-specific library first.
-test.run(chdir = scons_version,
- program = python,
- arguments = 'setup.py install --root=%s' % root,
- stderr = None)
-test.fail_test(not test.installed(version_lib))
+test.run(arguments = 'setup.py install --root=%s' % test.root)
+test.must_have_installed_lib(test.version_lib)
-shutil.rmtree(version_lib)
+shutil.rmtree(test.version_lib)
# Now with only the standard and standalone libraries in place,
# verify that a default installation finds the standalone library first.
-test.run(chdir = scons_version,
- program = python,
- arguments = 'setup.py install --root=%s' % root,
- stderr = None)
-test.fail_test(not test.installed(standalone_lib))
+test.run(arguments = 'setup.py install --root=%s' % test.root)
+test.must_have_installed_lib(test.standalone_lib)
-shutil.rmtree(standalone_lib)
+shutil.rmtree(test.standalone_lib)
# Now with only the standard libraries in place,
# verify that a default installation installs the standard library.
-test.run(chdir = scons_version,
- program = python,
- arguments = 'setup.py install --root=%s' % root,
- stderr = None)
-test.fail_test(not test.installed(standard_lib))
-
-# Verify that we're not warning about the directory in which
-# we've installed the modules when using a non-standard prefix.
-test.run(chdir = scons_version,
- program = python,
- arguments = 'setup.py install --prefix=%s' % prefix,
- stderr = None)
+test.run(arguments = 'setup.py install --root=%s' % test.root)
+test.must_have_installed_lib(test.standard_lib)
+
+# Verify that we don't warn about the directory in which we've
+# installed the modules when using a non-standard prefix.
+other_prefix = test.workpath('other-prefix')
+test.subdir(other_prefix)
+test.run(arguments = 'setup.py install --prefix=%s' % other_prefix)
test.fail_test(string.find(test.stderr(),
"you'll have to change the search path yourself")
!= -1)
projects / scons.git / commitdiff