code-2c516d113620/roundup/dist/command/__init__.py0000644000000000000000000000000013451103022017640 0ustar 00000000000000code-2c516d113620/roundup/dist/command/bdist_rpm.py0000644000000000000000000000234413451103022020101 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-2c516d113620/roundup/dist/command/build.py0000644000000000000000000000375413451103022017223 0ustar 00000000000000# # Copyright (C) 2009 Stefan Seefeld # All rights reserved. # For license terms see the file COPYING.txt. # from __future__ import print_function 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)) def build_message_files(command): """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) command.mkpath(os.path.dirname(_build_dst)) command.announce("Compiling %s -> %s" % (_src, _build_dst)) mo = msgfmt.Msgfmt(_src).get() open(_build_dst, 'wb').write(mo) class build(base): def run(self): check_manifest() build_message_files(self) base.run(self) code-2c516d113620/roundup/dist/command/build_doc.py0000644000000000000000000000257713451103022020052 0ustar 00000000000000# # Copyright (C) 2009 Stefan Seefeld # All rights reserved. # For license terms see the file COPYING.txt. # import os, sys import os.path 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 sphinx: sphinx = [sphinx] else: try: # try to find version installed with Python tools # tested with Sphinx 1.1.3 import sphinx as sp except ImportError: pass else: sphinx = [sys.executable, sp.__file__] 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-2c516d113620/roundup/dist/command/build_scripts.py0000644000000000000000000001320313451103022020760 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 from distutils import log 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 "bdist_wininst" in cmdopt: target = "win32" elif "formats" in cmdopt.get("bdist", {}): 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_platform = 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 "prefix" in cmdopt.get("install", {}): 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' """ try: # Python 3. maketrans = str.maketrans except AttributeError: # Python 2. maketrans = string.maketrans to_module = 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: log.info("would create %s" % outfile) continue module = os.path.splitext(os.path.basename(script))[0] module = module.translate(to_module) script_vars = { 'python': self.python_executable, 'package': self.package_name, 'module': module, 'prefix': self.script_preamble, } log.info("writing %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, 0o755) code-2c516d113620/roundup/dist/command/install_lib.py0000644000000000000000000000041113451103022020403 0ustar 00000000000000from roundup.dist.command.build import build_message_files, check_manifest from distutils.command.install_lib import install_lib as base class install_lib(base): def run(self): check_manifest() build_message_files(self) base.run(self)