chiark - git - mdw - runlisp/blob - mdwsetup.py

   1 ### -*-python-*-
   2 ###
   3 ### Utility module for Python build systems
   4 ###
   5 ### (c) 2009 Straylight/Edgeware
   6 ###
   7
   8 ###----- Licensing notice ---------------------------------------------------
   9 ###
  10 ### This file is part of the Common Files Distribution (`common')
  11 ###
  12 ### `Common' is free software; you can redistribute it and/or modify
  13 ### it under the terms of the GNU General Public License as published by
  14 ### the Free Software Foundation; either version 2 of the License, or
  15 ### (at your option) any later version.
  16 ###
  17 ### `Common' is distributed in the hope that it will be useful,
  18 ### but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ### GNU General Public License for more details.
  21 ###
  22 ### You should have received a copy of the GNU General Public License
  23 ### along with `common'; if not, write to the Free Software Foundation,
  24 ### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25
  26 from __future__ import with_statement
  27
  28 import sys as SYS
  29 import os as OS
  30 import re as RE
  31 import subprocess as SUB
  32
  33 import distutils.core as DC
  34 import distutils.log as DL
  35
  36 ###--------------------------------------------------------------------------
  37 ### Compatibility hacks.
  38
  39 def with_metaclass(meta, *supers):
  40   return meta("#<anonymous base %s>" % meta.__name__,
  41               supers or (object,), dict())
  42
  43 ###--------------------------------------------------------------------------
  44 ### Random utilities.
  45
  46 def uniquify(seq):
  47   """
  48   Return a list of the elements of SEQ, with duplicates removed.
  49
  50   Only the first occurrence (according to `==') is left.
  51   """
  52   seen = {}
  53   out = []
  54   for item in seq:
  55     if item not in seen:
  56       seen[item] = True
  57       out.append(item)
  58   return out
  59
  60 ###--------------------------------------------------------------------------
  61 ### Subprocess hacking.
  62
  63 class SubprocessFailure (Exception):
  64   def __init__(me, file, rc):
  65     me.args = (file, rc)
  66     me.file = file
  67     me.rc = rc
  68   def __str__(me):
  69     if OS.WIFEXITED(me.rc):
  70       return '%s failed (rc = %d)' % (me.file, OS.WEXITSTATUS(me.rc))
  71     elif OS.WIFSIGNALED(me.rc):
  72       return '%s died (signal %d)' % (me.file, OS.WTERMSIG(me.rc))
  73     else:
  74       return '%s died inexplicably' % (me.file)
  75
  76 def progoutput(command):
  77   """
  78   Run the shell COMMAND and return its standard output.
  79
  80   The COMMAND must produce exactly one line of output, and must exit with
  81   status zero.
  82   """
  83   kid = SUB.Popen(command, stdout = SUB.PIPE, universal_newlines = True)
  84   try:
  85     out = kid.stdout.readline()
  86     junk = kid.stdout.read(1)
  87   finally:
  88     kid.stdout.close()
  89   if junk != '': raise ValueError \
  90     ("Child process `%s' produced unspected output %r" % (command, junk))
  91   rc = kid.wait()
  92   if rc != 0: raise SubprocessFailure(command, rc)
  93   return out.rstrip('\n')
  94
  95 ###--------------------------------------------------------------------------
  96 ### External library packages.
  97
  98 INCLUDEDIRS = []
  99 LIBDIRS = []
 100 LIBS = []
 101
 102 def pkg_config(pkg, version):
 103   """
 104   Find the external package PKG and store the necessary compiler flags.
 105
 106   The include-directory names are stored in INCLUDEDIRS; the
 107   library-directory names are in LIBDIRS; and the library names themselves
 108   are in LIBS.
 109   """
 110
 111   def weird(what, word):
 112     raise ValueError \
 113       ("Unexpected `%s' item `%s' from package `%s'" % (what, word, pkg))
 114
 115   spec = '%s >= %s' % (pkg, version)
 116
 117   try: cflags = OS.environ["%s_CFLAGS" % pkg]
 118   except KeyError: cflags = progoutput(['pkg-config', '--cflags', spec])
 119   for word in cflags.split():
 120     if word.startswith('-I'): INCLUDEDIRS.append(word[2:])
 121     else: weird('CFLAGS', word)
 122   try: libs = OS.environ["%s_LIBS" % pkg]
 123   except KeyError: libs = progoutput(['pkg-config', '--libs', spec])
 124   for word in libs.split():
 125     if word.startswith('-L'): LIBDIRS.append(word[2:])
 126     elif word.startswith('-l'): LIBS.append(word[2:])
 127     else: weird('LIBS', word)
 128
 129 ###--------------------------------------------------------------------------
 130 ### Substituting variables in files.
 131
 132 class BaseGenFile (object):
 133   """
 134   A base class for file generators.
 135
 136   Instances of subclasses are suitable for listing in the `genfiles'
 137   attribute, passed to `setup'.
 138
 139   Subclasses need to implement `_gen', which should simply do the work of
 140   generating the target file from its sources.  This class will print
 141   progress messages and check whether the target actually needs regenerating.
 142   """
 143   def __init__(me, target, sources = []):
 144     me.target = target
 145     me.sources = sources
 146   def _needs_update_p(me):
 147     if not OS.path.exists(me.target): return True
 148     t_target = OS.stat(me.target).st_mtime
 149     for s in me.sources:
 150       if OS.stat(s).st_mtime >= t_target: return True
 151     return False
 152   def gen(me, dry_run_p = False):
 153     if not me._needs_update_p(): return
 154     DL.log(DL.INFO, "generate `%s' from %s", me.target,
 155            ', '.join("`%s'" % s for s in me.sources))
 156     if not dry_run_p: me._gen()
 157   def clean(me, dry_run_p):
 158     if not OS.path.exists(me.target): return
 159     DL.log(DL.INFO, "delete `%s'", me.target)
 160     if not dry_run_p: OS.remove(me.target)
 161
 162 class Derive (BaseGenFile):
 163   """
 164   Derive TARGET from SOURCE by making simple substitutions.
 165
 166   The SOURCE may contain markers %FOO%; these are replaced by SUBSTMAP['FOO']
 167   in the TARGET file.
 168   """
 169   RX_SUBST = RE.compile(r'\%(\w+)\%')
 170   def __init__(me, target, source, substmap):
 171     BaseGenFile.__init__(me, target, [source])
 172     me._map = substmap
 173   def _gen(me):
 174     temp = me.target + '.new'
 175     with open(temp, 'w') as ft:
 176       with open(me.sources[0], 'r') as fs:
 177         for line in fs:
 178           ft.write(me.RX_SUBST.sub((lambda m: me._map[m.group(1)]), line))
 179     OS.rename(temp, me.target)
 180
 181 class Generate (BaseGenFile):
 182   """
 183   Generate TARGET by running the SOURCE Python script.
 184
 185   If SOURCE is omitted, replace the extension of TARGET by `.py'.
 186   """
 187   def __init__(me, target, source = None):
 188     if source is None: source = OS.path.splitext(target)[0] + '.py'
 189     BaseGenFile.__init__(me, target, [source])
 190   def _gen(me):
 191     temp = me.target + '.new'
 192     with open(temp, 'w') as ft:
 193       rc = SUB.call([SYS.executable, me.sources[0]], stdout = ft)
 194     if rc != 0: raise SubprocessFailure(me.sources[0], rc << 8)
 195     OS.rename(temp, me.target)
 196
 197 ## Backward compatibility.
 198 def derive(target, source, substmap): Derive(target, source, substmap).gen()
 199 def generate(target, source = None): Generate(target, source).gen()
 200
 201 ###--------------------------------------------------------------------------
 202 ### Discovering version numbers.
 203
 204 def auto_version(writep = True):
 205   """
 206   Returns the package version number.
 207
 208   As a side-effect, if WRITEP is true, then write the version number to the
 209   RELEASE file so that it gets included in distributions.
 210
 211   All of this is for backwards compatibility.  New projects should omit the
 212   `version' keyword entirely and let `setup' discover it and write it into
 213   tarballs automatically.
 214   """
 215   version = progoutput(['./auto-version'])
 216   if writep:
 217     with open('RELEASE.new', 'w') as ft: ft.write('%s\n' % version)
 218     OS.rename('RELEASE.new', 'RELEASE')
 219   return version
 220
 221 ###--------------------------------------------------------------------------
 222 ### Adding new commands.
 223
 224 CMDS = {}
 225
 226 class CommandClass (type):
 227   """
 228   Metaclass for command classes: automatically adds them to the `CMDS' map.
 229   """
 230   def __new__(cls, name, supers, dict):
 231     c = super(CommandClass, cls).__new__(cls, name, supers, dict)
 232     try: name = c.NAME
 233     except AttributeError: pass
 234     else: CMDS[name] = c
 235     return c
 236
 237 class Command (with_metaclass(CommandClass, DC.Command, object)):
 238   """
 239   Base class for `mdwsetup' command classes.
 240
 241   This provides the automatic registration machinery, via the metaclass, and
 242   also trivial implementations of various responsibilities of `DC.Command'
 243   methods and attributes.
 244   """
 245   __metaclass__ = CommandClass
 246   user_options = []
 247   def initialize_options(me): pass
 248   def finalize_options(me): pass
 249   def run_subs(me):
 250     for s in me.get_sub_commands(): me.run_command(s)
 251
 252 ###--------------------------------------------------------------------------
 253 ### Some handy new commands.
 254
 255 class distdir (Command):
 256   NAME = 'distdir'
 257   description = "print the distribution directory name to stdout"
 258   def run(me):
 259     d = me.distribution
 260     print('%s-%s' % (d.get_name(), d.get_version()))
 261
 262 class build_gen (Command):
 263   """
 264   Generate files, according to the `genfiles'.
 265
 266   The `genfiles' keyword argument to `setup' lists a number of objects which
 267   guide the generation of output files.  These objects must implement the
 268   following methods.
 269
 270   clean(DRY_RUN_P)      Remove the output files.
 271
 272   gen(DRY_RUN_P)        Generate the output files, if they don't exist or are
 273                         out of date with respect to their prerequisites.
 274
 275   If DRY_RUN_P is true then the methods must not actually do anything with a
 276   lasting effect, but should print progress messages as usual.
 277   """
 278   NAME = 'build_gen'
 279   description = "build generated source files"
 280   def run(me):
 281     d = me.distribution
 282     for g in d.genfiles: g.gen(dry_run_p = me.dry_run)
 283
 284 from distutils.command.build import build as _build
 285 class build (_build, Command):
 286   ## Add `build_gen' early in the list of subcommands.
 287   NAME = 'build'
 288   sub_commands = [('build_gen', lambda me: me.distribution.genfiles)]
 289   sub_commands += _build.sub_commands
 290
 291 class test (Command):
 292   """
 293   Run unit tests, according to the `unittests'.
 294
 295   The `unittests' keyword argument to `setup' lists module names (or other
 296   things acceptable to the `loadTestsFromNames' test-loader method) to be
 297   run.  The build library directory is prepended to the load path before
 298   running the tests to ensure that the newly built modules are tested.  If
 299   `unittest_dir' is set, then this is appended to the load path so that test
 300   modules can be found there.
 301   """
 302   NAME = "test"
 303   description = "run the included test suite"
 304
 305   user_options = \
 306     [('build-lib=', 'b', "directory containing compiled moules"),
 307      ('tests=', 't', "tests to run"),
 308      ('verbose-test', 'V', "run tests verbosely")]
 309
 310   def initialize_options(me):
 311     me.build_lib = None
 312     me.verbose_test = False
 313     me.tests = None
 314   def finalize_options(me):
 315     me.set_undefined_options('build', ('build_lib', 'build_lib'))
 316   def run(me):
 317     import unittest as U
 318     d = me.distribution
 319     SYS.path = [me.build_lib] + SYS.path
 320     if d.unittest_dir is not None: SYS.path.append(d.unittest_dir)
 321     if me.tests is not None: tests = me.tests.split(",")
 322     else: tests = d.unittests
 323     suite = U.defaultTestLoader.loadTestsFromNames(tests)
 324     runner = U.TextTestRunner(verbosity = me.verbose_test and 2 or 1)
 325     if me.dry_run: return
 326     result = runner.run(suite)
 327     if result.errors or result.failures or \
 328        getattr(result, "unexpectedSuccesses", 0):
 329       SYS.exit(2)
 330
 331 class clean_gen (Command):
 332   """
 333   Remove the generated files, as listed in `genfiles'.
 334
 335   See the `build_gen' command for more detailed information.
 336   """
 337   NAME = 'clean_gen'
 338   description = "clean generated source files"
 339   def run(me):
 340     d = me.distribution
 341     for g in d.genfiles: g.clean(dry_run_p = me.dry_run)
 342
 343 class clean_others (Command):
 344   """
 345   Remove the files listed in the `cleanfiles' argument to `setup'.
 346   """
 347   NAME = 'clean_others'
 348   description = "clean miscellaneous output files"
 349   def run(me):
 350     d = me.distribution
 351     for f in d.cleanfiles:
 352       if not OS.path.exists(f): continue
 353       DL.log(DL.INFO, "delete `%s'", f)
 354       if not me.dry_run: OS.remove(f)
 355
 356 from distutils.command.clean import clean as _clean
 357 class clean (_clean, Command):
 358   ## Add `clean_gen' and `clean_others' to the list of subcommands.
 359   NAME = 'clean'
 360   sub_commands = [('clean_gen', lambda me: me.distribution.genfiles),
 361                   ('clean_others', lambda me: me.distribution.cleanfiles)]
 362   sub_commands += _clean.sub_commands
 363   def run(me):
 364     me.run_subs()
 365     _clean.run(me)
 366
 367 from distutils.command.sdist import sdist as _sdist
 368 class sdist (_sdist, Command):
 369   ## Write a `RELEASE' file to the output, if we extracted the version number
 370   ## from version control.  Also arrange to dereference symbolic links while
 371   ## copying.  Symlinks to directories will go horribly wrong, so don't do
 372   ## that.
 373   NAME = 'sdist'
 374   def make_release_tree(me, base_dir, files):
 375     _sdist.make_release_tree(me, base_dir, files)
 376     d = me.distribution
 377     if d._auto_version_p:
 378       v = d.metadata.get_version()
 379       DL.log(DL.INFO, "write `RELEASE' file: %s" % v)
 380       with open(OS.path.join(base_dir, 'RELEASE'), 'w') as f:
 381         f.write('%s\n' % v)
 382   def copy_file(me, infile, outfile, link = None, *args, **kw):
 383     if OS.path.islink(infile): link = None
 384     return _sdist.copy_file(me, infile, outfile, link = link, *args, **kw)
 385
 386 ###--------------------------------------------------------------------------
 387 ### Our own version of `setup'.
 388
 389 class Dist (DC.Distribution):
 390   ## Like the usual version, but with some additional attributes to support
 391   ## our enhanced commands.
 392   def __init__(me, attrs = None):
 393     me.genfiles = []
 394     me.unittest_dir = None
 395     me.unittests = []
 396     me.cleanfiles = []
 397     me._auto_version_p = False
 398     DC.Distribution.__init__(me, attrs)
 399     if me.metadata.version is None:
 400       me.metadata.version = auto_version(writep = False)
 401       me._auto_version_p = True
 402     me.cleanfiles = set(me.cleanfiles)
 403     me.cleanfiles.add('MANIFEST')
 404
 405 def setup(cmdclass = {}, distclass = Dist, **kw):
 406   ## Like the usual version, but provides defaults more suited to our
 407   ## purposes.
 408   cmds = dict()
 409   cmds.update(CMDS)
 410   cmds.update(cmdclass)
 411   DC.setup(cmdclass = cmds, distclass = distclass, **kw)
 412
 413 ###----- That's all, folks --------------------------------------------------