aboutsummaryrefslogtreecommitdiffstats
path: root/waflib/extras/autowaf.py
diff options
context:
space:
mode:
Diffstat (limited to 'waflib/extras/autowaf.py')
-rw-r--r--waflib/extras/autowaf.py1419
1 files changed, 1419 insertions, 0 deletions
diff --git a/waflib/extras/autowaf.py b/waflib/extras/autowaf.py
new file mode 100644
index 0000000..51077d1
--- /dev/null
+++ b/waflib/extras/autowaf.py
@@ -0,0 +1,1419 @@
+import glob
+import os
+import subprocess
+import sys
+import time
+
+from waflib import Configure, ConfigSet, Build, Context, Logs, Options, Utils
+from waflib.TaskGen import feature, before, after
+
+global g_is_child
+g_is_child = False
+
+NONEMPTY = -10
+
+if sys.platform == 'win32':
+ lib_path_name = 'PATH'
+elif sys.platform == 'darwin':
+ lib_path_name = 'DYLD_LIBRARY_PATH'
+else:
+ lib_path_name = 'LD_LIBRARY_PATH'
+
+# Compute dependencies globally
+# import preproc
+# preproc.go_absolute = True
+
+@feature('c', 'cxx')
+@after('apply_incpaths')
+def include_config_h(self):
+ self.env.append_value('INCPATHS', self.bld.bldnode.abspath())
+
+class OptionsContext(Options.OptionsContext):
+ def __init__(self, **kwargs):
+ super(OptionsContext, self).__init__(**kwargs)
+ set_options(self)
+
+ def configuration_options(self):
+ return self.get_option_group('Configuration options')
+
+ def add_flags(self, group, flags):
+ """Tersely add flags (a dictionary of longname:desc) to a group"""
+ for name, desc in flags.items():
+ group.add_option('--' + name, action='store_true',
+ dest=name.replace('-', '_'), help=desc)
+
+def set_options(opt, debug_by_default=False):
+ "Add standard autowaf options"
+ opts = opt.get_option_group('Configuration options')
+
+ # Standard directory options
+ opts.add_option('--bindir', type='string',
+ help="executable programs [default: PREFIX/bin]")
+ opts.add_option('--configdir', type='string',
+ help="configuration data [default: PREFIX/etc]")
+ opts.add_option('--datadir', type='string',
+ help="shared data [default: PREFIX/share]")
+ opts.add_option('--includedir', type='string',
+ help="header files [default: PREFIX/include]")
+ opts.add_option('--libdir', type='string',
+ help="libraries [default: PREFIX/lib]")
+ opts.add_option('--mandir', type='string',
+ help="manual pages [default: DATADIR/man]")
+ opts.add_option('--docdir', type='string',
+ help="HTML documentation [default: DATADIR/doc]")
+
+ # Build options
+ if debug_by_default:
+ opts.add_option('--optimize', action='store_false', default=True,
+ dest='debug', help="build optimized binaries")
+ else:
+ opts.add_option('-d', '--debug', action='store_true', default=False,
+ dest='debug', help="build debuggable binaries")
+ opts.add_option('--pardebug', action='store_true', default=False,
+ dest='pardebug',
+ help="build debug libraries with D suffix")
+
+ opts.add_option('-s', '--strict', action='store_true', default=False,
+ dest='strict',
+ help="use strict compiler flags and show all warnings")
+ opts.add_option('-S', '--ultra-strict', action='store_true', default=False,
+ dest='ultra_strict',
+ help="use extremely strict compiler flags (likely noisy)")
+ opts.add_option('--docs', action='store_true', default=False, dest='docs',
+ help="build documentation (requires doxygen)")
+
+ # Test options
+ if hasattr(Context.g_module, 'test'):
+ test_opts = opt.add_option_group('Test options', '')
+ opts.add_option('-T', '--test', action='store_true', dest='build_tests',
+ help='build unit tests')
+ opts.add_option('--no-coverage', action='store_true',
+ dest='no_coverage',
+ help='do not instrument code for test coverage')
+ test_opts.add_option('--wrapper', type='string',
+ dest='test_wrapper',
+ help='command prefix for tests (e.g. valgrind)')
+
+ # Run options
+ run_opts = opt.add_option_group('Run options')
+ run_opts.add_option('--cmd', type='string', dest='cmd',
+ help='command to run from build directory')
+
+class ConfigureContext(Configure.ConfigurationContext):
+ """configures the project"""
+
+ def __init__(self, **kwargs):
+ self.line_just = 45
+ if hasattr(Context.g_module, 'line_just'):
+ self.line_just = Context.g_module.line_just
+
+ super(ConfigureContext, self).__init__(**kwargs)
+ self.run_env = ConfigSet.ConfigSet()
+ self.system_include_paths = set()
+
+ def pre_recurse(self, node):
+ if len(self.stack_path) == 1:
+ Logs.pprint('BOLD', 'Configuring %s' % node.parent.srcpath())
+ super(ConfigureContext, self).pre_recurse(node)
+
+ def store(self):
+ self.env.AUTOWAF_RUN_ENV = self.run_env.get_merged_dict()
+ for path in sorted(self.system_include_paths):
+ if 'COMPILER_CC' in self.env:
+ self.env.append_value('CFLAGS', ['-isystem', path])
+ if 'COMPILER_CXX' in self.env:
+ self.env.append_value('CXXFLAGS', ['-isystem', path])
+
+ super(ConfigureContext, self).store()
+
+ def build_path(self, path='.'):
+ """Return `path` within the build directory"""
+ return str(self.path.get_bld().find_node(path))
+
+def get_check_func(conf, lang):
+ if lang == 'c':
+ return conf.check_cc
+ elif lang == 'cxx':
+ return conf.check_cxx
+ else:
+ Logs.error("Unknown header language `%s'" % lang)
+
+def check_header(conf, lang, name, define='', mandatory=True):
+ "Check for a header"
+ check_func = get_check_func(conf, lang)
+ if define != '':
+ check_func(header_name=name,
+ define_name=define,
+ mandatory=mandatory)
+ else:
+ check_func(header_name=name, mandatory=mandatory)
+
+def check_function(conf, lang, name, **args):
+ "Check for a function"
+ header_names = Utils.to_list(args['header_name'])
+ includes = ''.join(['#include <%s>\n' % x for x in header_names])
+ fragment = '''
+%s
+int main() { return !(void(*)())(%s); }
+''' % (includes, name)
+
+ check_func = get_check_func(conf, lang)
+ args['msg'] = 'Checking for %s' % name
+ check_func(fragment=fragment, **args)
+
+def nameify(name):
+ return (name.replace('/', '_').replace('++', 'PP')
+ .replace('-', '_').replace('.', '_'))
+
+def define(conf, var_name, value):
+ conf.define(var_name, value)
+ conf.env[var_name] = value
+
+def check_pkg(conf, name, **args):
+ "Check for a package iff it hasn't been checked for yet"
+ if args['uselib_store'].lower() in conf.env['AUTOWAF_LOCAL_LIBS']:
+ return
+
+ class CheckType:
+ OPTIONAL = 1
+ MANDATORY = 2
+
+ var_name = 'CHECKED_' + nameify(args['uselib_store'])
+ check = var_name not in conf.env
+ mandatory = 'mandatory' not in args or args['mandatory']
+ if not check and 'atleast_version' in args:
+ # Re-check if version is newer than previous check
+ checked_version = conf.env['VERSION_' + name]
+ if checked_version and checked_version < args['atleast_version']:
+ check = True
+ if not check and mandatory and conf.env[var_name] == CheckType.OPTIONAL:
+ # Re-check if previous check was optional but this one is mandatory
+ check = True
+ if check:
+ found = None
+ pkg_var_name = 'PKG_' + name.replace('-', '_')
+ pkg_name = name
+ if conf.env.PARDEBUG:
+ args['mandatory'] = False # Smash mandatory arg
+ found = conf.check_cfg(package=pkg_name + 'D',
+ args="--cflags --libs", **args)
+ if found:
+ pkg_name += 'D'
+ if mandatory:
+ args['mandatory'] = True # Unsmash mandatory arg
+ if not found:
+ found = conf.check_cfg(package=pkg_name, args="--cflags --libs",
+ **args)
+ if found:
+ conf.env[pkg_var_name] = pkg_name
+ if 'atleast_version' in args:
+ conf.env['VERSION_' + name] = args['atleast_version']
+ if mandatory:
+ conf.env[var_name] = CheckType.MANDATORY
+ else:
+ conf.env[var_name] = CheckType.OPTIONAL
+
+ if not conf.env.MSVC_COMPILER and 'system' in args and args['system']:
+ conf.system_include_paths.update(
+ conf.env['INCLUDES_' + nameify(args['uselib_store'])])
+
+def normpath(path):
+ if sys.platform == 'win32':
+ return os.path.normpath(path).replace('\\', '/')
+ else:
+ return os.path.normpath(path)
+
+def configure(conf):
+ def append_cxx_flags(flags):
+ conf.env.append_value('CFLAGS', flags)
+ conf.env.append_value('CXXFLAGS', flags)
+
+ if Options.options.docs:
+ conf.load('doxygen')
+
+ try:
+ conf.load('clang_compilation_database')
+ except Exception:
+ pass
+
+ prefix = normpath(os.path.abspath(os.path.expanduser(conf.env['PREFIX'])))
+
+ conf.env['DOCS'] = Options.options.docs and conf.env.DOXYGEN
+ conf.env['DEBUG'] = Options.options.debug or Options.options.pardebug
+ conf.env['PARDEBUG'] = Options.options.pardebug
+ conf.env['PREFIX'] = prefix
+
+ def config_dir(var, opt, default):
+ if opt:
+ conf.env[var] = normpath(opt)
+ else:
+ conf.env[var] = normpath(default)
+
+ opts = Options.options
+
+ config_dir('BINDIR', opts.bindir, os.path.join(prefix, 'bin'))
+ config_dir('SYSCONFDIR', opts.configdir, os.path.join(prefix, 'etc'))
+ config_dir('DATADIR', opts.datadir, os.path.join(prefix, 'share'))
+ config_dir('INCLUDEDIR', opts.includedir, os.path.join(prefix, 'include'))
+ config_dir('LIBDIR', opts.libdir, os.path.join(prefix, 'lib'))
+
+ datadir = conf.env['DATADIR']
+ config_dir('MANDIR', opts.mandir, os.path.join(datadir, 'man'))
+ config_dir('DOCDIR', opts.docdir, os.path.join(datadir, 'doc'))
+
+ if Options.options.debug:
+ if conf.env['MSVC_COMPILER']:
+ conf.env['CFLAGS'] = ['/Od', '/Z7', '/MTd', '/FS']
+ conf.env['CXXFLAGS'] = ['/Od', '/Z7', '/MTd', '/FS']
+ conf.env['LINKFLAGS'] = ['/DEBUG', '/MANIFEST']
+ else:
+ conf.env['CFLAGS'] = ['-O0', '-g']
+ conf.env['CXXFLAGS'] = ['-O0', '-g']
+ else:
+ if conf.env['MSVC_COMPILER']:
+ append_cxx_flags(['/MD', '/FS', '/DNDEBUG'])
+ else:
+ append_cxx_flags(['-DNDEBUG'])
+
+ if conf.env.MSVC_COMPILER:
+ Options.options.no_coverage = True
+ append_cxx_flags(['/nologo',
+ '/FS',
+ '/DNDEBUG',
+ '/D_CRT_SECURE_NO_WARNINGS',
+ '/experimental:external',
+ '/external:W0',
+ '/external:anglebrackets'])
+ conf.env.append_value('LINKFLAGS', '/nologo')
+ if Options.options.strict or Options.options.ultra_strict:
+ ms_strict_flags = ['/Wall',
+ '/wd4061',
+ '/wd4200',
+ '/wd4514',
+ '/wd4571',
+ '/wd4625',
+ '/wd4626',
+ '/wd4706',
+ '/wd4710',
+ '/wd4820',
+ '/wd5026',
+ '/wd5027',
+ '/wd5045']
+ conf.env.append_value('CFLAGS', ms_strict_flags)
+ conf.env.append_value('CXXFLAGS', ms_strict_flags)
+ conf.env.append_value('CXXFLAGS', ['/EHsc'])
+ else:
+ if Options.options.ultra_strict:
+ Options.options.strict = True
+ conf.env.append_value('CFLAGS', ['-Wredundant-decls',
+ '-Wstrict-prototypes',
+ '-Wmissing-prototypes',
+ '-Wcast-qual'])
+ conf.env.append_value('CXXFLAGS', ['-Wcast-qual'])
+
+ if Options.options.strict:
+ conf.env.append_value('CFLAGS', ['-pedantic', '-Wshadow'])
+ if conf.env.DEST_OS != "darwin":
+ conf.env.append_value('LINKFLAGS', ['-Wl,--no-undefined'])
+ conf.env.append_value('CXXFLAGS', ['-Wnon-virtual-dtor',
+ '-Woverloaded-virtual'])
+ append_cxx_flags(['-Wall',
+ '-Wcast-align',
+ '-Wextra',
+ '-Wmissing-declarations',
+ '-Wno-unused-parameter',
+ '-Wstrict-overflow',
+ '-Wundef',
+ '-Wwrite-strings',
+ '-fstrict-overflow'])
+
+ # Add less universal flags after checking they work
+ extra_flags = ['-Wlogical-op',
+ '-Wsuggest-attribute=noreturn',
+ '-Wunsafe-loop-optimizations']
+ if conf.check_cc(cflags=['-Werror'] + extra_flags, mandatory=False,
+ msg="Checking for extra C warning flags"):
+ conf.env.append_value('CFLAGS', extra_flags)
+ if 'COMPILER_CXX' in conf.env:
+ if conf.check_cxx(cxxflags=['-Werror'] + extra_flags,
+ mandatory=False,
+ msg="Checking for extra C++ warning flags"):
+ conf.env.append_value('CXXFLAGS', extra_flags)
+
+ if not conf.env['MSVC_COMPILER']:
+ append_cxx_flags(['-fshow-column'])
+
+ conf.env.NO_COVERAGE = True
+ conf.env.BUILD_TESTS = False
+ try:
+ conf.env.BUILD_TESTS = Options.options.build_tests
+ conf.env.NO_COVERAGE = Options.options.no_coverage
+ if not Options.options.no_coverage:
+ # Set up unit test code coverage
+ if conf.is_defined('CLANG'):
+ for cov in [conf.env.CC[0].replace('clang', 'llvm-cov'),
+ 'llvm-cov']:
+ if conf.find_program(cov, var='LLVM_COV', mandatory=False):
+ break
+ else:
+ conf.check_cc(lib='gcov', define_name='HAVE_GCOV',
+ mandatory=False)
+ except Exception:
+ pass # Test options do not exist
+
+ # Define version in configuration
+ appname = getattr(Context.g_module, Context.APPNAME, 'noname')
+ version = getattr(Context.g_module, Context.VERSION, '0.0.0')
+ defname = appname.upper().replace('-', '_').replace('.', '_')
+ define(conf, defname + '_VERSION', version)
+
+ conf.env.prepend_value('CFLAGS', '-I' + os.path.abspath('.'))
+ conf.env.prepend_value('CXXFLAGS', '-I' + os.path.abspath('.'))
+
+def display_summary(conf, msgs=None):
+ if len(conf.stack_path) == 1:
+ display_msg(conf, "Install prefix", conf.env['PREFIX'])
+ if 'COMPILER_CC' in conf.env:
+ display_msg(conf, "C Flags", ' '.join(conf.env['CFLAGS']))
+ if 'COMPILER_CXX' in conf.env:
+ display_msg(conf, "C++ Flags", ' '.join(conf.env['CXXFLAGS']))
+ display_msg(conf, "Debuggable", bool(conf.env['DEBUG']))
+ display_msg(conf, "Build documentation", bool(conf.env['DOCS']))
+
+ if msgs is not None:
+ display_msgs(conf, msgs)
+
+def set_c_lang(conf, lang):
+ "Set a specific C language standard, like 'c99' or 'c11'"
+ if conf.env.MSVC_COMPILER:
+ # MSVC has no hope or desire to compile C99, just compile as C++
+ conf.env.append_unique('CFLAGS', ['/TP'])
+ else:
+ flag = '-std=%s' % lang
+ conf.check(cflags=['-Werror', flag],
+ msg="Checking for flag '%s'" % flag)
+ conf.env.append_unique('CFLAGS', [flag])
+
+def set_cxx_lang(conf, lang):
+ "Set a specific C++ language standard, like 'c++11', 'c++14', or 'c++17'"
+ if conf.env.MSVC_COMPILER:
+ if lang != 'c++14':
+ lang = 'c++latest'
+ conf.env.append_unique('CXXFLAGS', ['/std:%s' % lang])
+ else:
+ flag = '-std=%s' % lang
+ conf.check(cxxflags=['-Werror', flag],
+ msg="Checking for flag '%s'" % flag)
+ conf.env.append_unique('CXXFLAGS', [flag])
+
+def set_modern_c_flags(conf):
+ "Use the most modern C language available"
+ if 'COMPILER_CC' in conf.env:
+ if conf.env.MSVC_COMPILER:
+ # MSVC has no hope or desire to compile C99, just compile as C++
+ conf.env.append_unique('CFLAGS', ['/TP'])
+ else:
+ for flag in ['-std=c11', '-std=c99']:
+ if conf.check(cflags=['-Werror', flag], mandatory=False,
+ msg="Checking for flag '%s'" % flag):
+ conf.env.append_unique('CFLAGS', [flag])
+ break
+
+def set_modern_cxx_flags(conf, mandatory=False):
+ "Use the most modern C++ language available"
+ if 'COMPILER_CXX' in conf.env:
+ if conf.env.MSVC_COMPILER:
+ conf.env.append_unique('CXXFLAGS', ['/std:c++latest'])
+ else:
+ for lang in ['c++14', 'c++1y', 'c++11', 'c++0x']:
+ flag = '-std=%s' % lang
+ if conf.check(cxxflags=['-Werror', flag], mandatory=False,
+ msg="Checking for flag '%s'" % flag):
+ conf.env.append_unique('CXXFLAGS', [flag])
+ break
+
+def set_local_lib(conf, name, has_objects):
+ var_name = 'HAVE_' + nameify(name.upper())
+ define(conf, var_name, 1)
+ if has_objects:
+ if type(conf.env['AUTOWAF_LOCAL_LIBS']) != dict:
+ conf.env['AUTOWAF_LOCAL_LIBS'] = {}
+ conf.env['AUTOWAF_LOCAL_LIBS'][name.lower()] = True
+ else:
+ if type(conf.env['AUTOWAF_LOCAL_HEADERS']) != dict:
+ conf.env['AUTOWAF_LOCAL_HEADERS'] = {}
+ conf.env['AUTOWAF_LOCAL_HEADERS'][name.lower()] = True
+
+def append_property(obj, key, val):
+ if hasattr(obj, key):
+ setattr(obj, key, getattr(obj, key) + val)
+ else:
+ setattr(obj, key, val)
+
+def use_lib(bld, obj, libs):
+ abssrcdir = os.path.abspath('.')
+ libs_list = libs.split()
+ for l in libs_list:
+ in_headers = l.lower() in bld.env['AUTOWAF_LOCAL_HEADERS']
+ in_libs = l.lower() in bld.env['AUTOWAF_LOCAL_LIBS']
+ if in_libs:
+ append_property(obj, 'use', ' lib%s ' % l.lower())
+ append_property(obj, 'framework', bld.env['FRAMEWORK_' + l])
+ if in_headers or in_libs:
+ if bld.env.MSVC_COMPILER:
+ inc_flag = '/I' + os.path.join(abssrcdir, l.lower())
+ else:
+ inc_flag = '-iquote ' + os.path.join(abssrcdir, l.lower())
+ for f in ['CFLAGS', 'CXXFLAGS']:
+ if inc_flag not in bld.env[f]:
+ bld.env.prepend_value(f, inc_flag)
+ else:
+ append_property(obj, 'uselib', ' ' + l)
+
+@feature('c', 'cxx')
+@before('apply_link')
+def version_lib(self):
+ if self.env.DEST_OS == 'win32':
+ self.vnum = None # Prevent waf from automatically appending -0
+ if self.env['PARDEBUG']:
+ applicable = ['cshlib', 'cxxshlib', 'cstlib', 'cxxstlib']
+ if [x for x in applicable if x in self.features]:
+ self.target = self.target + 'D'
+
+def set_lib_env(conf, name, version):
+ "Set up environment for local library as if found via pkg-config."
+ NAME = name.upper()
+ major_ver = version.split('.')[0]
+ pkg_var_name = 'PKG_' + name.replace('-', '_') + '_' + major_ver
+ lib_name = '%s-%s' % (name, major_ver)
+ lib_path = [str(conf.path.get_bld())]
+ if conf.env.PARDEBUG:
+ lib_name += 'D'
+ conf.env[pkg_var_name] = lib_name
+ conf.env['INCLUDES_' + NAME] = ['${INCLUDEDIR}/%s-%s' % (name, major_ver)]
+ conf.env['LIBPATH_' + NAME] = lib_path
+ conf.env['LIB_' + NAME] = [lib_name]
+
+ conf.run_env.append_unique(lib_path_name, lib_path)
+ conf.define(NAME + '_VERSION', version)
+
+def display_msg(conf, msg, status=None, color=None):
+ color = 'CYAN'
+ if type(status) == bool and status:
+ color = 'GREEN'
+ status = 'yes'
+ elif type(status) == bool and not status or status == "False":
+ color = 'YELLOW'
+ status = 'no'
+ Logs.pprint('BOLD', '%s' % msg.ljust(conf.line_just), sep='')
+ Logs.pprint('BOLD', ":", sep='')
+ Logs.pprint(color, status)
+
+def display_msgs(conf, msgs):
+ for k, v in msgs.items():
+ display_msg(conf, k, v)
+
+def link_flags(env, lib):
+ return ' '.join(map(lambda x: env['LIB_ST'] % x,
+ env['LIB_' + lib]))
+
+def compile_flags(env, lib):
+ return ' '.join(map(lambda x: env['CPPPATH_ST'] % x,
+ env['INCLUDES_' + lib]))
+
+def set_recursive():
+ global g_is_child
+ g_is_child = True
+
+def is_child():
+ global g_is_child
+ return g_is_child
+
+def build_pc(bld, name, version, version_suffix, libs, subst_dict={}):
+ """Build a pkg-config file for a library.
+
+ name -- uppercase variable name (e.g. 'SOMENAME')
+ version -- version string (e.g. '1.2.3')
+ version_suffix -- name version suffix (e.g. '2')
+ libs -- string/list of dependencies (e.g. 'LIBFOO GLIB')
+ """
+
+ pkg_prefix = bld.env['PREFIX']
+ if pkg_prefix[-1] == '/':
+ pkg_prefix = pkg_prefix[:-1]
+
+ target = name.lower()
+ if version_suffix != '':
+ target += '-' + version_suffix
+
+ if bld.env['PARDEBUG']:
+ target += 'D'
+
+ target += '.pc'
+
+ libdir = bld.env['LIBDIR']
+ if libdir.startswith(pkg_prefix):
+ libdir = libdir.replace(pkg_prefix, '${exec_prefix}')
+
+ includedir = bld.env['INCLUDEDIR']
+ if includedir.startswith(pkg_prefix):
+ includedir = includedir.replace(pkg_prefix, '${prefix}')
+
+ obj = bld(features='subst',
+ source='%s.pc.in' % name.lower(),
+ target=target,
+ install_path=os.path.join(bld.env['LIBDIR'], 'pkgconfig'),
+ exec_prefix='${prefix}',
+ PREFIX=pkg_prefix,
+ EXEC_PREFIX='${prefix}',
+ LIBDIR=libdir,
+ INCLUDEDIR=includedir)
+
+ if type(libs) != list:
+ libs = libs.split()
+
+ subst_dict[name + '_VERSION'] = version
+ subst_dict[name + '_MAJOR_VERSION'] = version[0:version.find('.')]
+ for i in libs:
+ subst_dict[i + '_LIBS'] = link_flags(bld.env, i)
+ lib_cflags = compile_flags(bld.env, i)
+ if lib_cflags == '':
+ lib_cflags = ' '
+ subst_dict[i + '_CFLAGS'] = lib_cflags
+
+ obj.__dict__.update(subst_dict)
+
+def build_dir(name, subdir):
+ if is_child():
+ return os.path.join('build', name, subdir)
+ else:
+ return os.path.join('build', subdir)
+
+
+def make_simple_dox(name):
+ "Clean up messy Doxygen documentation after it is built"
+ name = name.lower()
+ NAME = name.upper()
+ try:
+ top = os.getcwd()
+ os.chdir(build_dir(name, 'doc/html'))
+ page = 'group__%s.html' % name
+ if not os.path.exists(page):
+ return
+ for i in [
+ ['%s_API ' % NAME, ''],
+ ['%s_DEPRECATED ' % NAME, ''],
+ ['group__%s.html' % name, ''],
+ ['&#160;', ''],
+ [r'<script.*><\/script>', ''],
+ [r'<hr\/><a name="details" id="details"><\/a><h2>.*<\/h2>', ''],
+ [r'<link href=\"tabs.css\" rel=\"stylesheet\" type=\"text\/css\"\/>',
+ ''],
+ [r'<img class=\"footer\" src=\"doxygen.png\" alt=\"doxygen\"\/>',
+ 'Doxygen']]:
+ os.system("sed -i 's/%s/%s/g' %s" % (i[0], i[1], page))
+ os.rename('group__%s.html' % name, 'index.html')
+ for i in (glob.glob('*.png') +
+ glob.glob('*.html') +
+ glob.glob('*.js') +
+ glob.glob('*.css')):
+ if i != 'index.html' and i != 'style.css':
+ os.remove(i)
+ os.chdir(top)
+ os.chdir(build_dir(name, 'doc/man/man3'))
+ for i in glob.glob('*.3'):
+ os.system("sed -i 's/%s_API //' %s" % (NAME, i))
+ for i in glob.glob('_*'):
+ os.remove(i)
+ os.chdir(top)
+ except Exception as e:
+ Logs.error("Failed to fix up %s documentation: %s" % (name, e))
+ finally:
+ os.chdir(top)
+
+def build_dox(bld, name, version, srcdir, blddir, outdir='', versioned=True):
+ """Build Doxygen API documentation"""
+ if not bld.env['DOCS']:
+ return
+
+ # Doxygen paths in are relative to the doxygen file, not build directory
+ if is_child():
+ src_dir = os.path.join(srcdir, name.lower())
+ else:
+ src_dir = srcdir
+
+ subst_tg = bld(features='subst',
+ source='doc/reference.doxygen.in',
+ target='doc/reference.doxygen',
+ install_path='',
+ name='doxyfile')
+
+ subst_dict = {
+ name + '_VERSION': version,
+ name + '_SRCDIR': os.path.abspath(src_dir),
+ name + '_DOC_DIR': ''
+ }
+
+ subst_tg.__dict__.update(subst_dict)
+
+ subst_tg.post()
+
+ docs = bld(features='doxygen',
+ doxyfile='doc/reference.doxygen')
+
+ docs.post()
+
+ outname = name.lower()
+ if versioned:
+ outname += '-%d' % int(version[0:version.find('.')])
+ bld.install_files(
+ os.path.join('${DOCDIR}', outname, outdir, 'html'),
+ bld.path.get_bld().ant_glob('doc/html/*'))
+ for i in range(1, 8):
+ bld.install_files('${MANDIR}/man%d' % i,
+ bld.path.get_bld().ant_glob('doc/man/man%d/*' % i,
+ excl='**/_*'))
+
+
+def build_version_files(header_path, source_path, domain, major, minor, micro):
+ """Generate version code header"""
+ header_path = os.path.abspath(header_path)
+ source_path = os.path.abspath(source_path)
+ text = "int " + domain + "_major_version = " + str(major) + ";\n"
+ text += "int " + domain + "_minor_version = " + str(minor) + ";\n"
+ text += "int " + domain + "_micro_version = " + str(micro) + ";\n"
+ try:
+ o = open(source_path, 'w')
+ o.write(text)
+ o.close()
+ except IOError:
+ Logs.error('Failed to open %s for writing\n' % source_path)
+ sys.exit(-1)
+
+ text = "#ifndef __" + domain + "_version_h__\n"
+ text += "#define __" + domain + "_version_h__\n"
+ text += "extern const char* " + domain + "_revision;\n"
+ text += "extern int " + domain + "_major_version;\n"
+ text += "extern int " + domain + "_minor_version;\n"
+ text += "extern int " + domain + "_micro_version;\n"
+ text += "#endif /* __" + domain + "_version_h__ */\n"
+ try:
+ o = open(header_path, 'w')
+ o.write(text)
+ o.close()
+ except IOError:
+ Logs.warn('Failed to open %s for writing\n' % header_path)
+ sys.exit(-1)
+
+ return None
+
+def build_i18n_pot(bld, srcdir, dir, name, sources, copyright_holder=None):
+ Logs.info('Generating pot file from %s' % name)
+ pot_file = '%s.pot' % name
+
+ cmd = ['xgettext',
+ '--keyword=_',
+ '--keyword=N_',
+ '--keyword=S_',
+ '--from-code=UTF-8',
+ '-o', pot_file]
+
+ if copyright_holder:
+ cmd += ['--copyright-holder="%s"' % copyright_holder]
+
+ cmd += sources
+ Logs.info('Updating ' + pot_file)
+ subprocess.call(cmd, cwd=os.path.join(srcdir, dir))
+
+def build_i18n_po(bld, srcdir, dir, name, sources, copyright_holder=None):
+ pwd = os.getcwd()
+ os.chdir(os.path.join(srcdir, dir))
+ pot_file = '%s.pot' % name
+ po_files = glob.glob('po/*.po')
+ for po_file in po_files:
+ cmd = ['msgmerge',
+ '--update',
+ po_file,
+ pot_file]
+ Logs.info('Updating ' + po_file)
+ subprocess.call(cmd)
+ os.chdir(pwd)
+
+def build_i18n_mo(bld, srcdir, dir, name, sources, copyright_holder=None):
+ pwd = os.getcwd()
+ os.chdir(os.path.join(srcdir, dir))
+ po_files = glob.glob('po/*.po')
+ for po_file in po_files:
+ mo_file = po_file.replace('.po', '.mo')
+ cmd = ['msgfmt',
+ '-c',
+ '-f',
+ '-o',
+ mo_file,
+ po_file]
+ Logs.info('Generating ' + po_file)
+ subprocess.call(cmd)
+ os.chdir(pwd)
+
+def build_i18n(bld, srcdir, dir, name, sources, copyright_holder=None):
+ build_i18n_pot(bld, srcdir, dir, name, sources, copyright_holder)
+ build_i18n_po(bld, srcdir, dir, name, sources, copyright_holder)
+ build_i18n_mo(bld, srcdir, dir, name, sources, copyright_holder)
+
+class ExecutionEnvironment:
+ """Context that sets system environment variables for program execution"""
+ def __init__(self, changes):
+ self.original_environ = os.environ.copy()
+
+ self.diff = {}
+ for path_name, paths in changes.items():
+ value = os.pathsep.join(paths)
+ if path_name in os.environ:
+ value += os.pathsep + os.environ[path_name]
+
+ self.diff[path_name] = value
+
+ os.environ.update(self.diff)
+
+ def __str__(self):
+ return '\n'.join({'%s="%s"' % (k, v) for k, v in self.diff.items()})
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, type, value, traceback):
+ os.environ = self.original_environ
+
+class RunContext(Build.BuildContext):
+ "runs an executable from the build directory"
+ cmd = 'run'
+
+ def execute(self):
+ self.restore()
+ if not self.all_envs:
+ self.load_envs()
+
+ with ExecutionEnvironment(self.env.AUTOWAF_RUN_ENV) as env:
+ if Options.options.verbose:
+ Logs.pprint('GREEN', str(env) + '\n')
+
+ if Options.options.cmd:
+ Logs.pprint('GREEN', 'Running %s' % Options.options.cmd)
+ subprocess.call(Options.options.cmd, shell=True)
+ else:
+ Logs.error("error: Missing --cmd option for run command")
+
+def show_diff(from_lines, to_lines, from_filename, to_filename):
+ import difflib
+ import sys
+
+ for line in difflib.unified_diff(
+ from_lines, to_lines,
+ fromfile=os.path.abspath(from_filename),
+ tofile=os.path.abspath(to_filename)):
+ sys.stderr.write(line)
+
+def test_file_equals(patha, pathb):
+ import filecmp
+ import io
+
+ for path in (patha, pathb):
+ if not os.access(path, os.F_OK):
+ Logs.pprint('RED', 'error: missing file %s' % path)
+ return False
+
+ if filecmp.cmp(patha, pathb, shallow=False):
+ return True
+
+ with io.open(patha, 'rU', encoding='utf-8') as fa:
+ with io.open(pathb, 'rU', encoding='utf-8') as fb:
+ show_diff(fa.readlines(), fb.readlines(), patha, pathb)
+
+ return False
+
+def bench_time():
+ if hasattr(time, 'perf_counter'): # Added in Python 3.3
+ return time.perf_counter()
+ else:
+ return time.time()
+
+class TestOutput:
+ """Test output that is truthy if result is as expected"""
+ def __init__(self, expected, result=None):
+ self.stdout = self.stderr = None
+ self.expected = expected
+ self.result = result
+
+ def __bool__(self):
+ return self.expected is None or self.result == self.expected
+
+ __nonzero__ = __bool__
+
+def is_string(s):
+ if sys.version_info[0] < 3:
+ return isinstance(s, basestring)
+ return isinstance(s, str)
+
+class TestScope:
+ """Scope for running tests that maintains pass/fail statistics"""
+ def __init__(self, tst, name, defaults):
+ self.tst = tst
+ self.name = name
+ self.defaults = defaults
+ self.n_failed = 0
+ self.n_total = 0
+
+ def run(self, test, **kwargs):
+ if callable(test):
+ output = self._run_callable(test, **kwargs)
+ elif type(test) == list:
+ if 'name' not in kwargs:
+ import pipes
+ kwargs['name'] = ' '.join(map(pipes.quote, test))
+
+ output = self._run_command(test, **kwargs)
+ else:
+ raise Exception("Unknown test type")
+
+ if not output:
+ self.tst.log_bad('FAILED', kwargs['name'])
+
+ return self.tst.test_result(output)
+
+ def _run_callable(self, test, **kwargs):
+ expected = kwargs['expected'] if 'expected' in kwargs else True
+ return TestOutput(expected, test())
+
+ def _run_command(self, test, **kwargs):
+ if 'stderr' in kwargs and kwargs['stderr'] == NONEMPTY:
+ # Run with a temp file for stderr and check that it is non-empty
+ import tempfile
+ with tempfile.TemporaryFile(mode='w') as stderr:
+ kwargs['stderr'] = stderr
+ output = self.run(test, **kwargs)
+ return (output if not output else
+ self.run(
+ lambda: stderr.tell() > 0,
+ name=kwargs['name'] + ' error message'))
+
+ try:
+ # Run with stdout and stderr set to the appropriate streams
+ out_stream = self._stream('stdout', kwargs)
+ err_stream = self._stream('stderr', kwargs)
+ return self._exec(test, **kwargs)
+ finally:
+ out_stream = out_stream.close() if out_stream else None
+ err_stream = err_stream.close() if err_stream else None
+
+ def _stream(self, stream_name, kwargs):
+ s = kwargs[stream_name] if stream_name in kwargs else None
+ if is_string(s):
+ kwargs[stream_name] = open(s, 'wb')
+ return kwargs[stream_name]
+ return None
+
+ def _exec(self,
+ test,
+ expected=0,
+ name='',
+ stdin=None,
+ stdout=None,
+ stderr=None,
+ verbosity=1):
+ def stream(s):
+ return open(s, 'wb') if type(s) == str else s
+
+ if verbosity > 1:
+ self.tst.log_good('RUN ', name)
+
+ if Options.options.test_wrapper:
+ test = [Options.options.test_wrapper] + test
+
+ output = TestOutput(expected)
+ with open(os.devnull, 'wb') as null:
+ out = null if verbosity < 3 and not stdout else stdout
+ err = null if verbosity < 2 and not stderr else stderr
+ proc = subprocess.Popen(test, stdin=stdin, stdout=out, stderr=err)
+ output.stdout, output.stderr = proc.communicate()
+ output.result = proc.returncode
+
+ if output and verbosity > 0:
+ self.tst.log_good(' OK', name)
+
+ return output
+
+class TestContext(Build.BuildContext):
+ "runs test suite"
+ fun = cmd = 'test'
+
+ def __init__(self, **kwargs):
+ super(TestContext, self).__init__(**kwargs)
+ self.start_time = bench_time()
+ self.max_depth = 1
+
+ defaults = {'verbosity': Options.options.verbose}
+ self.stack = [TestScope(self, Context.g_module.APPNAME, defaults)]
+
+ def defaults(self):
+ return self.stack[-1].defaults
+
+ def finalize(self):
+ if self.stack[-1].n_failed > 0:
+ sys.exit(1)
+
+ super(TestContext, self).finalize()
+
+ def __call__(self, test, **kwargs):
+ return self.stack[-1].run(test, **self.args(**kwargs))
+
+ def file_equals(self, from_path, to_path, **kwargs):
+ kwargs.update({'expected': True,
+ 'name': '%s == %s' % (from_path, to_path)})
+ return self(lambda: test_file_equals(from_path, to_path), **kwargs)
+
+ def log_good(self, title, fmt, *args):
+ Logs.pprint('GREEN', '[%s] %s' % (title.center(10), fmt % args))
+
+ def log_bad(self, title, fmt, *args):
+ Logs.pprint('RED', '[%s] %s' % (title.center(10), fmt % args))
+
+ def pre_recurse(self, node):
+ wscript_module = Context.load_module(node.abspath())
+ group_name = wscript_module.APPNAME
+ self.stack.append(TestScope(self, group_name, self.defaults()))
+ self.max_depth = max(self.max_depth, len(self.stack) - 1)
+
+ bld_dir = node.get_bld().parent
+ if bld_dir != self.path.get_bld():
+ Logs.info('')
+
+ self.original_dir = os.getcwd()
+ Logs.info("Waf: Entering directory `%s'\n", bld_dir)
+ os.chdir(str(bld_dir))
+
+ if str(node.parent) == Context.top_dir:
+ self.clear_coverage()
+
+ self.log_good('=' * 10, 'Running %s tests', group_name)
+ super(TestContext, self).pre_recurse(node)
+
+ def test_result(self, success):
+ self.stack[-1].n_total += 1
+ self.stack[-1].n_failed += 1 if not success else 0
+ return success
+
+ def pop(self):
+ scope = self.stack.pop()
+ self.stack[-1].n_total += scope.n_total
+ self.stack[-1].n_failed += scope.n_failed
+ return scope
+
+ def post_recurse(self, node):
+ super(TestContext, self).post_recurse(node)
+
+ scope = self.pop()
+ duration = (bench_time() - self.start_time) * 1000.0
+ is_top = str(node.parent) == str(Context.top_dir)
+
+ if is_top and self.max_depth > 1:
+ Logs.info('')
+
+ self.log_good('=' * 10, '%d tests from %s ran (%d ms total)',
+ scope.n_total, scope.name, duration)
+
+ if not self.env.NO_COVERAGE:
+ if is_top:
+ self.gen_coverage()
+
+ if os.path.exists('coverage/index.html'):
+ self.log_good('COVERAGE', '<file://%s>',
+ os.path.abspath('coverage/index.html'))
+
+ successes = scope.n_total - scope.n_failed
+ Logs.pprint('GREEN', '[ PASSED ] %d tests' % successes)
+ if scope.n_failed > 0:
+ Logs.pprint('RED', '[ FAILED ] %d tests' % scope.n_failed)
+ if is_top:
+ Logs.info("\nWaf: Leaving directory `%s'" % os.getcwd())
+
+ os.chdir(self.original_dir)
+
+ def execute(self):
+ self.restore()
+ if not self.all_envs:
+ self.load_envs()
+
+ if not self.env.BUILD_TESTS:
+ self.fatal('Configuration does not include tests')
+
+ with ExecutionEnvironment(self.env.AUTOWAF_RUN_ENV) as env:
+ if self.defaults()['verbosity'] > 0:
+ Logs.pprint('GREEN', str(env) + '\n')
+ self.recurse([self.run_dir])
+
+ def src_path(self, path):
+ return os.path.relpath(os.path.join(str(self.path), path))
+
+ def args(self, **kwargs):
+ all_kwargs = self.defaults().copy()
+ all_kwargs.update(kwargs)
+ return all_kwargs
+
+ def group(self, name, **kwargs):
+ return TestGroup(
+ self, self.stack[-1].name, name, **self.args(**kwargs))
+
+ def set_test_defaults(self, **kwargs):
+ """Set default arguments to be passed to all tests"""
+ self.stack[-1].defaults.update(kwargs)
+
+ def clear_coverage(self):
+ """Zero old coverage data"""
+ try:
+ with open('cov-clear.log', 'w') as log:
+ subprocess.call(['lcov', '-z', '-d', str(self.path)],
+ stdout=log, stderr=log)
+
+ except Exception:
+ Logs.warn('Failed to run lcov to clear old coverage data')
+
+ def gen_coverage(self):
+ """Generate coverage data and report"""
+ try:
+ with open('cov.lcov', 'w') as out:
+ with open('cov.log', 'w') as err:
+ subprocess.call(['lcov', '-c', '--no-external',
+ '--rc', 'lcov_branch_coverage=1',
+ '-b', '.',
+ '-d', str(self.path)],
+ stdout=out, stderr=err)
+
+ if not os.path.isdir('coverage'):
+ os.makedirs('coverage')
+
+ with open('genhtml.log', 'w') as log:
+ subprocess.call(['genhtml',
+ '-o', 'coverage',
+ '--rc', 'genhtml_branch_coverage=1',
+ 'cov.lcov'],
+ stdout=log, stderr=log)
+
+ except Exception:
+ Logs.warn('Failed to run lcov to generate coverage report')
+
+class TestGroup:
+ def __init__(self, tst, suitename, name, **kwargs):
+ self.tst = tst
+ self.suitename = suitename
+ self.name = name
+ self.kwargs = kwargs
+ self.start_time = bench_time()
+ tst.stack.append(TestScope(tst, name, tst.defaults()))
+
+ def label(self):
+ return self.suitename + '.%s' % self.name if self.name else ''
+
+ def args(self, **kwargs):
+ all_kwargs = self.tst.args(**self.kwargs)
+ all_kwargs.update(kwargs)
+ return all_kwargs
+
+ def __enter__(self):
+ if 'verbosity' in self.kwargs and self.kwargs['verbosity'] > 0:
+ self.tst.log_good('-' * 10, self.label())
+ return self
+
+ def __call__(self, test, **kwargs):
+ return self.tst(test, **self.args(**kwargs))
+
+ def file_equals(self, from_path, to_path, **kwargs):
+ return self.tst.file_equals(from_path, to_path, **kwargs)
+
+ def __exit__(self, type, value, traceback):
+ duration = (bench_time() - self.start_time) * 1000.0
+ scope = self.tst.pop()
+ n_passed = scope.n_total - scope.n_failed
+ if scope.n_failed == 0:
+ self.tst.log_good('-' * 10, '%d tests from %s (%d ms total)',
+ scope.n_total, self.label(), duration)
+ else:
+ self.tst.log_bad('-' * 10, '%d/%d tests from %s (%d ms total)',
+ n_passed, scope.n_total, self.label(), duration)
+
+def run_ldconfig(ctx):
+ should_run = (ctx.cmd == 'install' and
+ not ctx.env['RAN_LDCONFIG'] and
+ ctx.env['LIBDIR'] and
+ 'DESTDIR' not in os.environ and
+ not Options.options.destdir)
+
+ if should_run:
+ try:
+ Logs.info("Waf: Running `/sbin/ldconfig %s'" % ctx.env['LIBDIR'])
+ subprocess.call(['/sbin/ldconfig', ctx.env['LIBDIR']])
+ ctx.env['RAN_LDCONFIG'] = True
+ except Exception:
+ pass
+
+def get_rdf_news(name,
+ in_files,
+ top_entries=None,
+ extra_entries=None,
+ dev_dist=None):
+ import rdflib
+ from time import strptime
+
+ doap = rdflib.Namespace('http://usefulinc.com/ns/doap#')
+ dcs = rdflib.Namespace('http://ontologi.es/doap-changeset#')
+ rdfs = rdflib.Namespace('http://www.w3.org/2000/01/rdf-schema#')
+ foaf = rdflib.Namespace('http://xmlns.com/foaf/0.1/')
+ rdf = rdflib.Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#')
+ m = rdflib.ConjunctiveGraph()
+
+ try:
+ for i in in_files:
+ m.parse(i, format='n3')
+ except Exception:
+ Logs.warn('Error parsing data, unable to generate NEWS')
+ return
+
+ proj = m.value(None, rdf.type, doap.Project)
+ for f in m.triples([proj, rdfs.seeAlso, None]):
+ if f[2].endswith('.ttl'):
+ m.parse(f[2], format='n3')
+
+ entries = {}
+ for r in m.triples([proj, doap.release, None]):
+ release = r[2]
+ revision = m.value(release, doap.revision, None)
+ date = m.value(release, doap.created, None)
+ blamee = m.value(release, dcs.blame, None)
+ changeset = m.value(release, dcs.changeset, None)
+ dist = m.value(release, doap['file-release'], None)
+
+ if not dist:
+ Logs.warn('No file release for %s %s' % (proj, revision))
+ dist = dev_dist
+
+ if revision and date and blamee and changeset:
+ entry = {}
+ entry['name'] = str(name)
+ entry['revision'] = str(revision)
+ entry['date'] = strptime(str(date), '%Y-%m-%d')
+ entry['status'] = 'stable' if dist != dev_dist else 'unstable'
+ entry['dist'] = str(dist)
+ entry['items'] = []
+
+ for i in m.triples([changeset, dcs.item, None]):
+ item = str(m.value(i[2], rdfs.label, None))
+ entry['items'] += [item]
+ if dist and top_entries is not None:
+ if not str(dist) in top_entries:
+ top_entries[str(dist)] = {'items': []}
+ top_entries[str(dist)]['items'] += [
+ '%s: %s' % (name, item)]
+
+ if extra_entries and dist:
+ for i in extra_entries[str(dist)]:
+ entry['items'] += extra_entries[str(dist)]['items']
+
+ entry['blamee_name'] = str(m.value(blamee, foaf.name, None))
+ entry['blamee_mbox'] = str(m.value(blamee, foaf.mbox, None))
+
+ entries[(str(date), str(revision))] = entry
+ else:
+ Logs.warn('Ignored incomplete %s release description' % name)
+
+ return entries
+
+def write_news(entries, out_file):
+ import textwrap
+ from time import strftime
+
+ if len(entries) == 0:
+ return
+
+ news = open(out_file, 'w')
+ for e in sorted(entries.keys(), reverse=True):
+ entry = entries[e]
+ news.write('%s (%s) %s;\n' % (entry['name'], entry['revision'], entry['status']))
+ for item in entry['items']:
+ wrapped = textwrap.wrap(item, width=79)
+ news.write('\n * ' + '\n '.join(wrapped))
+
+ news.write('\n\n --')
+ news.write(' %s <%s>' % (entry['blamee_name'],
+ entry['blamee_mbox'].replace('mailto:', '')))
+
+ news.write(' %s\n\n' % (
+ strftime('%a, %d %b %Y %H:%M:%S +0000', entry['date'])))
+
+ news.close()
+
+def write_posts(entries, meta, out_dir, status='stable'):
+ "write news posts in Pelican Markdown format"
+ from time import strftime
+ try:
+ os.mkdir(out_dir)
+ except Exception:
+ pass
+
+ for i in entries:
+ entry = entries[i]
+ revision = i[1]
+ if entry['status'] != status:
+ continue
+
+ date_str = strftime('%Y-%m-%d', entry['date'])
+ datetime_str = strftime('%Y-%m-%d %H:%M', entry['date'])
+
+ path = os.path.join(out_dir, '%s-%s-%s.md' % (
+ date_str, entry['name'], revision.replace('.', '-')))
+ post = open(path, 'w')
+ title = entry['title'] if 'title' in entry else entry['name']
+ post.write('Title: %s %s\n' % (title, revision))
+ post.write('Date: %s\n' % datetime_str)
+ post.write('Slug: %s-%s\n' % (entry['name'], revision.replace('.', '-')))
+ for k in meta:
+ post.write('%s: %s\n' % (k, meta[k]))
+ post.write('\n')
+
+ url = entry['dist']
+ if entry['status'] == status:
+ post.write('[%s %s](%s) has been released.' % (
+ (entry['name'], revision, url)))
+
+ if 'description' in entry:
+ post.write(' ' + entry['description'])
+
+ post.write('\n')
+ if (len(entry['items']) > 0 and
+ not (len(entry['items']) == 1 and
+ entry['items'][0] == 'Initial release')):
+ post.write('\nChanges:\n\n')
+ for i in entry['items']:
+ post.write(' * %s\n' % i)
+
+ post.close()
+
+def get_blurb(in_file):
+ "Get the first paragram of a Markdown formatted file, skipping the title"
+ f = open(in_file, 'r')
+ f.readline() # Title
+ f.readline() # Title underline
+ f.readline() # Blank
+ out = ''
+ line = f.readline()
+ while len(line) > 0 and line != '\n':
+ out += line.replace('\n', ' ')
+ line = f.readline()
+ return out.strip()
+
+def get_news(in_file, entry_props={}):
+ """Get NEWS entries in the format expected by write_posts().
+
+ Properties that should be set on every entry can be passed in
+ `entry_props`. If `entry_props` has a 'dist_pattern' value, it is used to
+ set the 'dist' entry of entries by substituting the version number.
+ """
+
+ import re
+ import rfc822
+
+ f = open(in_file, 'r')
+ entries = {}
+ while True:
+ # Read header line
+ head = f.readline()
+ matches = re.compile(r'([^ ]*) \((.*)\) ([a-zA-z]*);').match(head)
+ if matches is None:
+ break
+
+ entry = {}
+ entry['name'] = matches.group(1)
+ entry['revision'] = matches.group(2)
+ entry['status'] = matches.group(3)
+ entry['items'] = []
+ if 'dist_pattern' in entry_props:
+ entry['dist'] = entry_props['dist_pattern'] % entry['revision']
+
+ # Read blank line after header
+ if f.readline() != '\n':
+ raise SyntaxError('expected blank line after NEWS header')
+
+ def add_item(item):
+ if len(item) > 0:
+ entry['items'] += [item.replace('\n', ' ').strip()]
+
+ # Read entries for this revision
+ item = ''
+ line = ''
+ while line != '\n':
+ line = f.readline()
+ if line.startswith(' * '):
+ add_item(item)
+ item = line[3:].lstrip()
+ else:
+ item += line.lstrip()
+ add_item(item)
+
+ # Read footer line
+ foot = f.readline()
+ matches = re.compile(' -- (.*) <(.*)> (.*)').match(foot)
+ entry['date'] = rfc822.parsedate(matches.group(3))
+ entry['blamee_name'] = matches.group(1)
+ entry['blamee_mbox'] = matches.group(2)
+ entry.update(entry_props)
+ entries[(entry['date'], entry['revision'])] = entry
+
+ # Skip trailing blank line before next entry
+ f.readline()
+
+ f.close()
+
+ return entries
+
+def news_to_posts(news_file, entry_props, post_meta, default_post_dir):
+ post_dir = os.getenv('POST_DIR')
+ if not post_dir:
+ post_dir = default_post_dir
+ sys.stderr.write('POST_DIR not set in environment, writing to %s\n' % post_dir)
+ else:
+ sys.stderr.write('writing posts to %s\n' % post_dir)
+
+ entries = get_news(news_file, entry_props)
+ write_posts(entries, post_meta, post_dir)
+
+def run_script(cmds):
+ for cmd in cmds:
+ subprocess.check_call(cmd, shell=True)
+
+def release(name, version, dist_name=None):
+ if dist_name is None:
+ dist_name = name.lower()
+
+ dist = '%s-%s.tar.bz2' % (dist_name or name.lower(), version)
+ try:
+ os.remove(dist)
+ os.remove(dist + '.sig')
+ except Exception:
+ pass
+
+ status = subprocess.check_output('git status --porcelain', shell=True)
+ if status:
+ Logs.error('error: git working copy is dirty\n' + status)
+ raise Exception('git working copy is dirty')
+
+ head = subprocess.check_output('git show -s --oneline', shell=True)
+ head_summary = head[8:].strip().lower()
+ expected_summary = '%s %s' % (name.lower(), version)
+ if head_summary != expected_summary:
+ raise Exception('latest commit "%s" does not match "%s"' % (
+ head_summary, expected_summary))
+
+ run_script(['./waf configure --docs',
+ './waf',
+ './waf distcheck',
+ './waf posts',
+ 'gpg -b %s' % dist,
+ 'git tag -s v%s -m "%s %s"' % (version, name, version)])