code-9edbab31e2ac/roundup/dist/command/__init__.py0000644000000000000000000000000011457647751020336 0ustar 00000000000000code-9edbab31e2ac/roundup/dist/command/bdist_rpm.py0000644000000000000000000000234411457647751020577 0ustar 00000000000000# # Copyright (C) 2009 Stefan Seefeld # All rights reserved. # For license terms see the file COPYING.txt. # from distutils.command.bdist_rpm import bdist_rpm as base from distutils.file_util import write_file import os class bdist_rpm(base): def finalize_options(self): base.finalize_options(self) if self.install_script: # install script is overridden. skip default return # install script option must be file name. # create the file in rpm build directory. install_script = os.path.join(self.rpm_base, "install.sh") self.mkpath(self.rpm_base) self.execute(write_file, (install_script, [ ("%s setup.py install --root=$RPM_BUILD_ROOT " "--record=ROUNDUP_FILES") % self.python, # allow any additional extension for man pages # (rpm may compress them to .gz or .bz2) # man page here is any file # with single-character extension # in man directory "sed -e 's,\(/man/.*\..\)$,\\1*,' " "INSTALLED_FILES", ]), "writing '%s'" % install_script) self.install_script = install_script code-9edbab31e2ac/roundup/dist/command/build.py0000644000000000000000000000365511457647751017721 0ustar 00000000000000# # Copyright (C) 2009 Stefan Seefeld # All rights reserved. # For license terms see the file COPYING.txt. # from roundup import msgfmt from distutils.command.build import build as base import os from glob import glob def list_message_files(suffix=".po"): """Return list of all found message files and their intallation paths""" _files = glob("locale/*" + suffix) _list = [] for _file in _files: # basename (without extension) is a locale name _locale = os.path.splitext(os.path.basename(_file))[0] _list.append((_file, os.path.join( "share", "locale", _locale, "LC_MESSAGES", "roundup.mo"))) return _list def check_manifest(): """Check that the files listed in the MANIFEST are present when the source is unpacked. """ try: f = open('MANIFEST') except: print '\n*** SOURCE WARNING: The MANIFEST file is missing!' return try: manifest = [l.strip() for l in f.readlines()] finally: f.close() err = set([line for line in manifest if not os.path.exists(line)]) # ignore auto-generated files err = err - set(['roundup-admin', 'roundup-demo', 'roundup-gettext', 'roundup-mailgw', 'roundup-server', 'roundup-xmlrpc-server']) if err: n = len(manifest) print '\n*** SOURCE WARNING: There are files missing (%d/%d found)!'%( n-len(err), n) print 'Missing:', '\nMissing: '.join(err) class build(base): def build_message_files(self): """For each locale/*.po, build .mo file in target locale directory""" for (_src, _dst) in list_message_files(): _build_dst = os.path.join("build", _dst) self.mkpath(os.path.dirname(_build_dst)) self.announce("Compiling %s -> %s" % (_src, _build_dst)) msgfmt.make(_src, _build_dst) def run(self): check_manifest() self.build_message_files() base.run(self) code-9edbab31e2ac/roundup/dist/command/build_doc.py0000644000000000000000000000212311457647751020533 0ustar 00000000000000# # Copyright (C) 2009 Stefan Seefeld # All rights reserved. # For license terms see the file COPYING.txt. # import os, sys from stat import * import os.path from shutil import * import glob from distutils.command import build from distutils.spawn import spawn, find_executable from distutils.dep_util import newer, newer_group from distutils.dir_util import copy_tree, remove_tree, mkpath from distutils.file_util import copy_file from distutils import sysconfig class build_doc(build.build): """Defines the specific procedure to build roundup's documentation.""" description = "build documentation" def run(self): """Run this command, i.e. do the actual document generation.""" sphinx = find_executable('sphinx-build') if not sphinx: self.warn("could not find sphinx-build in PATH") self.warn("cannot build documentation") return doc_dir = os.path.join('share', 'doc', 'roundup', 'html') temp_dir = os.path.join(self.build_temp, 'doc') cmd = [sphinx, '-d', temp_dir, 'doc', doc_dir] spawn(cmd) code-9edbab31e2ac/roundup/dist/command/build_py.py0000644000000000000000000000125711457647751020425 0ustar 00000000000000# # Copyright (C) 2009 Stefan Seefeld # All rights reserved. # For license terms see the file COPYING.txt. # from distutils.command.build_py import build_py class build_py(build_py): def find_modules(self): # Files listed in py_modules are in the toplevel directory # of the source distribution. modules = [] for module in self.py_modules: path = module.split('.') package = '.'.join(path[0:-1]) module_base = path[-1] module_file = module_base + '.py' if self.check_module(module, module_file): modules.append((package, module_base, module_file)) return modules code-9edbab31e2ac/roundup/dist/command/build_scripts.py0000644000000000000000000001275011457647751021464 0ustar 00000000000000# # Copyright (C) 2009 Stefan Seefeld # All rights reserved. # For license terms see the file COPYING.txt. # from distutils.command.build_scripts import build_scripts as base import sys, os, string class build_scripts(base): """ Overload the build_scripts command and create the scripts from scratch, depending on the target platform. You have to define the name of your package in an inherited class (due to the delayed instantiation of command classes in distutils, this cannot be passed to __init__). The scripts are created in an uniform scheme: they start the run() function in the module .scripts. The mangling of script names replaces '-' and '/' characters with '-' and '.', so that they are valid module paths. If the target platform is win32, create .bat files instead of *nix shell scripts. Target platform is set to "win32" if main command is 'bdist_wininst' or if the command is 'bdist' and it has the list of formats (from command line or config file) and the first item on that list is wininst. Otherwise target platform is set to current (build) platform. """ package_name = 'roundup' def initialize_options(self): base.initialize_options(self) self.script_preamble = None self.target_platform = None self.python_executable = None def finalize_options(self): base.finalize_options(self) cmdopt=self.distribution.command_options # find the target platform if self.target_platform: # TODO? allow explicit setting from command line target = self.target_platform if cmdopt.has_key("bdist_wininst"): target = "win32" elif cmdopt.get("bdist", {}).has_key("formats"): formats = cmdopt["bdist"]["formats"][1].split(",") if formats[0] == "wininst": target = "win32" else: target = sys.platform if len(formats) > 1: self.warn( "Scripts are built for %s only (requested formats: %s)" % (target, ",".join(formats))) else: # default to current platform target = sys.platform self.target_platfom = target # for native builds, use current python executable path; # for cross-platform builds, use default executable name if self.python_executable: # TODO? allow command-line option pass if target == sys.platform: self.python_executable = os.path.normpath(sys.executable) else: self.python_executable = "python" # for windows builds, add ".bat" extension if target == "win32": # *nix-like scripts may be useful also on win32 (cygwin) # to build both script versions, use: #self.scripts = list(self.scripts) + [script + ".bat" # for script in self.scripts] self.scripts = [script + ".bat" for script in self.scripts] # tweak python path for installations outside main python library if cmdopt.get("install", {}).has_key("prefix"): prefix = os.path.expanduser(cmdopt['install']['prefix'][1]) version = '%d.%d'%sys.version_info[:2] self.script_preamble = """ import sys sys.path.insert(1, "%s/lib/python%s/site-packages") """%(prefix, version) else: self.script_preamble = '' def copy_scripts(self): """ Create each script listed in 'self.scripts' """ to_module = string.maketrans('-/', '_.') self.mkpath(self.build_dir) for script in self.scripts: outfile = os.path.join(self.build_dir, os.path.basename(script)) #if not self.force and not newer(script, outfile): # self.announce("not copying %s (up-to-date)" % script) # continue if self.dry_run: self.announce("would create %s" % outfile) continue module = os.path.splitext(os.path.basename(script))[0] module = string.translate(module, to_module) script_vars = { 'python': self.python_executable, 'package': self.package_name, 'module': module, 'prefix': self.script_preamble, } self.announce("creating %s" % outfile) file = open(outfile, 'w') try: # could just check self.target_platform, # but looking at the script extension # makes it possible to build both *nix-like # and windows-like scripts on win32. # may be useful for cygwin. if os.path.splitext(outfile)[1] == ".bat": file.write('@echo off\n' 'if NOT "%%_4ver%%" == "" "%(python)s" -c "from %(package)s.scripts.%(module)s import run; run()" %%$\n' 'if "%%_4ver%%" == "" "%(python)s" -c "from %(package)s.scripts.%(module)s import run; run()" %%*\n' % script_vars) else: file.write('#! %(python)s\n%(prefix)s' 'from %(package)s.scripts.%(module)s import run\n' 'run()\n' % script_vars) finally: file.close() os.chmod(outfile, 0755)