Add tools

tools/README.rst

@@ -0,0 +1,19 @@
+``tools/`` - Development helper packages
+----------------------------------------
+
+``discover.python/``
+``discover.lxml/``
+``discover.jre/``
+``discover.lo/``
+``install.jython/``
+
+   Discover multiple python versions, lxml, JRE, Libreoffice to use in the
+   developement environment. Provides zc.buildout recipes.
+
+``xsltest/``
+
+   an XSLT test runner.
+
+``oxt.tool/``
+
+   Build and test .oxt packages with the LibreOffice.

tools/constants/pyhwp_dev_constants.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+import os
+import sys
+
+
+class Recipe(object):
+
+    def __init__(self, buildout, name, options):
+        options['pathsep'] = os.pathsep
+        options['sep'] = os.sep
+        if sys.platform == 'win32':
+            options['script_py_suffix'] = '-script.py'
+        else:
+            options['script_py_suffix'] = ''
+
+    def install(self):
+        return []
+
+    def update(self):
+        pass

tools/constants/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+setup(name='pyhwp.dev.constants',
+      py_modules=['pyhwp_dev_constants'],
+      entry_points={'zc.buildout': ['default = pyhwp_dev_constants:Recipe']})

tools/discover.lo/discover_lo.py

@@ -0,0 +1,275 @@
+# -*- coding: utf-8 -*-
+
+import os
+import os.path
+import sys
+import logging
+import contextlib
+from discover_jre import executable_in_dir
+from discover_jre import expose_options
+
+
+logger = logging.getLogger(__name__)
+
+
+def wellknown_locations():
+    if sys.platform == 'win32':
+        program_files = 'c:\\program files'
+        if os.path.exists(program_files):
+            for name in os.listdir(program_files):
+                yield dict(location=os.path.join(program_files, name))
+    if sys.platform.startswith('linux'):
+        yield dict(location='/usr/lib/libreoffice',
+                   uno_python='/usr/bin/python')  # Debian/Ubuntu
+
+
+def discover_lo(in_wellknown=True, in_path=True):
+    if in_wellknown:
+        for installation in discover_in_wellknown_locations():
+            yield installation
+
+    if in_path:
+        for installation in discover_in_path():
+            yield installation
+
+
+def discover_in_wellknown_locations():
+    for installation in wellknown_locations():
+        found = contains_program(installation['location'])
+        if found:
+            if 'uno_python' not in found and 'uno_python' in installation:
+                uno_python = python_import_uno(installation['uno_python'])
+                if uno_python:
+                    found.update(resolve_uno_components(uno_python))
+            installation.update(found)
+            installation['through'] = 'WELLKNOWN_LOCATION'
+            yield installation
+
+
+def discover_in_path():
+    if 'PATH' in os.environ:
+        path = os.environ['PATH']
+        path = path.split(os.pathsep)
+        for dir in path:
+            libreoffice = contains_libreoffice(dir)
+            if libreoffice:
+                entry = dict(libreoffice=libreoffice, through='PATH')
+
+                # resolve symlinks
+                resolved = os.path.realpath(libreoffice)
+                location = os.path.dirname(os.path.dirname(resolved))
+                installation = contains_program(location)
+                if installation:
+                    entry.update(installation)
+
+                # Debian/Ubuntu case
+                if 'uno' not in entry:
+                    # try System python
+                    uno_python = python_import_uno(sys.executable)
+                    if uno_python:
+                        entry.update(resolve_uno_components(uno_python))
+
+                yield entry
+
+
+def contains_libreoffice(dir):
+    return executable_in_dir('libreoffice', dir)
+
+
+def contains_program(location):
+    program_dir = os.path.join(location, 'program')
+    if os.path.isdir(program_dir):
+        installation = dict(location=location, program=program_dir)
+        soffice = executable_in_dir('soffice', program_dir)
+        if soffice:
+            installation['soffice'] = soffice
+        unopkg = executable_in_dir('unopkg', program_dir)
+        if unopkg:
+            installation['unopkg'] = unopkg
+
+        program_python = executable_in_dir('python', program_dir)
+        if program_python:
+            uno_python = python_import_uno(program_python)
+            if uno_python:
+                installation.update(resolve_uno_components(uno_python))
+
+        basis_link = os.path.join(location, 'basis-link')
+        if os.path.islink(basis_link):
+            location = os.path.realpath(basis_link)
+
+        ure = find_ure(location)
+        if ure:
+            installation['ure'] = ure
+
+        return installation
+
+
+def find_ure(location):
+    ure_link = os.path.join(location, 'ure-link')
+    if os.path.islink(ure_link):
+        ure = os.path.realpath(ure_link)
+        if os.path.isdir(ure):
+            return ure
+
+    # win32
+    ure = os.path.join(location, 'ure')
+    if os.path.isdir(ure):
+        return ure
+
+
+def python_import_uno(python):
+    import subprocess
+    cmd = [python, '-c', 'import uno, unohelper']
+    ret = subprocess.call(cmd)
+    if ret == 0:
+        return python
+
+
+def resolve_uno_components(uno_python):
+    uno_python_core, modules = get_uno_locations(uno_python,
+                                            ['uno', 'pyuno',
+                                             'unohelper'])
+
+    yield 'uno_python', uno_python
+    yield 'uno_python_core', uno_python_core
+
+    uno_pythonpath = set(os.path.dirname(modules[name])
+                         for name in ['uno', 'unohelper'])
+    uno_pythonpath = os.pathsep.join(list(uno_pythonpath))
+    yield 'uno_pythonpath', uno_pythonpath
+
+    for name in modules:
+        yield name, modules[name]
+
+
+def get_uno_locations(python, modules):
+    statements = ['print __import__("sys").executable']
+    statements.extend('print __import__("%s").__file__' % name
+                      for name in modules)
+    statements = ';'.join(statements)
+    cmd = [python, '-c', statements]
+    lines = subprocess_check_output(cmd)
+    lines = lines.strip()
+    lines = lines.split('\n')
+    return lines[0], dict(zip(modules, lines[1:]))
+
+
+def subprocess_check_output(cmd):
+    import tempfile
+    fd, name = tempfile.mkstemp()
+    f = os.fdopen(fd, 'r+')
+    try:
+        import subprocess
+        ret = subprocess.call(cmd, stdout=f)
+        if ret != 0:
+            logger.error('%d returned: %s', ret, ' '.join(cmd))
+            raise Exception('%s exit with %d' % (cmd[0], ret))
+        f.seek(0)
+        return f.read()
+    finally:
+        f.close()
+        os.unlink(name)
+
+
+LO_VARS = ('libreoffice'
+           ' location program soffice unopkg'
+           ' ure'
+           ' uno_python uno_python_core uno_pythonpath uno pyuno unohelper').split(' ')
+
+
+def log_discovered(installations):
+    for installation in installations:
+        msg = 'discovered:'
+        for name in LO_VARS + ['through']:
+            if name in installation:
+                msg += ' ' + name + '=' + installation[name]
+        logger.info(msg)
+        yield installation
+
+
+@contextlib.contextmanager
+def original_pythonpath():
+    ''' without buildout-modified environment variables
+    '''
+    if 'BUILDOUT_ORIGINAL_PYTHONPATH' in os.environ:
+        buildout_pythonpath = os.environ['PYTHONPATH']
+        os.environ['PYTHONPATH'] = os.environ.pop('BUILDOUT_ORIGINAL_PYTHONPATH')
+        yield
+        os.environ['BUILDOUT_ORIGINAL_PYTHONPATH'] = os.environ['PYTHONPATH']
+        os.environ['PYTHONPATH'] = buildout_pythonpath
+    else:
+        yield
+
+
+class Discover(object):
+    ''' Discover a LibreOffice installation and provide its location.
+    '''
+
+    def __init__(self, buildout, name, options):
+        self.__logger = logger = logging.getLogger(name)
+        for k, v in options.items():
+            logger.info('%s: %r', k, v)
+
+        self.__recipe = options['recipe']
+        self.__generate_stub = None
+
+        # special marker
+        not_found = options.get('not-found', 'not-found')
+
+        # expose platform-specific path seperator for convinience
+        options['pathsep'] = os.pathsep
+
+        if 'location' in options:
+            # if location is explicitly specified, it must contains java
+            # executable.
+            with original_pythonpath():
+                discovered = contains_program(options['location'])
+            if discovered:
+                # LO found, no further operation required.
+                expose_options(options, LO_VARS, discovered,
+                               not_found=not_found, logger=logger)
+                return
+            from zc.buildout import UserError
+            raise UserError('LO not found at %s' % options['location'])
+
+        in_wellknown = options.get('search-in-wellknown-places',
+                                   'true').lower().strip()
+        in_wellknown = in_wellknown in ('true', 'yes', '1')
+        in_path = options.get('search-in-path', 'true').lower().strip()
+        in_path = in_path in ('true', 'yes', '1')
+
+        # location is not specified: try to discover a LO installation
+        with original_pythonpath():
+            discovered = discover_lo(in_wellknown, in_path)
+            discovered = log_discovered(discovered)
+            discovered = list(discovered)
+
+        if discovered:
+            discovered = discovered[0]
+            logger.info('following LO installation will be used:')
+            expose_options(options, LO_VARS, discovered, not_found=not_found,
+                           logger=logger)
+            return
+
+        expose_options(options, LO_VARS, dict(), not_found=not_found,
+                       logger=logger)
+        return
+
+        # no LO found: stub generation
+        parts_dir = buildout['buildout']['parts-directory']
+        self.__generate_stub = os.path.join(parts_dir, name)
+        options['location'] = self.__generate_stub
+        logger.info('LO not found: a dummy LO will be generated')
+        logger.info('location = %s (updating)', self.__generate_stub)
+
+    def install(self):
+        location = self.__generate_stub
+        if location is None:
+            return
+
+        if not os.path.exists(location):
+            os.makedirs(location)
+        yield location
+        self.__logger.info('A dummy LO has been generated: %s', location)
+
+    update = install

tools/discover.lo/setup.py

@@ -0,0 +1,5 @@
+from distutils.core import setup
+setup(name='discover.lo',
+      py_modules=['discover_lo'],
+      entry_points={'zc.buildout': ['default = discover_lo:Discover']},
+      install_requires=['discover.jre'])

tools/discover.lxml/discover_lxml.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from __future__ import with_statement
+import logging
+import os
+import os.path
+import sys
+from discover_python import expose_options
+from discover_python import log_discovered
+
+
+logger = logging.getLogger(__name__)
+
+
+EXPOSE_NAMES = ('location', 'version')
+
+
+FIND_SOURCE = '''
+import os
+import os.path
+import sys
+try:
+    from pkg_resources import get_distribution
+except ImportError:
+    sys.stderr.write('pkg_resources is not found' + os.linesep)
+    try:
+        import lxml
+    except ImportError:
+        sys.stderr.write('lxml is not found' + os.linesep)
+        raise SystemExit(1)
+    else:
+        print(os.path.dirname(lxml.__path__[0]))
+        print('')
+        raise SystemExit(0)
+
+try:
+    dist = get_distribution('lxml')
+except Exception:
+    e = sys.exc_info()[1]
+    sys.stderr.write(repr(e))
+    sys.stderr.write(os.linesep)
+    raise SystemExit(1)
+else:
+    print(dist.location)
+    print(dist.version)
+'''
+
+
+def discover_lxml(executable):
+    import tempfile
+    fd, path = tempfile.mkstemp()
+    try:
+        with os.fdopen(fd, 'w') as f:
+            f.write(FIND_SOURCE)
+
+        from subprocess import Popen
+        from subprocess import PIPE
+        args = [executable, path]
+        env = dict(os.environ)
+        for k in ('PYTHONPATH', 'PYTHONHOME'):
+            if k in env:
+                del env[k]
+        try:
+            p = Popen(args, stdout=PIPE, env=env)
+        except Exception:
+            e = sys.exc_info()[1]
+            logger.exception(e)
+            return
+        else:
+            try:
+                lines = list(p.stdout)
+            finally:
+                p.wait()
+    finally:
+        os.unlink(path)
+
+    if p.returncode == 0:
+        location = lines[0].strip()
+        version = lines[1].strip()
+        yield dict(location=location,
+                   version=version)
+
+
+class DiscoverRecipe(object):
+    ''' Discover lxml and provide its location.
+    '''
+
+    def __init__(self, buildout, name, options):
+        self.__logger = logger = logging.getLogger(name)
+        for k, v in options.items():
+            logger.info('%s: %r', k, v)
+
+        self.__recipe = options['recipe']
+
+        not_found = options.get('not-found', 'not-found')
+        executable = options.get('python', 'python').strip()
+        #version = options.get('version', '').strip()
+
+        founds = discover_lxml(executable=executable)
+        founds = log_discovered('matching', founds, EXPOSE_NAMES,
+                                log=logger.info)
+        founds = list(founds)
+
+        # location is not specified: try to discover a Python installation
+        if founds:
+            found = founds[0]
+            logger.info('the first-found one will be used:')
+            expose_options(options, EXPOSE_NAMES, found,
+                           not_found=not_found, logger=logger)
+            return
+
+        # ensure executable publishes not-found marker
+        expose_options(options, ['location'], dict(), not_found=not_found,
+                       logger=logger)
+        logger.warning('lxml not found')
+        return
+
+    def install(self):
+        return []
+
+    update = install

tools/discover.lxml/setup.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+import os
+import os.path
+from distutils.core import setup
+
+
+def main():
+    cwd = os.getcwd()
+    setupdir = os.path.dirname(os.path.abspath(__file__))
+    os.chdir(setupdir)
+    try:
+        setup(name='discover.lxml',
+              py_modules=['discover_lxml'],
+              install_requires=['discover.python'],
+              entry_points={'zc.buildout':
+                            ['default = discover_lxml:DiscoverRecipe']})
+    finally:
+        os.chdir(cwd)
+
+
+if __name__ == '__main__':
+    main()

tools/discover.python/discover_python.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+
+import logging
+import os
+import os.path
+import sys
+import re
+
+
+logger = logging.getLogger(__name__)
+
+
+EXPOSE_NAMES = ('executable', 'version', 'prefix', 'exec_prefix', 'through')
+
+
+def wellknown_locations():
+    if sys.platform == 'win32':
+        base = 'c:\\'
+        for name in os.listdir(base):
+            name = name.lower()
+            if name.startswith('python'):
+                shortversion = name[len('python'):]
+                m = re.match('[23][0-9]', shortversion)
+                if m:
+                    yield base + name
+    elif 'PYTHONZ_ROOT' in os.environ:
+        pythonz_root = os.environ['PYTHONZ_ROOT']
+        pythons = os.path.join(pythonz_root, 'pythons')
+        for item in os.listdir(pythons):
+            yield os.path.join(pythons, item)
+
+
+def discover_python(in_wellknown=True, in_path=True):
+
+    if in_wellknown:
+        for found in search_in_wellknown_locations():
+            yield found
+
+    if in_path:
+        for found in search_in_path():
+            yield found
+
+
+def search_in_wellknown_locations():
+    for location in wellknown_locations():
+        if sys.platform == 'win32':
+            founds = contains_python(location)
+        else:
+            founds = contains_python_in_bin(location)
+
+        for found in founds:
+            found['through'] = 'WELLKNOWN_LOCATION'
+            yield found
+
+
+def search_in_path():
+    if 'PATH' in os.environ:
+        path = os.environ['PATH']
+        path = path.split(os.pathsep)
+        for dir in path:
+            for found in contains_python(dir):
+                found['through'] = 'PATH'
+
+                # resolve symlinks
+                resolved = os.path.realpath(found['executable'])
+                found['executable'] = resolved
+                yield found
+
+
+def contains_python_in_bin(dir):
+    bindir = os.path.join(dir, 'bin')
+    return contains_python(bindir)
+
+
+def contains_python(dir):
+    vers = {
+        2: [3, 4, 5, 6, 7],
+        3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+    }
+    names = (('python%d.%d' % (major, minor))
+             for major in reversed(sorted(vers))
+             for minor in reversed(sorted(vers[major])))
+    names = list(names) + ['python']
+    for name in names:
+        executable = executable_in_dir(name, dir)
+        if executable:
+            found = executable_is_python(executable)
+            if found:
+                yield found
+
+
+def executable_in_dir(name, dir):
+    assert name == os.path.basename(name)
+    if sys.platform == 'win32':
+        name += '.exe'
+    path = os.path.join(dir, name)
+    if not os.path.exists(path):
+        return
+    return path
+
+
+def executable_is_python(executable):
+    from subprocess import Popen
+    from subprocess import PIPE
+    cmd = '''
+    import os, sys
+    print(sys.hexversion)
+    print(os.pathsep.join([sys.prefix, sys.exec_prefix]))
+    '''.strip().replace('\n', ';')
+    args = [executable, '-c', cmd]
+    env = dict(os.environ)
+    for k in ('PYTHONPATH', 'PYTHONHOME'):
+        if k in env:
+            del env[k]
+    try:
+        p = Popen(args, stdout=PIPE, env=env)
+        lines = p.stdout.read().split('\n')
+        p.wait()
+        ver = int(lines[0])
+        ver_major = str(ver >> 24 & 0xff)
+        ver_minor = str(ver >> 16 & 0xff)
+        ver_patch = str(ver >> 8  & 0xff)
+        ver = ver_major, ver_minor, ver_patch
+        version = '.'.join(ver)
+        prefix, exec_prefix = lines[1].split(os.pathsep)
+        return dict(executable=executable, version=version,
+                    prefix=prefix, exec_prefix=exec_prefix)
+    except Exception, e:
+        logger.error('popen failed: %s', args)
+        logger.exception(e)
+
+
+def log_discovered(qualify, found, names, log=logger.info):
+    for item in found:
+        msg = qualify + ':'
+        for name in names:
+            if name in item:
+                msg += ' %s=%s' % (name, item[name])
+        log(msg)
+        yield item
+
+
+def expose_options(options, names, found, not_found, logger=logger):
+    for name in names:
+        if name in found:
+            value = found[name]
+            if name in options:
+                if value != options[name]:
+                    logger.info('(updating) %s = %s', name, value)
+                    options[name] = value
+                else:
+                    logger.info('(preserving) %s = %s', name, value)
+            else:
+                logger.info('(exposing) %s = %s', name, value)
+                options[name] = value
+        else:
+            if name not in options:
+                options[name] = value = not_found
+                logger.info('(exposing) %s = %s', name, value)
+
+
+class Discover(object):
+    ''' Discover Python and provide its location.
+    '''
+
+    def __init__(self, buildout, name, options):
+        from zc.buildout import UserError
+        self.__logger = logger = logging.getLogger(name)
+        for k, v in options.items():
+            logger.info('%s: %r', k, v)
+
+        self.__recipe = options['recipe']
+
+        not_found = options.get('not-found', 'not-found')
+        version = options.get('version', '').strip()
+
+        if 'location' in options:
+            # if location is explicitly specified, it must contains java
+            # executable.
+            for found in contains_python_in_bin(options['location']):
+                if not version or found['version'].startswith(version):
+                    # Python found, no further discovery required.
+                    options['executable'] = found['executable']
+                    return
+            raise UserError('Python not found at %s' % options['location'])
+
+        in_wellknown = options.get('search-in-wellknown-places',
+                                   'true').lower().strip()
+        in_wellknown = in_wellknown in ('true', 'yes', '1') 
+        in_path = options.get('search-in-path', 'true').lower().strip()
+        in_path = in_path in ('true', 'yes', '1')
+
+        founds = discover_python(in_wellknown=in_wellknown,
+                                 in_path=in_path)
+        founds = log_discovered('candidates', founds, EXPOSE_NAMES,
+                                log=logger.debug)
+        if version:
+            # filter with version
+            founds = (found for found in founds
+                      if found['version'].startswith(version))
+        founds = log_discovered('matching', founds, EXPOSE_NAMES,
+                                log=logger.info)
+        founds = list(founds)
+
+        # location is not specified: try to discover a Python installation
+        if founds:
+            found = founds[0]
+            logger.info('the first-matching one will be used:')
+            expose_options(options, EXPOSE_NAMES, found,
+                           not_found=not_found, logger=logger)
+            return
+
+        # ensure executable publishes not-found marker
+        expose_options(options, ['executable'], dict(), not_found=not_found,
+                       logger=logger)
+        logger.warning('Python not found')
+        return
+
+    def install(self):
+        return []
+
+    update = install

tools/discover.python/setup.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+import os
+import os.path
+from distutils.core import setup
+
+def main():
+    cwd = os.getcwd()
+    setupdir = os.path.dirname(os.path.abspath(__file__))
+    os.chdir(setupdir)
+    try:
+        setup(name='discover.python',
+              py_modules=['discover_python'],
+              entry_points={'zc.buildout': ['default = discover_python:Discover']})
+    finally:
+        os.chdir(cwd)
+
+
+if __name__ == '__main__':
+    main()

tools/download/pyhwp_download.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+import sys
+import urlparse
+import os.path
+import logging
+from binascii import a2b_hex
+from binascii import b2a_hex
+from hashlib import md5
+
+import requests
+
+
+logger = logging.getLogger(__name__)
+
+
+def main():
+    logging.basicConfig()
+    logger.setLevel(logging.DEBUG)
+
+    url = sys.argv[1]
+    dst = sys.argv[2]
+    md5_given = a2b_hex(sys.argv[3])
+    result = urlparse.urlparse(url)
+
+    filename = os.path.basename(result.path)
+
+    if not os.path.exists(dst):
+        destination_path = dst
+        logger.debug('%s not exists: destination=%s', dst, destination_path)
+    else:
+        if os.path.isdir(dst):
+            destination_path = os.path.join(dst, filename)
+            logger.debug('%s is a directory: destination=%s', dst,
+                         destination_path)
+        else:
+            destination_path = dst
+
+    if os.path.exists(destination_path):
+        md5_existing = md5_file(destination_path)
+        if md5_given == md5_existing:
+            logger.debug('%s exists: skipped', destination_path)
+            return
+
+    response = requests.get(url, stream=True)
+    response.raise_for_status()
+    with open(destination_path, 'wb') as f:
+        copy_stream(response.raw, f)
+
+    md5_downloaded = md5_file(destination_path)
+    if md5_given != md5_downloaded:
+        logger.error('md5 not match: %s', b2a_hex(md5_downloaded))
+        raise SystemExit(1)
+
+
+def copy_stream(src, dst):
+    while True:
+        data = src.read(16384)
+        if len(data) == 0:
+            break
+        dst.write(data)
+
+
+def md5_file(path):
+    with open(path, 'rb') as f:
+        m = md5('')
+        while True:
+            data = f.read(16384)
+            if len(data) == 0:
+                break
+            m.update(data)
+    return m.digest()

tools/download/setup.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup
+setup(name='pyhwp.develop.download',
+      py_modules=['pyhwp_download'],
+      install_requires=['requests'],
+      entry_points=dict(console_scripts=['pyhwp-download = pyhwp_download:main']))

tools/egg.path/egg_path.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+import logging
+
+
+class EggPath(object):
+    def __init__(self, buildout, name, options):
+        self.__name = name
+        self.__logger = logging.getLogger(name)
+
+        eggs = options['eggs']
+        eggs = eggs.split('\n')
+        eggs = list(egg.strip() for egg in eggs)
+        for egg in eggs:
+            self.__logger.info('egg: %s', egg)
+
+        from zc.recipe.egg.egg import Eggs
+        eggs_recipe = Eggs(buildout, name, options)
+        req, ws = eggs_recipe.working_set()
+        for dist in ws:
+            self.__logger.debug('dist: %s %s at %s', dist, dist.key, dist.location)
+        dist_locations = dict((dist.key, dist.location) for dist in ws)
+        egg_path = list(dist_locations[egg] for egg in eggs)
+        for p in egg_path:
+            self.__logger.info('egg-path: %s', p)
+        options['egg-path'] = ' '.join(egg_path)
+
+    def install(self):
+        return []
+
+    update = install

tools/egg.path/setup.py

@@ -0,0 +1,9 @@
+from setuptools import setup
+setup(name='egg.path',
+      install_requires=['zc.recipe.egg'],
+      py_modules=['egg_path'],
+      entry_points = {
+          'zc.buildout': [
+              'default = egg_path:EggPath'
+          ]
+      })

tools/gpl/gpl/Pysec.py

@@ -0,0 +1,432 @@
+# -*- coding: utf-8 -*-
+# originally authored by Peter Thatcher, Public Domain
+# See http://www.valuedlessons.com/2008/02/pysec-monadic-combinatoric-parsing-in.html
+
+def Record(*props):
+    class cls(RecordBase):
+        pass
+
+    cls.setProps(props)
+
+    return cls
+
+
+class RecordBase(tuple):
+    PROPS = ()
+
+    def __new__(cls, *values):
+        if cls.prepare != RecordBase.prepare:
+            values = cls.prepare(*values)
+        return cls.fromValues(values)
+
+    @classmethod
+    def fromValues(cls, values):
+        return tuple.__new__(cls, values)
+
+    def __repr__(self):
+        return self.__class__.__name__ + tuple.__repr__(self)
+
+    ## overridable
+    @classmethod
+    def prepare(cls, *args):
+        return args
+
+    ## setting up getters and setters
+    @classmethod
+    def setProps(cls, props):
+        for index, prop in enumerate(props):
+            cls.setProp(index, prop)
+        cls.PROPS = props
+
+    @classmethod
+    def setProp(cls, index, prop):
+        getter_name = prop
+        setter_name = "set" + prop[0].upper() + prop[1:]
+
+        setattr(cls, getter_name, cls.makeGetter(index, prop))
+        setattr(cls, setter_name, cls.makeSetter(index, prop))
+
+    @classmethod
+    def makeGetter(cls, index, prop):
+        return property(fget = lambda self : self[index])
+
+    @classmethod
+    def makeSetter(cls, index, prop):
+        def setter(self, value):
+            values = (value if current_index == index
+                            else current_value
+                      for current_index, current_value
+                      in enumerate(self))
+            return self.fromValues(values)
+        return setter
+
+
+class ByteStream(Record("bytes", "index")):
+    @classmethod
+    def prepare(cls, bytes, index = 0):
+        return (bytes, index)
+
+    def get(self, count):
+        start = self.index
+        end   = start + count
+        bytes = self.bytes[start : end]
+        return bytes, (self.setIndex(end) if bytes else self)
+
+
+def make_decorator(func, *dec_args):
+    def decorator(undecorated):
+        def decorated(*args, **kargs):
+            return func(undecorated, args, kargs, *dec_args) 
+        
+        decorated.__name__ = undecorated.__name__
+        return decorated
+    
+    decorator.__name__ = func.__name__
+    return decorator
+
+
+decorator = make_decorator
+
+
+class Monad:
+    ## Must be overridden
+    def bind(self, func):
+        raise NotImplementedError
+
+    @classmethod
+    def unit(cls, val):
+        raise NotImplementedError
+
+    @classmethod
+    def lift(cls, func):
+        return (lambda val : cls.unit(func(val)))
+
+    ## useful defaults that should probably NOT be overridden
+    def __rshift__(self, bindee):
+        return self.bind(bindee)
+
+    def __and__(self, monad):
+        return self.shove(monad)
+        
+    ## could be overridden if useful or if more efficient
+    def shove(self, monad):
+        return self.bind(lambda _ : monad)
+
+
+class StateChanger(Record("changer", "bindees"), Monad):
+    @classmethod
+    def prepare(cls, changer, bindees = ()):
+        return (changer, bindees)
+
+    # binding can be slow since it happens at bind time rather than at run time
+    def bind(self, bindee):
+        return self.setBindees(self.bindees + (bindee,))
+
+    def __call__(self, state):
+        return self.run(state)
+
+    def run(self, state0):
+        value, state = self.changer(state0) if callable(self.changer) else self.changer
+        state        = state0 if state is None else state
+
+        for bindee in self.bindees:
+            value, state = bindee(value).run(state)
+        return (value, state)
+
+    @classmethod
+    def unit(cls, value):
+        return cls((value, None))
+
+
+######## Parser Monad ###########
+
+
+class ParserState(Record("stream", "position")):
+    @classmethod
+    def prepare(cls, stream, position = 0):
+        return (stream, position)
+
+    def read(self, count):
+        collection, stream = self.stream.get(count)
+        return collection, self.fromValues((stream, self.position + count))
+
+
+class Parser(StateChanger):
+    def parseString(self, bytes):
+        return self.parseStream(ByteStream(bytes))
+        
+    def parseStream(self, stream):
+        state = ParserState(stream)
+        value, state = self.run(state)
+        return value
+
+
+class ParseFailed(Exception):
+    def __init__(self, message, state):
+        self.message = message
+        self.state   = state
+        Exception.__init__(self, message)
+
+
+@decorator
+def parser(func, func_args, func_kargs):
+    def changer(state):
+        return func(state, *func_args, **func_kargs)
+    changer.__name__ = func.__name__
+    return Parser(changer)
+
+
+##### combinatoric functions #########
+
+
+@parser
+def tokens(state0, count, process):
+    tokens, state1 = state0.read(count)
+
+    passed, value = process(tokens)
+    if passed:
+        return (value, state1)
+    else:
+        raise ParseFailed(value, state0)
+    
+
+def read(count):
+    return tokens(count, lambda values : (True, values))
+
+
+@parser
+def skip(state0, parser):
+    value, state1 = parser(state0)
+    return (None, state1)
+
+
+@parser
+def option(state, default_value, parser):
+    try:
+        return parser(state)
+    except ParseFailed, failure:
+        if failure.state == state:
+            return (default_value, state)
+        else:
+            raise
+        
+
+@parser
+def choice(state, parsers):
+    for parser in parsers:
+        try:
+            return parser(state)
+        except ParseFailed, failure:
+            if failure.state != state:
+                raise failure
+    raise ParseFailed("no choices were found", state)
+
+
+@parser
+def match(state0, expected):
+    actual, state1 = read(len(expected))(state0)
+    if actual == expected:
+        return actual, state1
+    else:
+        raise ParseFailed("expected %r, actual %r" % (expected, actual), state0)
+
+
+def between(before, inner, after):
+    return before & inner >> (lambda value : after & Parser.unit(value))
+
+
+def quoted(before, inner, after):
+    return between(match(before), inner, match(after))
+
+
+def quoted_collection(start, space, inner, joiner, end):
+    return quoted(start, space & sep_end_by(inner, joiner), end)
+
+
+@parser
+def many(state, parser, min_count = 0):
+    values = []
+
+    try:
+        while True:
+            value, state = parser(state)
+            values.append(value)
+    except ParseFailed:
+        if len(values) < min_count:
+            raise
+
+    return values, state
+    
+
+@parser
+def group(state, parsers):
+    values = []
+
+    for parser in parsers:
+        value, state = parser(state)
+        values.append(value)
+
+    return values, state
+
+
+def pair(parser1, parser2):
+    # return group((parser1, parser2))
+    return parser1 >> (lambda value1 : parser2 >> (lambda value2 : Parser.unit((value1, value2))))
+
+
+@parser
+def skip_many(state, parser):
+    try:
+        while True:
+            value, state = parser(state)
+    except ParseFailed:
+        return (None, state)
+
+
+def skip_before(before, parser):
+    return skip(before) & parser
+
+
+@parser
+def skip_after(state0, parser, after):
+    value, state1 = parser(state0)
+    _,     state2 = after(state1)
+    return value, state2
+
+
+@parser
+def option_many(state0, first, repeated, min_count = 0):
+    try:
+        first_value, state1 = first(state0)
+    except ParseFailed:
+        if min_count > 0:
+            raise
+        else:
+            return [], state0
+    else:
+        values, state2 = many(repeated, min_count-1)(state1)
+        values.insert(0, first_value)
+        return values, state2
+
+
+# parser separated and ended by sep
+def end_by(parser, sep_parser, min_count = 0):
+    return many(skip_after(parser, sep_parser), min_count)
+
+
+# parser separated by sep
+def sep_by(parser, sep_parser, min_count = 0):
+    return option_many(parser, skip_before(sep_parser, parser), min_count)
+    
+
+# parser separated and optionally ended by sep
+def sep_end_by(parser, sep_parser, min_count = 0):
+    return skip_after(sep_by(parser, sep_parser, min_count), option(None, sep_parser))
+
+
+##### char-specific parsing ###########
+
+
+def satisfy(name, passes):
+    return tokens(1, lambda char : (True, char) if passes(char) else (False, "not " + name))
+
+
+def one_of(chars):
+    char_set = frozenset(chars)
+    return satisfy("one of %r" % chars, lambda char : char in char_set)
+
+
+def none_of(chars):
+    char_set = frozenset(chars)
+    return satisfy("not one of %r" % chars, lambda char : char and char not in char_set)
+
+
+def maybe_match_parser(parser):
+    return match(parser) if isinstance(parser, str) else parser
+
+
+def maybe_match_parsers(parsers):
+    return tuple(maybe_match_parser(parser) for parser in parsers)
+
+
+def many_chars(parser, min_count = 0):
+    return join_chars(many(parser, min_count))
+
+
+def option_chars(parsers):
+    return option("", group_chars(parsers))
+
+
+def group_chars(parsers):
+    return join_chars(group(maybe_match_parsers(parsers)))
+    #return join_chars(group(parsers))
+
+
+def join_chars(parser):
+    return parser >> Parser.lift("".join)
+
+
+def while_one_of(chars, min_count = 0):
+    return many_chars(one_of(chars), min_count)
+
+
+def until_one_of(chars, min_count = 0):
+    return many_chars(none_of(chars), min_count)
+
+
+def char_range(begin, end):
+    return "".join(chr(num) for num in xrange(ord(begin), ord(end)))
+
+
+def quoted_chars(start, end):
+    assert len(end) == 1, "end string must be exactly 1 character"
+    return quoted(start, many_chars(none_of(end)), end)
+
+
+digit  = one_of(char_range("0", "9"))
+digits = many_chars(digit, min_count = 1)
+space  = one_of(" \v\f\t\r\n")
+spaces = skip_many(space)
+
+
+############# simplified JSON ########################
+
+#from Pysec import Parser, choice, quoted_chars, group_chars, option_chars, digits, between, pair, spaces, match, quoted_collection, sep_end_by
+
+#HACK: json_choices is used to get around mutual recursion 
+#a json is value is one of text, number, mapping, and collection, which we define later 
+json_choices = []
+json         = choice(json_choices)
+
+#text is any characters between quotes
+text         = quoted_chars("'", "'")
+
+#sort of like the regular expression -?[0-9]+(\.[0-9]+)?
+#in case you're unfamiliar with monads, "parser >> Parser.lift(func)" means "pass the parsed value into func but give me a new Parser back"
+number       = group_chars([option_chars(["-"]), digits, option_chars([".", digits])]) >> Parser.lift(float)
+
+#quoted_collection(start, space, inner, joiner, end) means "a list of inner separated by joiner surrounded by start and end"
+#also, we have to put a lot of spaces in there since JSON allows lot of optional whitespace
+joiner       = between(spaces, match(","), spaces)
+mapping_pair = pair(text, spaces & match(":") & spaces & json)
+collection   = quoted_collection("[", spaces, json,         joiner, "]") >> Parser.lift(list)
+mapping      = quoted_collection("{", spaces, mapping_pair, joiner, "}") >> Parser.lift(dict)
+
+#HACK: finish the work around mutual recursion
+json_choices.extend([text, number, mapping, collection])
+
+
+############# simplified CSV ########################
+
+def line(cell):
+    return sep_end_by(cell, match(","))
+
+def csv(cell):
+    return sep_end_by(line(cell), match("\n"))
+
+############# testing ####################
+
+if __name__ == '__main__':
+    print json.parseString("{'a' : -1.0, 'b' : 2.0, 'z' : {'c' : [1.0, [2.0, [3.0]]]}}")
+    print csv(number).parseString("1,2,3\n4,5,6")
+    print csv(json).parseString("{'a' : 'A'},[1, 2, 3],'zzz'\n-1.0,2.0,-3.0")

tools/gpl/gpl/__init__.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+'''
+Usage:
+    gpl [options] <files>...
+    gpl -h | --help
+    gpl --version
+
+Options:
+    -h --help               Show this screen
+    --version               Show version
+    --add-year=<year>       Add release year
+    --set-author=<author>   Set author
+'''
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+def main():
+    from docopt import docopt
+    args = docopt(__doc__, version='0.0.0')
+
+    logger.setLevel(logging.INFO)
+    logger.addHandler(logging.StreamHandler())
+
+    license_modifiers = []
+
+    add_year = args['--add-year']
+    if add_year:
+        year = add_year.strip()
+        year = int(year)
+        def add_year(license):
+            years = license.copyright.years
+            years.add(year)
+            copyright = license.copyright.setYears(years)
+            return license.setCopyright(copyright)
+        license_modifiers.append(add_year)
+
+    set_author = args['--set-author']
+    if set_author:
+        author = set_author.strip()
+        from parsers import AUTHOR
+        author = AUTHOR.parseString(author)
+        def set_author(license):
+            copyright = license.copyright
+            copyright = copyright.setAuthors([author])
+            return license.setCopyright(copyright)
+        license_modifiers.append(set_author)
+
+
+    filenames = args['<files>']
+
+    for path in filenames:
+        logger.info('filename: %s', path)
+        try:
+            process_file(path, license_modifiers)
+        except Exception, e:
+            logger.exception(e)
+
+
+def process_file(path, license_modifiers):
+    import os
+    import tempfile
+    import shutil
+    from parsers import parse_file
+
+    license = parse_file(path)
+    for modifier in license_modifiers:
+        license = modifier(license)
+
+    fd, tmp_path = tempfile.mkstemp()
+    try:
+        with os.fdopen(fd, 'w') as f:
+            f.write(str(license))
+    except:
+        os.unlink(tmp_path)
+        raise
+    else:
+        shutil.move(tmp_path, path)
+
+
+def stringify_years(years):
+    from parsers import Span
+    return ','.join(str(span) for span in Span.from_set(years))

tools/gpl/gpl/parsers.py

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+
+
+from gpl.Pysec import Record
+from gpl.Pysec import one_of
+from gpl.Pysec import none_of
+from gpl.Pysec import between
+from gpl.Pysec import digits
+from gpl.Pysec import match
+from gpl.Pysec import sep_by
+from gpl.Pysec import pair
+from gpl.Pysec import Parser
+from gpl.Pysec import until_one_of
+from gpl.Pysec import option
+from gpl.Pysec import space
+from gpl.Pysec import spaces
+from gpl.Pysec import quoted
+#from gpl.Pysec import quoted_chars
+from gpl.Pysec import char_range
+from gpl.Pysec import many_chars
+from gpl.Pysec import group_chars
+from gpl.Pysec import skip_before
+from gpl.Pysec import skip_after
+from gpl.Pysec import skip_many
+from gpl.Pysec import many
+from gpl.Pysec import group
+from gpl.Pysec import parser
+from gpl.Pysec import ParseFailed
+
+lift = Parser.lift
+
+inline_space  = one_of(" \v\f\t\r")
+inline_spaces = skip_many(inline_space)
+meaningful_spaces = many_chars(space)
+
+def quoted_chars_inline(start, end):
+    return quoted(start, many_chars(none_of(end+'\n')), end)
+
+
+def until_one_of_inline(chars):
+    return until_one_of(chars+'\n')
+
+
+def skip_tailspace_of_line(parser):
+    return skip_after(parser,
+                      inline_spaces & option(None, match('\n')))
+
+
+@parser
+def until_not_but(state0, should_not, but):
+    state = state0
+    values = []
+    while True:
+        try:
+            should_not_value, next_state = should_not(state)
+            return values, state
+        except ParseFailed:
+            value, state = but(state)
+            values.append(value)
+
+
+def py_comment(parser):
+    return inline_spaces & match('#') & parser
+
+
+class Project(Record('name', 'description')):
+
+    @classmethod
+    def prepare(cls, name, description=None):
+        name = name.strip()
+        if description is not None:
+            description = description.strip()
+        return name, description
+
+    def __str__(self):
+        return self.name + (' : ' + self.description
+                            if self.description
+                            else '')
+
+
+alphabet = char_range('a', 'z') + char_range('A', 'Z')
+PROJECT_NAME = (group_chars([one_of(alphabet),
+                             many_chars(one_of(alphabet + char_range('0', '9') + '-_'), 1)])
+                >> lift(str.strip))
+PROJECT_NAME = skip_after(PROJECT_NAME, option(None, inline_spaces))
+PROJECT_DESC = until_one_of('\n') >> lift(str.strip)
+PROJECT_LINE = pair(PROJECT_NAME,
+                    option(None, match(':') & PROJECT_DESC))
+PROJECT_LINE = PROJECT_LINE >> lift(lambda seq: Project(*seq))
+PROJECT_LINE = skip_before(inline_spaces, PROJECT_LINE)
+PROJECT_LINE = skip_tailspace_of_line(PROJECT_LINE)
+
+
+COPYRIGHT_SIGN = match('Copyright (C)')
+
+class Span(Record('start', 'end')):
+
+    @classmethod
+    def prepare(cls, start, end=None):
+        if end is None:
+            end = start
+        assert start <= end
+        return start, end
+
+    def as_set(self):
+        return set(range(self.start, self.end + 1))
+
+    @classmethod
+    def from_set(cls, valueset):
+        span = None
+        for value in sorted(valueset):
+            if span is None:
+                # at first
+                span = Span(value, value)
+            elif value == span.end + 1:
+                # continue current span
+                span = span.setEnd(value)
+            else:
+                # end current and start next span
+                yield span
+                span = Span(value, value)
+        if span is not None:
+            yield span
+
+    def __str__(self):
+        if self.start == self.end:
+            return str(self.start)
+        return '%d-%d' % self
+
+
+YEAR = digits >> lift(int)
+TAIL = option(None, match('-') & YEAR)
+YEAR_SPAN = (pair(YEAR, TAIL) >> lift(lambda pair: Span(*pair)))
+YEARS = (sep_by(YEAR_SPAN, match(','))
+         >> lift(lambda spans: reduce(set.union,
+                                      (span.as_set() for span in spans))))
+
+class Author(Record('name', 'email')):
+
+    @classmethod
+    def prepare(self, name, email=None):
+        if not name and not email:
+            raise ValueError('either of name and email should not be empty')
+        return (name.strip() if name else None,
+                email.strip() if email else None)
+
+    def __str__(self):
+        name = self.name or ''
+        email = ('<' + self.email + '>') if self.email else ''
+        if not email:
+            return name
+        if not name:
+            return email
+        return name + ' ' + email
+
+
+AUTHOR_NAME = until_one_of('<,\n') >> lift(str.strip)
+AUTHOR_EMAIL = quoted_chars_inline('<', '>')
+AUTHOR = (pair(option(None, AUTHOR_NAME), option(None, AUTHOR_EMAIL))
+          >> lift(lambda author: Author(*author)))
+joiner = between(spaces, match(","), spaces)
+AUTHORS = sep_by(AUTHOR, joiner)
+
+
+class Copyright(Record('years', 'authors')):
+    def __str__(self):
+        years = ','.join(str(span) for span in Span.from_set(self.years))
+        authors = ', '.join(str(author) for author in self.authors)
+        return 'Copyright (C) %s %s' % (years, authors)
+
+
+COPYRIGHT_LINE = (COPYRIGHT_SIGN & inline_spaces &
+                  pair(YEARS, inline_spaces & AUTHORS))
+COPYRIGHT_LINE = skip_before(inline_spaces, COPYRIGHT_LINE)
+COPYRIGHT_LINE = skip_tailspace_of_line(COPYRIGHT_LINE)
+COPYRIGHT_LINE = COPYRIGHT_LINE >> lift(lambda seq: Copyright(*seq))
+
+GENERIC_LINE = skip_after(many_chars(none_of('\n')), match('\n'))
+
+
+class License(Record('prolog', 'project', 'copyright', 'epilog')):
+
+    def __str__(self):
+        return '\n'.join(self.prolog +
+                         ['#   ' + str(self.project),
+                          '#   ' + str(self.copyright)] +
+                         self.epilog + [''])
+
+
+PROLOG = until_not_but(py_comment(PROJECT_LINE), GENERIC_LINE)
+EPILOG = many(GENERIC_LINE)
+LICENSE = (group([PROLOG,
+                  py_comment(PROJECT_LINE),
+                  py_comment(COPYRIGHT_LINE),
+                  EPILOG])
+           >> lift(lambda seq: License(*seq)))
+
+
+def parse_file(path):
+    with file(path) as f:
+        text = f.read()
+        return LICENSE.parseString(text)

tools/gpl/gpl/tests/test_gpl.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+from unittest import TestCase
+
+
+class SpanTest(TestCase):
+
+    def test_from_set(self):
+        from gpl.parsers import Span
+        self.assertEqual([Span(1)],
+                          list(Span.from_set([1])))
+        self.assertEqual([Span(1, 2)],
+                          list(Span.from_set([1, 2])))
+        self.assertEqual([Span(1, 2), Span(4)],
+                          list(Span.from_set([1, 2, 4])))
+        self.assertEqual([Span(1, 2), Span(4, 6)],
+                          list(Span.from_set([1, 2, 4, 5, 6])))
+
+    def test_str(self):
+        from gpl.parsers import Span
+        self.assertEqual('3', str(Span(3)))
+        self.assertEqual('3-4', str(Span(3, 4)))
+        self.assertEqual('3-6', str(Span(3, 6)))
+
+
+project_line = '   pyhwp : hwp file format parser in python'
+copyright_line = '    Copyright (C) 2010-2012 mete0r  '
+generic_line = '   abc   '
+LF = '\n'
+
+
+class ProjectTest(TestCase):
+
+    def test_project_name(self):
+        from gpl.parsers import PROJECT_NAME
+        self.assertEqual('pyhwp', PROJECT_NAME.parseString('pyhwp  :'))
+
+    def test_project_desc(self):
+        from gpl.parsers import PROJECT_DESC
+        self.assertEqual('hwp file format parser in python',
+                          PROJECT_DESC.parseString('   hwp file format parser in python  '))
+
+    def test_project_line_with_lf(self):
+        from gpl.parsers import Project
+        from gpl.parsers import PROJECT_LINE
+
+        # ok with LF
+        self.assertEqual(Project('pyhwp', 'hwp file format parser in python'),
+                          PROJECT_LINE.parseString(project_line + LF))
+        self.assertEqual(Project('pyhwp'),
+                          PROJECT_LINE.parseString('   pyhwp   ' + LF))
+
+    def test_project_line_without_lf(self):
+        from gpl.parsers import Project
+        from gpl.parsers import PROJECT_LINE
+
+        # ok without LF
+        self.assertEqual(Project('pyhwp', 'hwp file format parser in python'),
+                          PROJECT_LINE.parseString(project_line))
+        self.assertEqual(Project('pyhwp'),
+                          PROJECT_LINE.parseString('   pyhwp   '))
+
+    def test_project_line_parser_doesnt_consume_after_lf(self):
+        from gpl.parsers import PROJECT_LINE
+        # make sure that the parser does not consume after LF
+        from gpl.Pysec import match
+        self.assertEqual(' NEXTLINE',
+                          (PROJECT_LINE & match(' NEXTLINE')).parseString(project_line
+                                                                          + LF + ' NEXTLINE'))
+
+
+class CopyrightTest(TestCase):
+
+    def test_stringify_years(self):
+        from gpl import stringify_years
+        self.assertEqual('2011-2012',
+                          stringify_years([2011, 2012]))
+        self.assertEqual('2011-2013',
+                          stringify_years([2011, 2012, 2013]))
+        self.assertEqual('2011-2013,2015',
+                          stringify_years([2011, 2012, 2013, 2015]))
+        self.assertEqual('2009,2011-2013,2015',
+                          stringify_years([2009, 2011, 2012, 2013, 2015]))
+
+    def test_copyright(self):
+        from gpl.parsers import COPYRIGHT_SIGN
+        self.assertTrue(COPYRIGHT_SIGN.parseString('Copyright (C)'))
+
+        from gpl.parsers import Span
+        self.assertEqual('2010', str(Span(2010)))
+        self.assertEqual('2010-2012', str(Span(2010, 2012)))
+
+        from gpl.parsers import YEAR_SPAN
+        self.assertEqual(Span(2010, 2012),
+                          YEAR_SPAN.parseString('2010-2012'))
+        self.assertEqual(Span(2010, 2010),
+                          YEAR_SPAN.parseString('2010'))
+
+        from gpl.parsers import YEARS
+        self.assertEqual(set([2010]),
+                          YEARS.parseString('2010'))
+        self.assertEqual(set([2010, 2011]),
+                          YEARS.parseString('2010,2011'))
+        self.assertEqual(set([2010, 2011, 2012]),
+                          YEARS.parseString('2010-2012'))
+        self.assertEqual(set([2010, 2011, 2013, 2014, 2015, 2017]),
+                          YEARS.parseString('2010,2011,2013-2015,2017'))
+
+        from gpl.parsers import AUTHOR_NAME
+        self.assertEqual('Hello World',
+                          AUTHOR_NAME.parseString('Hello World'))
+        self.assertEqual('Hello World',
+                          AUTHOR_NAME.parseString('Hello World <'))
+
+        from gpl.parsers import AUTHOR_EMAIL
+        self.assertEqual('user@example.tld',
+                          AUTHOR_EMAIL.parseString('<user@example.tld>'))
+
+        from gpl.parsers import Author
+        from gpl.parsers import AUTHOR
+        self.assertEqual(Author('hong gil-dong', 'hongd@example.tld'),
+                          AUTHOR.parseString('hong gil-dong <hongd@example.tld>'))
+        self.assertEqual(Author('hong gil-dong'),
+                          (AUTHOR.parseString('hong gil-dong')))
+        self.assertEqual(Author(None, 'hongd@example.tld'),
+                          (AUTHOR.parseString('<hongd@example.tld>')))
+
+        from gpl.parsers import AUTHORS
+        self.assertEqual([Author('mete0r'),
+                           Author('hong gil-dong', 'hongd@ex.tld')],
+                          AUTHORS.parseString('mete0r, hong gil-dong <hongd@ex.tld>'))
+
+        from gpl.parsers import Copyright
+        from gpl.parsers import COPYRIGHT_LINE
+        # ok with LF
+        self.assertEqual(Copyright(set([2010, 2011, 2012]),
+                                    [Author('mete0r')]),
+                          (COPYRIGHT_LINE.parseString(copyright_line + LF)))
+
+        # ok without LF
+        self.assertEqual(Copyright(set([2010, 2011, 2012]),
+                                    [Author('mete0r')]),
+                          (COPYRIGHT_LINE.parseString(copyright_line)))
+
+        # make sure that the parser does not consume after the LF
+        from gpl.Pysec import match
+        self.assertEqual(' NEXTLINE',
+                          (COPYRIGHT_LINE & match(' NEXTLINE')).parseString(copyright_line + LF + ' NEXTLINE'))
+
+    def test_generic_line(self):
+        from gpl.parsers import GENERIC_LINE
+        self.assertEqual(generic_line,
+                          GENERIC_LINE.parseString(generic_line + LF))
+
+
+class LicenseTest(TestCase):
+    def test_license(self):
+        from gpl.parsers import LICENSE
+
+        text = '''#!/usr/bin/python
+# -*- coding: utf-8 -*-
+#
+# ''' + project_line + '''
+# ''' + copyright_line + '''
+#
+#    This file is part of pyhwp project.
+#
+#   license text.
+
+import unittest
+'''
+        print LICENSE.parseString(text)

tools/gpl/setup.py

@@ -0,0 +1,9 @@
+from setuptools import setup, find_packages
+setup(name='gpl',
+      packages=find_packages(),
+      install_requires=['docopt'],
+      entry_points={
+          'console_scripts': [
+              'gpl = gpl:main'
+          ]
+      })

tools/jingodf/jingodf/__init__.py

@@ -0,0 +1,176 @@
+#! -*- coding: utf-8 -*-
+
+class Jing(object):
+
+    def __init__(self, executable='jing'):
+        ''' External Jing executable
+
+        :param executable: path to jing executable. Default: jing
+        '''
+        self.executable = executable
+
+    def __call__(self, *args, **kwargs):
+        args = list(args)
+
+        import subprocess
+        if isinstance(self.executable, basestring):
+            args[0:0] = [self.executable]
+        else:
+            args[0:0] = self.executable
+
+        p = subprocess.Popen(args, stdout=subprocess.PIPE, **kwargs)
+        for line in p.stdout:
+            filename, line, column, level, msg = line.split(':', 4)
+            level = level.strip()
+            msg = msg.strip()
+            yield dict(filename=filename,
+                       line=line, column=column,
+                       level=level, msg=msg)
+        p.wait()
+        yield p.returncode
+
+    def validate(self, rngfile, xmlfile):
+        return self('-i', rngfile, xmlfile)
+
+
+class XmlLint(object):
+    def __init__(self, executable='xmllint'):
+        ''' External xmllint executable
+
+        :param executable: path to xmllint executable. Default: xmllint
+        '''
+        self.executable = executable
+
+    def __call__(self, *args, **kwargs):
+        args = list(args)
+
+        import subprocess
+        if isinstance(self.executable, basestring):
+            args[0:0] = [self.executable]
+        else:
+            args[0:0] = self.executable
+
+        p = subprocess.Popen(args, stderr=subprocess.PIPE, **kwargs)
+        import re
+        regex = re.compile('(.*)Relax-NG validity error : (.*)')
+        for line in p.stderr:
+            if line.endswith(' validates\n'):
+                continue
+            elif line.endswith(' fails to validate\n'):
+                continue
+            line = line.strip()
+            m = regex.match(line)
+            if m:
+                location = m.group(1)
+                msg = m.group(2)
+                if location:
+                    filename, line_no, element, _ = line.split(':', 3)
+                    element = element.strip()
+                level = 'error'
+                msg = msg.strip()
+                yield dict(filename=filename,
+                           line=line_no, column=element,
+                           level=level, msg=msg)
+            else:
+                print '*', line
+        p.wait()
+        yield p.returncode
+
+    def validate(self, rngfile, xmlfile):
+        return self('--noout', '--relaxng', rngfile, xmlfile)
+
+
+class ODFValidator(object):
+    def __init__(self, engine):
+        self.engine = engine
+
+    def validate_manifest_xml(self, version, xmlfile):
+        rng_files = {
+            '1.0': 'OpenDocument-manifest-schema-v1.0-os.rng',
+            '1.1': 'OpenDocument-manifest-schema-v1.1.rng',
+            '1.2': 'OpenDocument-v1.2-os-manifest-schema.rng',
+        }
+
+        import pkg_resources
+        rng_filename = rng_files[version]
+        rng_file = pkg_resources.resource_filename('jingodf',
+                                                   'schema/'+rng_filename)
+        return self.engine.validate(rng_file, xmlfile)
+
+    def validate_opendocument_xml(self, version, xmlfile):
+        rng_files = {
+            '1.0': 'OpenDocument-schema-v1.0-os.rng',
+            '1.1': 'OpenDocument-schema-v1.1.rng',
+            '1.2': 'OpenDocument-v1.2-os-schema.rng',
+        }
+        import pkg_resources
+        rng_filename = rng_files[version]
+        rng_file = pkg_resources.resource_filename('jingodf',
+                                                   'schema/'+rng_filename)
+        return self.engine.validate(rng_file, xmlfile)
+
+    def validate_odf(self, version, odffile):
+
+        import os.path
+        from zipfile import ZipFile
+        zipfile = ZipFile(odffile, 'r')
+        try:
+            import tempfile
+            tmpdir = tempfile.mkdtemp()
+            try:
+                path = 'META-INF/manifest.xml'
+                zipfile.extract(path, tmpdir)
+                results = self.validate_manifest_xml(version,
+                                                     os.path.join(tmpdir, path))
+                for result in results:
+                    if isinstance(result, dict):
+                        result['filename'] = path
+                    yield result
+
+                path = 'styles.xml'
+                zipfile.extract(path, tmpdir)
+                results = self.validate_opendocument_xml(version,
+                                                         os.path.join(tmpdir, path))
+                for result in results:
+                    if isinstance(result, dict):
+                        result['filename'] = path
+                    yield result
+
+                path = 'content.xml'
+                zipfile.extract(path, tmpdir)
+                results = self.validate_opendocument_xml(version,
+                                                         os.path.join(tmpdir, path))
+                for result in results:
+                    if isinstance(result, dict):
+                        result['filename'] = path
+                    yield result
+
+            finally:
+                import shutil
+                shutil.rmtree(tmpdir)
+        finally:
+            zipfile.close()
+
+from opster import command
+
+@command()
+def validate(odf_file,
+             odf_version=('', '1.2', 'OpenDocument specification version'),
+             engine=('', 'jing', 'Relax-NG Validator engine')):
+    ''' Validate an ODF file against the OpenDocument Relax-NG Schema. '''
+
+    engines = dict(jing=Jing, xmllint=XmlLint)
+    engine_class = engines.get(engine, Jing)
+    engine = engine_class()
+    odf_validator = ODFValidator(engine)
+    results = odf_validator.validate_odf(odf_version, odf_file)
+
+    def print_result(result):
+        if isinstance(result, dict):
+            print '%(filename)s:%(line)s:%(column)s: %(level)s: %(msg)s'%result
+
+    for result in results:
+        print_result(result)
+
+def main():
+    validate.command()

tools/jingodf/jingodf/schema/OpenDocument-manifest-schema-v1.0-os.rng

@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    OASIS OpenDocument v1.0
+    OASIS standard, 1 May 2005
+    Relax-NG Manifest Schema
+
+    $Id$
+
+    © 2002-2005 OASIS Open
+    © 1999-2005 Sun Microsystems, Inc.
+-->
+
+<grammar 
+    xmlns="http://relaxng.org/ns/structure/1.0"
+
+    datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"
+
+    xmlns:manifest="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0">
+<define name="manifest">
+    <element name="manifest:manifest">
+        <oneOrMore>
+            <ref name="file-entry"/>
+        </oneOrMore>
+    </element>
+</define>
+
+<start>
+    <choice>
+        <ref name="manifest"/>
+    </choice>
+</start>
+<define name="file-entry">
+    <element name="manifest:file-entry">
+        <ref name="file-entry-attlist"/>
+        <optional>
+            <ref name="encryption-data"/>
+        </optional>
+    </element>
+</define>
+<define name="file-entry-attlist" combine="interleave">
+    <attribute name="manifest:full-path">
+        <data type="string"/>
+    </attribute>
+</define>
+<define name="file-entry-attlist" combine="interleave">
+    <optional>
+        <attribute name="manifest:size">
+            <data type="nonNegativeInteger"/>
+        </attribute>
+    </optional>
+</define>
+<define name="file-entry-attlist" combine="interleave">
+    <attribute name="manifest:media-type">
+        <data type="string"/>
+    </attribute>
+</define>
+<define name="encryption-data">
+    <element name="manifest:encryption-data">
+        <ref name="encryption-data-attlist"/>
+        <ref name="algorithm"/>
+        <ref name="key-derivation"/>
+    </element>
+</define>
+<define name="encryption-data-attlist" combine="interleave">
+    <attribute name="manifest:checksum-type">
+        <data type="string"/>
+    </attribute>
+</define>
+<define name="encryption-data-attlist" combine="interleave">
+    <attribute name="manifest:checksum">
+        <data type="base64Binary"/>
+    </attribute>
+</define>
+<define name="algorithm">
+    <element name="manifest:algorithm">
+        <ref name="algorithm-attlist"/>
+        <empty/>
+    </element>
+</define>
+<define name="algorithm-attlist" combine="interleave">
+    <attribute name="manifest:algorithm-name">
+        <data type="string"/>
+    </attribute>
+</define>
+<define name="algorithm-attlist" combine="interleave">
+    <attribute name="manifest:initialisation-vector">
+        <data type="base64Binary"/>
+    </attribute>
+</define>
+<define name="key-derivation">
+    <element name="manifest:key-derivation">
+        <ref name="key-derivation-attlist"/>
+        <empty/>
+    </element>
+</define>
+<define name="key-derivation-attlist" combine="interleave">
+    <attribute name="manifest:key-derivation-name">
+        <data type="string"/>
+    </attribute>
+</define>
+<define name="key-derivation-attlist" combine="interleave">
+    <attribute name="manifest:salt">
+        <data type="base64Binary"/>
+    </attribute>
+</define>
+<define name="key-derivation-attlist" combine="interleave">
+    <attribute name="manifest:iteration-count">
+            <data type="nonNegativeInteger"/>
+        </attribute>
+</define>
+</grammar>

tools/jingodf/jingodf/schema/OpenDocument-manifest-schema-v1.1.rng

@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    OASIS OpenDocument v1.1
+    OASIS Standard, 1 Feb 2007
+    Relax-NG Manifest Schema
+
+    $Id$
+
+    © 2002-2007 OASIS Open
+    © 1999-2007 Sun Microsystems, Inc.
+-->
+
+<grammar 
+    xmlns="http://relaxng.org/ns/structure/1.0"
+
+    datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"
+
+    xmlns:manifest="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0">
+<define name="manifest">
+    <element name="manifest:manifest">
+        <oneOrMore>
+            <ref name="file-entry"/>
+        </oneOrMore>
+    </element>
+</define>
+
+<start>
+    <choice>
+        <ref name="manifest"/>
+    </choice>
+</start>
+<define name="file-entry">
+    <element name="manifest:file-entry">
+        <ref name="file-entry-attlist"/>
+        <optional>
+            <ref name="encryption-data"/>
+        </optional>
+    </element>
+</define>
+<define name="file-entry-attlist" combine="interleave">
+    <attribute name="manifest:full-path">
+        <data type="string"/>
+    </attribute>
+</define>
+<define name="file-entry-attlist" combine="interleave">
+    <optional>
+        <attribute name="manifest:size">
+            <data type="nonNegativeInteger"/>
+        </attribute>
+    </optional>
+</define>
+<define name="file-entry-attlist" combine="interleave">
+    <attribute name="manifest:media-type">
+        <data type="string"/>
+    </attribute>
+</define>
+<define name="encryption-data">
+    <element name="manifest:encryption-data">
+        <ref name="encryption-data-attlist"/>
+        <ref name="algorithm"/>
+        <ref name="key-derivation"/>
+    </element>
+</define>
+<define name="encryption-data-attlist" combine="interleave">
+    <attribute name="manifest:checksum-type">
+        <data type="string"/>
+    </attribute>
+</define>
+<define name="encryption-data-attlist" combine="interleave">
+    <attribute name="manifest:checksum">
+        <data type="base64Binary"/>
+    </attribute>
+</define>
+<define name="algorithm">
+    <element name="manifest:algorithm">
+        <ref name="algorithm-attlist"/>
+        <empty/>
+    </element>
+</define>
+<define name="algorithm-attlist" combine="interleave">
+    <attribute name="manifest:algorithm-name">
+        <data type="string"/>
+    </attribute>
+</define>
+<define name="algorithm-attlist" combine="interleave">
+    <attribute name="manifest:initialisation-vector">
+        <data type="base64Binary"/>
+    </attribute>
+</define>
+<define name="key-derivation">
+    <element name="manifest:key-derivation">
+        <ref name="key-derivation-attlist"/>
+        <empty/>
+    </element>
+</define>
+<define name="key-derivation-attlist" combine="interleave">
+    <attribute name="manifest:key-derivation-name">
+        <data type="string"/>
+    </attribute>
+</define>
+<define name="key-derivation-attlist" combine="interleave">
+    <attribute name="manifest:salt">
+        <data type="base64Binary"/>
+    </attribute>
+</define>
+<define name="key-derivation-attlist" combine="interleave">
+    <attribute name="manifest:iteration-count">
+            <data type="nonNegativeInteger"/>
+        </attribute>
+</define>
+</grammar>

tools/jingodf/jingodf/schema/OpenDocument-strict-schema-v1.1.rng

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    OASIS OpenDocument v1.1
+    OASIS Standard, 1 Feb 2007
+    Strict Relax-NG Schema
+
+    $Id$
+
+    © 2002-2007 OASIS Open
+    © 1999-2007 Sun Microsystems, Inc.
+-->
+
+<grammar xmlns="http://relaxng.org/ns/structure/1.0">
+    <include href="OpenDocument-schema-v1.1.rng">
+        <define name="office-meta-content">
+            <ref name="office-meta-content-strict"/>
+        </define>
+        <define name="style-page-layout-properties-content">
+            <ref name="style-page-layout-properties-content-strict"/>
+        </define>
+        <define name="style-header-footer-properties-content">
+            <ref name="style-header-footer-properties-content-strict"/>
+        </define>
+        <define name="style-drawing-page-properties-content">
+            <ref name="style-drawing-page-properties-content-strict"/>
+        </define>
+        <define name="style-text-properties-content">
+            <ref name="style-text-properties-content-strict"/>
+        </define>
+        <define name="style-paragraph-properties-content">
+            <ref name="style-paragraph-properties-content-strict"/>
+        </define>
+        <define name="style-ruby-properties-content">
+            <ref name="style-ruby-properties-content-strict"/>
+        </define>
+        <define name="style-section-properties-content">
+            <ref name="style-section-properties-content-strict"/>
+        </define>
+        <define name="style-list-level-properties-content">
+            <ref name="style-list-level-properties-content-strict"/>
+        </define>
+        <define name="style-table-properties-content">
+            <ref name="style-table-properties-content-strict"/>
+        </define>
+        <define name="style-table-column-properties-content">
+            <ref name="style-table-column-properties-content-strict"/>
+        </define>
+        <define name="style-table-row-properties-content">
+            <ref name="style-table-row-properties-content-strict"/>
+        </define>
+        <define name="style-table-cell-properties-content">
+            <ref name="style-table-cell-properties-content-strict"/>
+        </define>
+        <define name="style-graphic-properties-content">
+            <ref name="style-graphic-properties-content-strict"/>
+        </define>
+        <define name="style-chart-properties-content">
+            <ref name="style-chart-properties-content-strict"/>
+        </define>
+    </include>
+</grammar>

tools/jingodf/jingodf/schema/OpenDocument-v1.2-os-dsig-schema.rng

@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+        Open Document Format for Office Applications (OpenDocument) Version 1.2
+        OASIS Standard, 29 September 2011
+	Digital Signatures Relax-NG Schema
+        Source: http://docs.oasis-open.org/office/v1.2/os/
+        Copyright (c) OASIS Open 2002-2011. All Rights Reserved.
+
+	All capitalized terms in the following text have the meanings assigned to them
+   	in the OASIS Intellectual Property Rights Policy (the "OASIS IPR Policy"). The
+	full Policy may be found at the OASIS website.
+
+	This document and translations of it may be copied and furnished to others, and
+	derivative works that comment on or otherwise explain it or assist in its
+	implementation may be prepared, copied, published, and distributed, in whole or
+	in part, without restriction of any kind, provided that the above copyright
+	notice and this section are included on all such copies and derivative works.
+	However, this document itself may not be modified in any way, including by
+	removing the copyright notice or references to OASIS, except as needed for the
+	purpose of developing any document or deliverable produced by an OASIS
+	Technical Committee (in which case the rules applicable to copyrights, as set
+	forth in the OASIS IPR Policy, must be followed) or as required to translate it
+	into languages other than English.
+
+	The limited permissions granted above are perpetual and will not be revoked by
+	OASIS or its successors or assigns.
+
+	This document and the information contained herein is provided on an "AS IS"
+	basis and OASIS DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+	LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT
+	INFRINGE ANY OWNERSHIP RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR
+	FITNESS FOR A PARTICULAR PURPOSE. 
+-->
+
+<grammar
+	xmlns="http://relaxng.org/ns/structure/1.0"
+
+	datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"
+
+	xmlns:dsig="urn:oasis:names:tc:opendocument:xmlns:digitalsignature:1.0"
+	xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
+>
+<start>
+	<choice>
+		<ref name="dsig-document-signatures"/>
+	</choice>
+</start>
+<define name="dsig-document-signatures">
+	<element name="dsig:document-signatures">
+		<ref name="dsig-document-signatures-attlist"/>
+		<oneOrMore>
+			<ref name="ds-signature"/>
+		</oneOrMore>
+	</element>
+</define>
+<define name="dsig-document-signatures-attlist">
+	<attribute name="dsig:version">
+		<value>1.2</value>
+	</attribute>
+</define>
+<define name="ds-signature">
+	<element name="ds:Signature">
+		<!-- The permitted content of this element is the permitted -->
+		<!-- content of the Signature element defined by W3C XML    -->
+		<!-- Signature Syntax and Processing (Second Edition).      -->
+		<!-- See OpenDocument v1.2 part 3, section 4.3.             -->
+		<ref name="dsMarkup"/>
+	</element>
+</define>
+<define name="dsMarkup">
+	<zeroOrMore>
+		<choice>
+			<attribute>
+				<anyName/>
+			</attribute>
+			<text/>
+			<element>
+				<anyName/>
+				<ref name="dsMarkup"/>
+			</element>
+		</choice>
+	</zeroOrMore>
+</define>
+</grammar>

tools/jingodf/jingodf/schema/OpenDocument-v1.2-os-manifest-schema.rng

@@ -0,0 +1,224 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+        Open Document Format for Office Applications (OpenDocument) Version 1.2
+        OASIS Standard, 29 September 2011
+	Manifest Relax-NG Schema
+        Source: http://docs.oasis-open.org/office/v1.2/os/
+        Copyright (c) OASIS Open 2002-2011. All Rights Reserved.
+
+	All capitalized terms in the following text have the meanings assigned to them
+   	in the OASIS Intellectual Property Rights Policy (the "OASIS IPR Policy"). The
+	full Policy may be found at the OASIS website.
+
+	This document and translations of it may be copied and furnished to others, and
+	derivative works that comment on or otherwise explain it or assist in its
+	implementation may be prepared, copied, published, and distributed, in whole or
+	in part, without restriction of any kind, provided that the above copyright
+	notice and this section are included on all such copies and derivative works.
+	However, this document itself may not be modified in any way, including by
+	removing the copyright notice or references to OASIS, except as needed for the
+	purpose of developing any document or deliverable produced by an OASIS
+	Technical Committee (in which case the rules applicable to copyrights, as set
+	forth in the OASIS IPR Policy, must be followed) or as required to translate it
+	into languages other than English.
+
+	The limited permissions granted above are perpetual and will not be revoked by
+	OASIS or its successors or assigns.
+
+	This document and the information contained herein is provided on an "AS IS"
+	basis and OASIS DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+	LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT
+	INFRINGE ANY OWNERSHIP RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR
+	FITNESS FOR A PARTICULAR PURPOSE. 
+-->
+<grammar 
+	xmlns="http://relaxng.org/ns/structure/1.0"
+
+	datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"
+
+	xmlns:manifest="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"
+>
+<start>
+	<choice>
+		<ref name="manifest"/>
+	</choice>
+</start>
+<define name="manifest">
+	<element name="manifest:manifest">
+		<ref name="manifest-attlist"/>
+		<oneOrMore>
+			<ref name="file-entry"/>
+		</oneOrMore>
+	</element>
+</define>
+<define name="manifest-attlist">
+	<attribute name="manifest:version">
+		<value>1.2</value>
+	</attribute>
+</define>
+<define name="file-entry">
+	<element name="manifest:file-entry">
+		<ref name="file-entry-attlist"/>
+		<optional>
+			<ref name="encryption-data"/>
+		</optional>
+	</element>
+</define>
+<define name="file-entry-attlist">
+  <interleave>
+	<attribute name="manifest:full-path">
+		<ref name="string"/>
+	</attribute>
+	<optional>
+		<attribute name="manifest:size">
+			<ref name="nonNegativeInteger"/>
+		</attribute>
+	</optional>
+	<attribute name="manifest:media-type">
+		<ref name="string"/>
+	</attribute>
+	<optional>
+		<attribute name="manifest:preferred-view-mode">
+			<choice>
+				<value>edit</value>
+				<value>presentation-slide-show</value>
+				<value>read-only</value>
+				<ref name="namespacedToken"/> 
+			</choice> 
+		</attribute> 
+	</optional> 
+	<optional>
+		<attribute name="manifest:version">
+			<ref name="string"/>
+		</attribute>
+	</optional>
+  </interleave>
+</define>
+
+<define name="encryption-data">
+	<element name="manifest:encryption-data">
+		<ref name="encryption-data-attlist"/>
+		<ref name="algorithm"/>
+		<optional>
+			<ref name="start-key-generation"/>
+		</optional>
+		<ref name="key-derivation"/>
+	</element>
+</define>
+<define name="encryption-data-attlist">
+  <interleave>
+	<attribute name="manifest:checksum-type">
+		<choice>
+			<value>SHA1/1K</value>
+			<ref name="anyURI"/>
+		</choice>
+	</attribute>
+	<attribute name="manifest:checksum">
+		<ref name="base64Binary"/>
+	</attribute>
+  </interleave>
+</define>
+<define name="algorithm">
+	<element name="manifest:algorithm">
+		<ref name="algorithm-attlist"/>
+		<ref name="anyElements"/>
+	</element>
+</define>
+<define name="algorithm-attlist">
+  <interleave>
+	<attribute name="manifest:algorithm-name">
+		<choice>
+			<value>Blowfish CFB</value>
+			<ref name="anyURI"/>
+		</choice>
+	</attribute>
+	<attribute name="manifest:initialisation-vector">
+		<ref name="base64Binary"/>
+	</attribute>
+  </interleave>
+</define>
+<define name="anyAttListOrElements">
+	<zeroOrMore>
+		<attribute>
+			<anyName/>
+			<text/>
+		</attribute>
+	</zeroOrMore>
+	<ref name="anyElements"/>
+</define>
+<define name="anyElements">
+	<zeroOrMore>
+		<element>
+			<anyName/>
+			<mixed>
+				<ref name="anyAttListOrElements"/>
+			</mixed>
+		</element>
+	</zeroOrMore>
+</define>
+<define name="key-derivation">
+	<element name="manifest:key-derivation">
+		<ref name="key-derivation-attlist"/>
+		<empty/>
+	</element>
+</define>
+<define name="key-derivation-attlist">
+  <interleave>
+	<attribute name="manifest:key-derivation-name">
+		<choice>
+			<value>PBKDF2</value>
+			<ref name="anyURI"/>
+		</choice>
+	</attribute>
+	<attribute name="manifest:salt">
+		<ref name="base64Binary"/>
+	</attribute>
+	<attribute name="manifest:iteration-count">
+			<ref name="nonNegativeInteger"/>
+		</attribute>
+	<optional>
+		<attribute name="manifest:key-size">
+			<ref name="nonNegativeInteger"/>
+		</attribute>
+	</optional>
+  </interleave>
+</define>
+<define name="start-key-generation">
+	<element name="manifest:start-key-generation">
+		<ref name="start-key-generation-attlist"/>
+		<empty/>
+	</element>
+</define>
+<define name="start-key-generation-attlist">
+  <interleave>
+	<attribute name="manifest:start-key-generation-name">
+		<choice>
+			<value>SHA1</value>
+			<ref name="anyURI"/>
+		</choice>
+	</attribute>
+	<optional>
+		<attribute name="manifest:key-size">
+			<ref name="nonNegativeInteger"/>
+		</attribute>
+	</optional>
+  </interleave>
+</define>
+<define name="base64Binary">
+	<data type="base64Binary"/>
+</define>
+<define name="namespacedToken">
+	<data type="QName">
+		<param name="pattern">[^:]+:[^:]+</param>
+	</data>
+</define>
+<define name="nonNegativeInteger">
+	<data type="nonNegativeInteger"/>
+</define>
+<define name="string">
+	<data type="string"/>
+</define>
+<define name="anyURI">
+	<data type="anyURI"/>
+</define>
+</grammar>

tools/jingodf/jingodf/schema/OpenDocument-v1.2-os-metadata.owl

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+        Open Document Format for Office Applications (OpenDocument) Version 1.2
+        OASIS Standard, 29 September 2011
+	OWL Metadata Manifest Description
+        Source: http://docs.oasis-open.org/office/v1.2/os/
+        Copyright (c) OASIS Open 2002-2011. All Rights Reserved.
+
+	All capitalized terms in the following text have the meanings assigned to them
+   	in the OASIS Intellectual Property Rights Policy (the "OASIS IPR Policy"). The
+	full Policy may be found at the OASIS website.
+
+	This document and translations of it may be copied and furnished to others, and
+	derivative works that comment on or otherwise explain it or assist in its
+	implementation may be prepared, copied, published, and distributed, in whole or
+	in part, without restriction of any kind, provided that the above copyright
+	notice and this section are included on all such copies and derivative works.
+	However, this document itself may not be modified in any way, including by
+	removing the copyright notice or references to OASIS, except as needed for the
+	purpose of developing any document or deliverable produced by an OASIS
+	Technical Committee (in which case the rules applicable to copyrights, as set
+	forth in the OASIS IPR Policy, must be followed) or as required to translate it
+	into languages other than English.
+
+	The limited permissions granted above are perpetual and will not be revoked by
+	OASIS or its successors or assigns.
+
+	This document and the information contained herein is provided on an "AS IS"
+	basis and OASIS DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+	LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT
+	INFRINGE ANY OWNERSHIP RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR
+	FITNESS FOR A PARTICULAR PURPOSE. 
+-->
+
+<rdf:RDF
+	xmlns="http://www.w3.org/2000/01/rdf-schema#"
+	xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+	xmlns:owl="http://www.w3.org/2002/07/owl#"
+	xmlns:dc="http://purl.org/dc/elements/1.1/"
+	xmlns:pkg="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#"
+	xmlns:odf="http://docs.oasis-open.org/ns/office/1.2/meta/odf#">
+
+<owl:Ontology rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/odf#">
+	<owl:imports rdf:resource="http://docs.oasis-open.org/office/v1.2/os/OpenDocument-v1.2-os-package-metadata.owl" />
+	<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
+	<dc:title xml:lang="en">Open Document Schema Metadata Manifest Ontology</dc:title>
+	<label xml:lang="en">ODF Schema Metadata Manifest</label>
+</owl:Ontology>
+
+<owl:Class rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/odf#ContentFile">
+	<label xml:lang="en">The OpenDocument Content File</label>
+	<comment xml:lang="en">The unique content.xml from the root path of the document</comment>
+	<subClassOf rdf:resource="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#File"/>
+</owl:Class>
+
+<owl:Class rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/odf#StylesFile">
+	<label xml:lang="en">The OpenDocument Styles File</label>
+	<comment xml:lang="en">The unique styles.xml from the root path of the document</comment>
+	<subClassOf rdf:resource="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#File"/>
+</owl:Class>
+
+<owl:Class rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/odf#Element">
+	<label xml:lang="en">OpenDocument Package ODF XML Element</label>
+	<subClassOf rdf:resource="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#Element"/>
+</owl:Class>
+
+<owl:Class rdf:about="urn:oasis:names:tc:opendocument:xmlns:text:1.0meta-field">
+	<label xml:lang="en">OpenDocument Meta field Element</label>
+	<subClassOf rdf:resource="http://docs.oasis-open.org/ns/office/1.2/meta/odf#Element"/>
+</owl:Class>
+
+<owl:DatatypeProperty rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/odf#prefix">
+	<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#FunctionalProperty"/>
+	<domain rdf:resource="urn:oasis:names:tc:opendocument:xmlns:text:1.0meta-field"/>
+	<range rdf:resource="http://www.w3.org/2001/XMLSchema-datatypes#string"/>
+	<label xml:lang="en">has prefix</label>
+</owl:DatatypeProperty>
+
+<owl:DatatypeProperty rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/odf#suffix">
+	<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#FunctionalProperty"/>
+	<domain rdf:resource="urn:oasis:names:tc:opendocument:xmlns:text:1.0meta-field"/>
+	<range rdf:resource="http://www.w3.org/2001/XMLSchema-datatypes#string"/>
+	<label xml:lang="en">has suffix</label>
+</owl:DatatypeProperty>
+</rdf:RDF>
+

tools/jingodf/jingodf/schema/OpenDocument-v1.2-os-package-metadata.owl

@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+        Open Document Format for Office Applications (OpenDocument) Version 1.2
+        OASIS Standard, 29 September 2011
+	OWL Metadata Manifest Description
+        Source: http://docs.oasis-open.org/office/v1.2/os/
+        Copyright (c) OASIS Open 2002-2011. All Rights Reserved.
+
+	All capitalized terms in the following text have the meanings assigned to them
+   	in the OASIS Intellectual Property Rights Policy (the "OASIS IPR Policy"). The
+	full Policy may be found at the OASIS website.
+
+	This document and translations of it may be copied and furnished to others, and
+	derivative works that comment on or otherwise explain it or assist in its
+	implementation may be prepared, copied, published, and distributed, in whole or
+	in part, without restriction of any kind, provided that the above copyright
+	notice and this section are included on all such copies and derivative works.
+	However, this document itself may not be modified in any way, including by
+	removing the copyright notice or references to OASIS, except as needed for the
+	purpose of developing any document or deliverable produced by an OASIS
+	Technical Committee (in which case the rules applicable to copyrights, as set
+	forth in the OASIS IPR Policy, must be followed) or as required to translate it
+	into languages other than English.
+
+	The limited permissions granted above are perpetual and will not be revoked by
+	OASIS or its successors or assigns.
+
+	This document and the information contained herein is provided on an "AS IS"
+	basis and OASIS DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+	LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT
+	INFRINGE ANY OWNERSHIP RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR
+	FITNESS FOR A PARTICULAR PURPOSE. 
+-->
+
+<rdf:RDF
+	xmlns="http://www.w3.org/2000/01/rdf-schema#"
+	xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+	xmlns:owl="http://www.w3.org/2002/07/owl#"
+	xmlns:dc="http://purl.org/dc/elements/1.1/"
+	xmlns:pkg="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#">
+
+<owl:Ontology rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#">
+	<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
+	<dc:title xml:lang="en">Open Document Package Metadata Manifest Ontology</dc:title>
+	<label xml:lang="en">ODF Package Metadata Manifest</label>
+</owl:Ontology>
+
+<owl:Class rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#Document">
+	<label xml:lang="en">OpenDocument Document</label>
+</owl:Class>
+
+<owl:Class rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#File">
+	<label xml:lang="en"> OpenDocument Document Package File</label>
+</owl:Class>
+
+<owl:ObjectProperty rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#hasPart">
+	<domain rdf:resource="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#Document"/>
+	<range rdf:resource="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#File"/>
+	<label xml:lang="en">contains</label>
+	<comment xml:lang="en">Related to dcterms:hasPart of the Dublin Core Metadata Initiative</comment>
+</owl:ObjectProperty>
+
+<owl:Class rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#MetadataFile">
+	<label xml:lang="en">An OpenDocument Metadata File</label>
+	<comment xml:lang="en">Used for any metadata file in the document</comment>
+	<subClassOf rdf:resource="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#File"/>
+</owl:Class>
+
+<owl:DatatypeProperty rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#mimeType">
+	<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#FunctionalProperty"/>
+	<domain rdf:resource="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#File"/>
+	<range rdf:resource="http://www.w3.org/2001/XMLSchema-datatypes#string"/>
+	<label xml:lang="en">the MIME type</label>
+	<comment xml:lang="en">A string representing the MIME media type of a file (see RFC4288).</comment>
+</owl:DatatypeProperty>
+
+<owl:Class rdf:about="http://docs.oasis-open.org/ns/office/1.2/meta/pkg#Element">
+	<label xml:lang="en">OpenDocument Package XML Element</label>
+</owl:Class>
+
+</rdf:RDF>

tools/jingodf/setup.py

@@ -0,0 +1,13 @@
+from setuptools import setup
+
+setup(name='jingodf',
+      version='0.0',
+      license='GNU Affero GPL v3',
+      author = 'mete0r',
+      author_email = 'https://github.com/mete0r',
+      packages = ['jingodf'],
+      package_data = dict(jingodf=['schema/*']),
+      install_requires=['opster == 3.7'],
+      entry_points = {
+          'console_scripts': ['jingodf = jingodf:main']
+      })

tools/jxml/jxml.coverage/jxml_coverage.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+from __future__ import with_statement
+
+import logging
+import sys
+import os.path
+
+import colorama
+from colorama import Fore, Back, Style
+from docopt import docopt
+
+from jxml.etree import XSLTCoverage
+from jxml.etree import xsltcoverage
+
+
+def colorama_init(f):
+    def wrapper(*args, **kwargs):
+        colorama.init()
+        try:
+            return f(*args, **kwargs)
+        finally:
+            colorama.deinit()
+    return wrapper
+
+
+@colorama_init
+def annotate_main():
+    __doc__ = '''
+    Usage: jxml-annotate [options] <xml-file>...
+
+    <xml-file>  Cobertura-compatible coverage data file
+    --color=[auto|yes|no]    Output with colors
+
+    Example:
+        jxml-annotate --color=yes coverage.xml | less -R
+    '''
+    args = docopt(__doc__)
+
+    logging.basicConfig()
+    logger = logging.getLogger('jxml.annotate')
+
+    use_color = args['--color'] == 'yes'
+    if args['--color'] in ('auto', None):
+        use_color = sys.stdout.isatty()
+
+    coverage = XSLTCoverage()
+    for arg in args['<xml-file>']:
+        coverage.read_from(arg)
+
+    traces = coverage.traces
+    for filename in sorted(traces):
+        covered_lines = traces[filename]
+        if not os.path.exists(filename):
+            logger.info('skipping %s: not exists', filename)
+            continue
+        print filename
+
+        with open(filename) as f:
+            for line_no, line in enumerate(f):
+                line_no += 1
+                count = covered_lines.get(line_no, 0)
+                annotated = '%8d: %s' % (count, line)
+
+                if use_color:
+                    if count == 0:
+                        color = Fore.RED
+                    else:
+                        color = Fore.RESET
+                    annotated = color + annotated + Fore.RESET
+                sys.stdout.write(annotated)
+
+    print ''
+
+
+def load_tests(filenames):
+    import unittest
+    ts = unittest.TestSuite()
+    testloader = unittest.defaultTestLoader
+    for filename in filenames:
+        d = dict()
+        execfile(filename, d)
+        for name in d:
+            x = d[name]
+            if isinstance(x, type) and issubclass(x, unittest.TestCase):
+                ts.addTests(testloader.loadTestsFromTestCase(x))
+    return ts
+
+
+def cov_test_main():
+    __doc__ = '''
+    Usage: jxml-cov-test [options] <output-file> <unittest-file>...
+
+    <output-file>       Cobertura-compatible coverage data file.
+    <unittest-file>     unittest files.
+
+    Example:
+        jxml-cov-test coverage.xml test1.py test2.py
+    '''
+    args = docopt(__doc__)
+
+    logging.basicConfig()
+    logger = logging.getLogger('jxml.cov-test')
+
+    from java.lang import System
+    import unittest
+
+    props = System.getProperties()
+    props['javax.xml.transform.TransformerFactory'] = 'org.apache.xalan.processor.TransformerFactoryImpl'
+    props['javax.xml.parsers.DocumentBuilderFactory'] = 'org.apache.xerces.jaxp.DocumentBuilderFactoryImpl'
+    props['javax.xml.parsers.SAXParserFactory'] = 'org.apache.xerces.jaxp.SAXParserFactoryImpl'
+
+    output_name = args['<output-file>']
+    test_filenames = args['<unittest-file>']
+    ts = load_tests(test_filenames)
+    runner = unittest.TextTestRunner()
+    with xsltcoverage(output_name) as coverage:
+        runner.run(ts)

tools/jxml/jxml.coverage/setup.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup, find_packages
+import os.path
+import sys
+if not sys.platform.startswith('java'):
+    raise SystemExit(1)
+
+os.chdir(os.path.dirname(__file__))
+
+console_scripts = ['jxml-annotate = jxml_coverage:annotate_main',
+                   'jxml-cov-test = jxml_coverage:cov_test_main']
+
+setup(name='jxml.coverage',
+      py_modules=['jxml_coverage'],
+      install_requires=['jxml', 'docopt', 'colorama'],
+      entry_points=dict(console_scripts=console_scripts))

tools/jxml/jxml/etree/__init__.py

@@ -0,0 +1,1072 @@
+# -*- coding: utf-8
+from __future__ import with_statement
+
+from contextlib import contextmanager
+import logging
+from itertools import imap
+from itertools import ifilter
+from itertools import takewhile
+import os.path
+from urlparse import urlparse
+from urlparse import urljoin
+from pkgutil import simplegeneric
+
+from javax.xml import XMLConstants
+from javax.xml.parsers import DocumentBuilderFactory
+from javax.xml.xpath import XPathFactory
+from javax.xml.xpath import XPathConstants
+from javax.xml.xpath import XPathExpressionException
+from javax.xml.namespace import NamespaceContext
+from javax.xml.transform import OutputKeys
+from javax.xml.transform import TransformerFactory
+from javax.xml.transform import URIResolver
+from javax.xml.transform.dom import DOMSource
+from javax.xml.transform.dom import DOMResult
+from javax.xml.transform.stream import StreamSource
+from javax.xml.transform.stream import StreamResult
+from org.w3c import dom
+from java.io import File
+from java.io import InputStream
+from java.io import IOException
+from java.io import FileInputStream
+from java.io import FileOutputStream
+from java.io import ByteArrayInputStream
+from java.io import ByteArrayOutputStream
+from java.io import ByteArrayInputStream
+from java.util import Iterator
+from java.util import NoSuchElementException
+
+
+logger = logging.getLogger(__name__)
+
+fac = DocumentBuilderFactory.newInstance()
+fac.setNamespaceAware(True)
+builder = fac.newDocumentBuilder()
+transformfac = TransformerFactory.newInstance()
+xpathfac = XPathFactory.newInstance()
+
+
+class XSLTCoverage(object):
+
+    def __init__(self):
+        self.traces = dict()
+
+    def trace(self, systemId, startline, endline):
+        files = self.traces
+        lines = files.setdefault(systemId, dict())
+        lines[startline] = lines.get(startline, 0) + 1
+        lines[endline] = lines.get(endline, 0) + 1
+
+    def writeto(self, f):
+        trace_root = Element('coverage')
+        packages = SubElement(trace_root, 'packages')
+        package_attrib = {'name': '', 'branch-rate': '0', 'complexity': '0',
+                          'line-rate': '0'}
+        package = SubElement(packages, 'package', package_attrib)
+        classes = SubElement(package, 'classes')
+
+        for filename in sorted(self.traces):
+            if not filename:
+                continue
+            if filename.startswith('file://'):
+                fn = filename[len('file://'):]
+            else:
+                fn = filename
+            class_attrib = dict()
+            class_attrib['filename'] = fn
+            class_attrib['branch-rate'] = '0'
+            class_attrib['complexity'] = '0'
+            class_attrib['line-rate'] = '0'
+            class_attrib['name'] = os.path.basename(fn)
+            clas = SubElement(classes, 'class', class_attrib)
+            methods = SubElement(clas, 'methods')
+            linesElem = SubElement(clas, 'lines')
+            lines = self.traces[filename]
+            for lineno in sorted(lines):
+                count = lines[lineno]
+                lineElem = SubElement(linesElem, 'line',
+                                      dict(number=str(lineno),
+                                           hits=str(count)))
+        s = tostring(trace_root, encoding='utf-8', xml_declaration=True)
+        f.write(s)
+        f.write('\n')
+
+    def read_from(self, filename):
+        tree = parse(filename)
+        coverage = tree.getroot()
+        assert coverage.tag == 'coverage'
+        packages = coverage[0]
+        assert packages.tag == 'packages'
+        for package in packages:
+            if package.tag != 'package':
+                continue
+            classes = package[0]
+            assert classes.tag == 'classes'
+            for clas in classes:
+                if clas.tag != 'class':
+                    continue
+                filename = clas.get('filename')
+                trace = self.traces.setdefault(filename, dict())
+                for lines in clas:
+                    if lines.tag != 'lines':
+                        continue
+                    for line in lines:
+                        if line.tag != 'line':
+                            continue
+                        lineno = int(line.get('number'))
+                        hits = int(line.get('hits'))
+                        trace[lineno] = trace.get(lineno, 0) + hits
+
+
+xsltcoverage_trace = None
+
+
+@contextmanager
+def xsltcoverage(output=None):
+    xsltcoverage = XSLTCoverage()
+    globals()['xsltcoverage_trace'] = xsltcoverage
+    yield xsltcoverage
+    globals()['xsltcoverage_trace'] = None
+    if output is not None:
+        if isinstance(output, basestring):
+            with open(output, 'w') as f:
+                xsltcoverage.writeto(f)
+        elif hasattr(output, 'write'):
+            xsltcoverage.writeto(output)
+
+
+def instrument_xalan_transformer_factory(transformfac):
+    from javax.xml.transform import Templates
+    try:
+        from org.apache.xalan.processor import TransformerFactoryImpl
+        from org.apache.xalan.transformer import TransformerImpl
+        from org.apache.xalan.trace import TraceListenerEx2
+    except ImportError:
+        logger.warning('Xalan-J is not found: '
+                       'check your CLASSPATH. '
+                       'there will be no coverage data')
+        return transformfac
+    if not isinstance(transformfac, TransformerFactoryImpl):
+        logger.warning('TransformerFactory implementation is not Xalan-J: '
+                       'check system property of '
+                       'javax.xml.transform.TransformerFactory. '
+                       'there will be no coverage data')
+        return transformfac
+    if xsltcoverage_trace is None:
+        return transformfac
+
+    class XalanTraceListener(TraceListenerEx2):
+
+        def trace(self, ev):
+            stylenode = ev.m_styleNode
+            systemId = stylenode.getSystemId()
+            startline = stylenode.getLineNumber()
+            endline = stylenode.getEndLineNumber()
+
+            xsltcoverage_trace.trace(systemId, startline, endline)
+
+    traceListener = XalanTraceListener()
+
+    class XalanTransformerInstrumentImpl(TransformerFactoryImpl):
+
+        def newTemplates(self, source):
+            templates = TransformerFactoryImpl.newTemplates(self, source)
+            return XalanTemplates(templates, source)
+
+        def newTransformer(self, source=None):
+            impl = TransformerFactoryImpl.newTransformer(self, source)
+            # add listener
+            tracemanager = impl.getTraceManager()
+            tracemanager.addTraceListener(traceListener)
+            return impl
+
+    class XalanTemplates(Templates):
+
+        def __init__(self, t, s):
+            self.templates = t
+            self.source = s
+
+        def newTransformer(self):
+            transformer = self.templates.newTransformer()
+            # add listener
+            tracemanager = transformer.getTraceManager()
+            tracemanager.addTraceListener(traceListener)
+            return transformer
+
+        def getOutputProperties(self):
+            return self.templates.getOutputProperties()
+
+    return XalanTransformerInstrumentImpl()
+
+
+XML_URI = 'http://www.w3.org/XML/1998/namespace'
+XMLNS_URI = 'http://www.w3.org/2000/xmlns/'
+TRANSIENT_NAMESPACE_PREFIXES = {'xml': XML_URI, 'xmlns': XMLNS_URI}
+
+
+def split_prefix_and_localName(tag):
+    if ':' in tag:
+        return tag.split(':', 1)
+    else:
+        return None, tag
+
+
+def split_jcnotation(tag):
+    ''' Get namespaceURI and localName from a James Clark's notation.
+
+    See http://www.jclark.com/xml/xmlns.htm
+    '''
+    if tag[0] != '{':
+        return None, tag
+    pos = tag.find('}')
+    if pos == -1:
+        raise ValueError(tag)
+    return tag[1:pos], tag[pos+1:]
+
+
+def get_prefix_for_uri(namespaceURI, nsmap):
+    for prefix, uri in nsmap.items():
+        if uri == namespaceURI:
+            return prefix
+    if namespaceURI in TRANSIENT_NAMESPACE_PREFIXES:
+        return TRANSIENT_NAMESPACE_PREFIXES[namespaceURI]
+    prefix = 'ns' + str(len(TRANSIENT_NAMESPACE_PREFIXES))
+    TRANSIENT_NAMESPACE_PREFIXES[namespaceURI] = prefix
+    return prefix
+
+
+def dom_element_from_tag(tag, nsmap=None):
+    if nsmap is None:
+        nsmap = {}
+    doc = builder.newDocument()
+    namespaceURI, localName = split_jcnotation(tag)
+    if namespaceURI is not None:
+        prefix = get_prefix_for_uri(namespaceURI, nsmap)
+        return doc.createElementNS(namespaceURI, prefix + ':' + localName)
+    else:
+        return doc.createElement(localName)
+
+
+def dom_document_from_file(f):
+    if hasattr(f, 'name'):
+        documentURI = os.path.abspath(f.name)
+    else:
+        documentURI = None
+    bytestring = f.read()
+
+    temp = File.createTempFile('someprefix', 'tmp')
+
+    outputstream = FileOutputStream(temp)
+    try:
+        outputstream.write(bytestring)
+    finally:
+        outputstream.close()
+
+    inputstream = FileInputStream(temp)
+    try:
+        dom_doc = dom_document_from_inputstream(inputstream)
+        dom_doc.setDocumentURI(documentURI)
+        return dom_doc
+    finally:
+        inputstream.close()
+
+
+def dom_document_from_inputstream(inputstream):
+    return builder.parse(inputstream)
+
+
+def dom_tag(dom_element):
+    return dom_jcnotation(dom_element)
+
+
+def dom_jcnotation(dom_node):
+    ''' Get node name expressed in James Clark's notation.
+
+    See http://www.jclark.com/xml/xmlns.htm
+    '''
+    namespaceURI = dom_node.namespaceURI
+    if namespaceURI:
+        namespace = '{%s}' % namespaceURI
+        return namespace + dom_node.localName
+    else:
+        return dom_node.nodeName
+
+
+def dom_nsmap_specified_here(dom_element):
+    nsmap = {}
+    attrs = dom_element.attributes
+    for i in range(0, attrs.length):
+        attr = attrs.item(i)
+        if attr.name.startswith('xmlns:'):
+            prefix = attr.name[len('xmlns:'):]
+            uri = attr.value
+            nsmap[prefix] = uri
+        else:
+            prefix = attr.prefix
+            uri = attr.namespaceURI
+            if prefix and uri:
+                nsmap[prefix] = uri
+    return nsmap
+
+
+dom_node_is_element = lambda n: n.nodeType == dom.Node.ELEMENT_NODE
+
+
+def dom_ancestors(dom_node):
+    while True:
+        dom_node = dom_node.parentNode
+        if dom_node:
+            yield dom_node
+        else:
+            return
+
+
+def dom_ancestor_elements(dom_node):
+    return takewhile(dom_node_is_element,
+                     dom_ancestors(dom_node))
+
+
+def dom_siblings_next(dom_node):
+    while True:
+        dom_node = dom_node.nextSibling
+        if dom_node:
+            yield dom_node
+        else:
+            return
+
+
+def dom_siblings_previous(dom_node):
+    while True:
+        dom_node = dom_node.previousSibling
+        if dom_node:
+            yield dom_node
+        else:
+            return
+
+
+def dom_nsmap(dom_element):
+    assert dom_element.nodeType == dom_element.ELEMENT_NODE
+    default_nsmap = dom_nsmap_specified_here(dom_element)
+    for ancestor in dom_ancestor_elements(dom_element):
+        nsmap = dom_nsmap_specified_here(ancestor)
+        nsmap.update(default_nsmap)
+        default_nsmap = nsmap
+    return default_nsmap
+
+
+def dom_set_attr(dom_element, key, value, nsmap):
+    namespaceURI, localName = split_jcnotation(key)
+    if namespaceURI:
+        prefix = get_prefix_for_uri(namespaceURI, nsmap)
+        qualifiedName = prefix + ':' + localName
+        dom_element.setAttributeNS(namespaceURI, qualifiedName, value)
+    else:
+        dom_element.setAttribute(key, value)
+
+
+def Element(tag, attrib=None, nsmap=None, **extra):
+    assert isinstance(tag, basestring)
+    dom_element = dom_element_from_tag(tag, nsmap)
+    nsmap = nsmap or {}
+
+    dom_document = dom_element.getOwnerDocument() 
+    for prefix, namespaceURI in nsmap.items():
+        dom_element.setAttributeNS(XMLNS_URI, 'xmlns:'+prefix, namespaceURI)
+
+    if attrib:
+        extra.update(attrib)
+    if extra:
+        for k, v in extra.items():
+            dom_set_attr(dom_element, k, v, nsmap)
+    return _Element(dom_element)
+
+
+def SubElement(parent, tag, attrib=None, nsmap=None, **extra):
+    element = Element(tag, attrib, nsmap, **extra)
+    parent.append(element)
+    return element
+
+
+def ElementTree(element=None, file=None, parser=None):
+    if parser is not None:
+        raise NotImplementedError('parser is not supported')
+    elif element is not None:
+        dom_doc = builder.newDocument()
+        dom_doc.documentURI = element._dom_element.ownerDocument.documentURI
+        dom_root = dom_doc.importNode(element._dom_element, True)
+        dom_doc.appendChild(dom_root)
+        _Element(dom_root)
+    elif file is not None:
+        dom_doc = dom_document_from_file(file)
+    else:
+        raise ValueError('element and file is None')
+    return _ElementTree(dom_doc)
+
+
+class _Element(object):
+
+    def __init__(self, dom_element):
+        if dom_element.nodeType != dom_element.ELEMENT_NODE:
+            raise ValueError('ELEMENT_NODE(%d) required: %d' %
+                             (dom_element.ELEMENT_NODE, dom_element.nodeType))
+        self._dom_element = dom_element
+
+    def getroottree(self):
+        dom_doc = self._dom_element.getOwnerDocument()
+        return _ElementTree(dom_doc)
+
+    @property
+    def attrib(self):
+        attrib = dict()
+        dom_attrib = self._dom_element.getAttributes()
+        for i in range(dom_attrib.length):
+            child = dom_attrib.item(i)
+            name = child.name
+            if not name.startswith('xmlns:') and name != 'xmlns':
+                attrib[dom_jcnotation(child)] = child.value
+        return attrib
+
+    @property
+    def tag(self):
+        return dom_tag(self._dom_element)
+
+    @property
+    def nsmap(self):
+        return dom_nsmap(self._dom_element)
+
+    @property
+    def prefix(self):
+        namespaceURI = self._dom_element.namespaceURI
+        return self._dom_element.lookupPrefix(namespaceURI)
+
+    @property
+    def text(self):
+        node = self._dom_element.firstChild
+        if node and node.nodeType == node.TEXT_NODE:
+            return node.getWholeText()
+
+    @property
+    def tail(self):
+        node = self._dom_element.nextSibling
+        if node and node.nodeType == node.TEXT_NODE:
+            return node.getWholeText()
+
+    @property
+    def base(self):
+        dom_doc = self._dom_element.ownerDocument
+        return dom_doc.documentURI
+
+    def __deepcopy__(self, memo):
+        dom_doc = builder.newDocument()
+        copied = dom_doc.importNode(self._dom_element, True)
+        return _Element(copied)
+
+    def __iter__(self):
+        childs = self._dom_element.getChildNodes()
+        for i in range(childs.length):
+            child = childs.item(i)
+            if child.nodeType == child.ELEMENT_NODE:
+                yield _Element(child)
+
+    def __getitem__(self, index):
+        if index >= 0:
+            iterable = self.__iter__()
+        else:
+            iterable = self.__reversed__()
+            index = -index - 1
+        for child in iterable:
+            if index == 0:
+                return child
+            index -= 1
+        raise IndexError(index)
+
+    def __len__(self):
+        n = 0
+        for _ in self.__iter__():
+            n += 1
+        return n
+
+    def __reversed__(self):
+        childs = self._dom_element.getChildNodes()
+        length = childs.length
+        for x in range(length):
+            i = length - x - 1
+            child = childs.item(i)
+            if child.nodeType == child.ELEMENT_NODE:
+                yield _Element(child)
+
+    def __setitem__(self, index, new_elem):
+        old_elem = self.__getitem__(index)
+
+        dom_document = self._dom_element.getOwnerDocument()
+        dom_element_new = dom_document.importNode(new_elem._dom_element, True)
+        self._dom_element.replaceChild(dom_element_new,
+                                       old_elem._dom_element)
+
+    def append(self, element):
+        dom_document = self._dom_element.getOwnerDocument()
+        dom_element_new = dom_document.importNode(element._dom_element, True)
+        self._dom_element.appendChild(dom_element_new)
+        element._dom_element = dom_element_new
+
+    def get(self, key):
+        return self.attrib.get(key)
+
+    def getchildren(self):
+        # TODO: deprecated warning
+        return list(self.__iter__())
+
+    def getnext(self):
+        sibling = None
+        for sibling in dom_siblings_next(self._dom_element):
+            if dom_node_is_element(sibling):
+                return _Element(sibling)
+
+    def getparent(self):
+        dom_parent = self._dom_element.getParentNode()
+        if dom_parent and dom_node_is_element(dom_parent):
+            return _Element(dom_parent)
+
+    def getprevious(self):
+        sibling = None
+        for sibling in dom_siblings_previous(self._dom_element):
+            if dom_node_is_element(sibling):
+                return _Element(sibling)
+
+    def iterancestors(self, *tags):
+        parents = imap(_Element, dom_ancestor_elements(self._dom_element))
+        if tags:
+            parents = ifilter(lambda elem: elem.tag in tags,
+                              parents)
+        return parents
+
+    def keys(self):
+        return self.attrib.keys()
+
+    def set(self, key, value):
+        dom_doc = self._dom_element.getOwnerDocument()
+        dom_element = self._dom_element
+        dom_set_attr(dom_element, key, value, self.nsmap)
+
+    def values(self):
+        return self.attrib.values()
+
+    def xpath(self, _path, namespaces=None, extensions=None,
+              smart_strings=True, **_variables):
+        xpath = XPath(_path, namespaces, extensions, smart_strings)
+        return xpath(self, **_variables)
+
+
+class _ElementTree(object):
+
+    def __init__(self, dom_doc):
+        self._set_dom_doc(dom_doc)
+
+    def __copy__(self, dom_doc):
+        raise NotImplementedError('__copy__() is not implemented yet')
+
+    def __deepcopy__(self, memo):
+        dom_doc = builder.newDocument()
+        dom_root = dom_doc.importNode(self.getroot()._dom_element, True)
+        return _ElementTree(dom_doc)
+
+    @property
+    def docinfo(self):
+        dom_doc = self._dom_doc
+        return DocInfo(dom_doc)
+
+    def _setroot(self, root):
+        self._set_dom_doc(root._dom_element.getOwnerDocument())
+
+    def _set_dom_doc(self, dom_doc):
+        if dom_doc.nodeType != dom_doc.DOCUMENT_NODE:
+            raise ValueError('DOCUMENT_NODE(%d) required: %d' %
+                             (dom.DOCUMENT_NODE, dom_doc.nodeType))
+        self._dom_doc = dom_doc
+
+    def getroot(self):
+        dom_root = self._dom_doc.getDocumentElement()
+        if dom_root is not None:
+            return _Element(dom_root)
+
+    def find(self, path, namespaces=None):
+        root = self.getroot()
+        return root.find(path, namespaces)
+
+    def findall(self, path, namespaces=None):
+        root = self.getroot()
+        return root.findall(path, namespaces)
+
+    def findtext(self, path, default=None, namespaces=None):
+        root = self.getroot()
+        return root.findtext(path, default, namespaces)
+
+    def iter(self, **tags):
+        root = self.getroot()
+        return root.iter(*tags)
+
+    def iterfind(self, path, namespaces=None):
+        root = self.getroot()
+        return root.iterfind(path)
+
+    def relaxng(self, relaxng):
+        raise NotImplementedError('relaxng is not implemented yet')
+
+    def write(self, file, encoding=None, method='xml', pretty_print=False,
+              xml_declaration=None, with_tail=True, standalone=None,
+              compression=0, exclusive=False, with_comments=True,
+              inclusive_ns_prefixes=None):
+
+        if compression != 0:
+            raise NotImplementedError('compression should be 0')
+
+        s = tostring(self, encoding=encoding, method=method,
+                     pretty_print=pretty_print,
+                     xml_declaration=xml_declaration, with_tail=with_tail,
+                     standalone=standalone, exclusive=exclusive,
+                     with_comments=with_comments,
+                     inclusive_ns_prefixes=inclusive_ns_prefixes)
+        if isinstance(file, basestring):
+            with open(file, 'w') as f:
+                f.write(s)
+        elif hasattr(file, 'write'):
+            file.write(s)
+
+    def write_c14n(self, file, exlusive=False, with_comments=True,
+                   compression=0, inclusive_ns_prefixes=None):
+        raise NotImplementedError('write_c14n() is not implemented yet')
+
+    def xinclude(self):
+        raise NotImplementedError('xinclude() is not implemented yet')
+
+    def xmlschema(self, xmlschema):
+        raise NotImplementedError('xmlschema() is not implemented yet')
+
+    def xpath(self, _path, namespaces=None, extensions=None,
+              smart_strings=True, **_variables):
+        xpath = XPath(_path, namespaces, extensions, smart_strings)
+        return xpath(self, **_variables)
+
+    def xslt(self, _xslt, extensions=None, access_control=None, **_kw):
+        xslt = XSLT(_xslt, extensions=extensions,
+                    access_control=access_control)
+        return xslt(self, **_kw)
+
+
+class DocInfo(object):
+
+    def __init__(self, dom_doc):
+        self.dom_doc = dom_doc
+
+    def getURL(self):
+        return self.dom_doc.documentURI
+
+    def setURL(self, uri):
+        self.dom_doc.documentURI = uri
+
+    URL = property(getURL, setURL)
+
+    @property
+    def doctype(self):
+        doctype = self.dom_doc.doctype
+        if doctype:
+            return doctype.name
+        return ''
+
+    @property
+    def public_id(self):
+        doctype = self.dom_doc.doctype
+        if doctype:
+            return doctype.publicId
+
+    @property
+    def system_url(self):
+        doctype = self.dom_doc.doctype
+        if doctype:
+            return doctype.systemId
+
+    @property
+    def encoding(self):
+        return self.dom_doc.getXmlEncoding()
+
+    @property
+    def root_name(self):
+        dom_root = self.dom_doc.getDocumentElement()
+        if dom_root:
+            return dom_root.localName
+
+    @property
+    def standalone(self):
+        return self.dom_doc.getXmlStandalone()
+
+    @property
+    def xml_version(self):
+        return self.dom_doc.getXmlVersion()
+
+    @property
+    def externalDTD(self):
+        # TODO
+        return None
+
+    @property
+    def internalDTD(self):
+        # TODO
+        return None
+
+
+class QName(object):
+
+    def __init__(self, text_or_uri_or_element, tag=None):
+        x = text_or_uri_or_element
+        if tag is not None:
+            if not isinstance(x, basestring):
+                raise ValueError('Bad namespace URI: %s' %
+                                 text_or_uri_or_element)
+            if not isinstance(tag, basestring):
+                raise ValueError('Bad tag: %s', tag)
+            self.namespace = x
+            self.localname = tag
+        elif isinstance(x, _Element):
+            assert tag is None
+            dom_node = x._dom_element
+            self.namespace = dom_node.namespaceURI
+            self.localname = dom_node.localName
+        elif isinstance(x, basestring):
+            self.namespace, self.localname = split_jcnotation(x)
+        else:
+            raise ValueError('Bad argument: %s' % text_or_uri_or_element)
+
+    @property
+    def text(self):
+        if self.namespace:
+            return '{%s}%s' % (self.namespace, self.localname)
+        return self.localname
+
+
+class XPath(object):
+
+    def __init__(self, path, namespaces=None, extensions=None, regexp=True,
+                 smart_strings=True):
+        if extensions:
+            raise NotImplementedError('extensions are not supported')
+
+        xpath = xpathfac.newXPath()
+        nscontext = NamespaceContextImpl(namespaces or {})
+        xpath.setNamespaceContext(nscontext)
+        self.xpathexpr = xpath.compile(path)
+
+    def __call__(self, _etree_or_element, **_variables):
+        if len(_variables):
+            raise NotImplementedError('variables are not supported')
+
+        if isinstance(_etree_or_element, _ElementTree):
+            node = _etree_or_element._dom_doc.getDocumentElement()
+        elif isinstance(_etree_or_element, _Element):
+            node = _etree_or_element._dom_element
+        else:
+            logger.error('_etree_or_element should be an instance of '
+                         '_Element/_ElementTree')
+            raise ValueError()
+
+        # TODO: heuristic
+        try:
+            return self._eval_nodeset(node)
+        except XPathExpressionException, e:
+            pass
+
+        try:
+            return self._eval_node(node)
+        except XPathExpressionException, e:
+            pass
+
+        try:
+            result = self._eval_number(node)
+            if not (isinstance(result, float) and str(result) == 'nan'):
+                return result
+        except XPathExpressionException, e:
+            pass
+
+        try:
+            return self._eval_string(node)
+        except XPathExpressionException, e:
+            pass
+
+        return self._eval_boolean(node)
+
+    def _eval_nodeset(self, node):
+        result = self.xpathexpr.evaluate(node, XPathConstants.NODESET)
+        return dom_xpath_result(result)
+
+    def _eval_node(self, node):
+        result = self.xpathexpr.evaluate(node, XPathConstants.NODE)
+        return dom_xpath_result(result)
+
+    def _eval_string(self, node):
+        result = self.xpathexpr.evaluate(node, XPathConstants.STRING)
+        return dom_xpath_result(result)
+
+    def _eval_number(self, node):
+        result = self.xpathexpr.evaluate(node, XPathConstants.NUMBER)
+        return dom_xpath_result(result)
+
+    def _eval_boolean(self, node):
+        result = self.xpathexpr.evaluate(node, XPathConstants.BOOLEAN)
+        return dom_xpath_result(result)
+
+
+@simplegeneric
+def dom_xpath_result(result):
+    return result
+
+
+@dom_xpath_result.register(dom.NodeList)
+def dom_xpath_result_nodelist(nodelist):
+    resultset = []
+    for i in range(nodelist.length):
+        item = nodelist.item(i)
+        resultset.append(dom_xpath_result(item))
+    return resultset
+
+
+@dom_xpath_result.register(dom.Element)
+def dom_xpath_result_element(element):
+    return _Element(element)
+
+
+@dom_xpath_result.register(dom.Attr)
+def dom_xpath_result_attr(attr):
+    return attr.value
+
+
+class NamespaceContextImpl(NamespaceContext):
+
+    def __init__(self, nsmap):
+        self.nsmap = nsmap
+
+    def getNamespaceURI(self, prefix):
+        # TODO: default namespace, etc., not implemented
+        if prefix is None:
+            raise IllegalArgumentException()
+        if prefix in self.nsmap:
+            return self.nsmap[prefix]
+        return XMLConstants.NULL_NS_URI
+
+    def getPrefixes(self, namespaceURI):
+        if namespaceURI is None:
+            raise IllegalArgumentException()
+        return IteratorImpl(self.iterPrefixes(namespaceURI))
+
+    def getPrefix(self, namespaceURI):
+        prefixes = self.getPrefixes(namespaceURI)
+        if prefixes is None:
+            return None
+
+    def iterPrefixes(self, namespaceURI):
+        if namespaceURI is None:
+            raise IllegalArgumentException()
+        for prefix, uri in self.nsmap.items():
+            if uri == namespaceURI:
+                yield prefix
+
+
+class IteratorImpl(Iterator):
+
+    def __init__(self, it):
+        self.it = it
+        self._goNext()
+
+    def hasNext(self):
+        return self._hasNext
+
+    def next(self):
+        if self._hasNext:
+            try:
+                return self._nextItem
+            finally:
+                self._goNext()
+        else:
+            raise NoSuchElementException()
+
+    def _goNext(self):
+        try:
+            self._nextItem = it.next()
+            self._hasNext = True
+        except StopIteration:
+            self._nextItem = None
+            self._hasNext = False
+
+
+class XSLT(object):
+
+    def __init__(self, xsl_input, extensions=None, regexp=True,
+                 access_control=None):
+        if extensions:
+            raise NotImplementedError('extensions is not supported')
+        if access_control:
+            raise NotImplementedError('access_control is not supported')
+
+        if isinstance(xsl_input, _ElementTree):
+            xsl_tree = xsl_input
+        elif isinstance(xsl_input, _Element):
+            xsl_tree = ElementTree(xsl_input)
+        else:
+            raise ValueError(xsl_input)
+
+        self.xsl_tree = xsl_tree
+        self.xsl_source = DOMSource(xsl_tree._dom_doc, xsl_tree.docinfo.URL)
+        self.uri_resolver = __URIResolverImpl(xsl_tree)
+
+        #print tostring(xsl_tree)
+        fac = TransformerFactory.newInstance()
+        fac.setURIResolver(self.uri_resolver)
+        fac = instrument_xalan_transformer_factory(fac)
+        self.transformer = fac.newTransformer(self.xsl_source)
+
+    def __call__(self, _input, profile_run=False, **kw):
+
+        nsmap = dict(xsl='http://www.w3.org/1999/XSL/Transform')
+        output_method = 'xml'
+        output_encoding = 'utf-8'
+
+        nodes = self.xsl_tree.xpath('xsl:output/@method', namespaces=nsmap)
+        if len(nodes) > 0:
+            output_method = nodes[0]
+
+        nodes = self.xsl_tree.xpath('xsl:output/@encoding', namespaces=nsmap)
+        if len(nodes) > 0:
+            output_encoding = nodes[0]
+
+        #print tostring(_input)
+        if isinstance(_input, _ElementTree):
+            doc_source = DOMSource(_input._dom_doc)
+        elif isinstance(_input, _Element):
+            # Xalan-J 2.7.1 does not support a DOMSource from an Element
+            # so we build new document
+            dom_doc = builder.newDocument()
+            dom_root = dom_doc.importNode(_input._dom_element, True)
+            dom_doc.appendChild(dom_root)
+            doc_source = DOMSource(dom_doc)
+        else:
+            raise NotImplementedError()
+
+        if output_method in ('xml', 'html'):
+
+            # TODO: for testing
+            outputstream = ByteArrayOutputStream()
+            result = StreamResult(outputstream)
+            self.transformer.transform(doc_source, result)
+            bytes = outputstream.toByteArray()
+            inputstream = ByteArrayInputStream(bytes)
+            try:
+                dom_doc = builder.parse(inputstream)
+            except:
+                import sys
+                sys.stderr.write(bytes.tostring())
+                raise
+            result_tree = _ElementTree(dom_doc)
+            return result_tree
+
+            result = DOMResult()
+            self.transformer.transform(doc_source, result)
+            dom_doc = result.getNode()
+            result_tree = _ElementTree(dom_doc)
+            #print tostring(result_tree)
+            return result_tree
+        else:
+            outputstream = ByteArrayOutputStream()
+            result = StreamResult(outputstream)
+            self.transformer.transform(doc_source, result)
+
+            resultdoc = builder.newDocument()
+            resulttree = _XSLTResultTree(resultdoc)
+            resulttree._text = outputstream.toString(output_encoding)
+            return resulttree
+
+
+class _XSLTResultTree(_ElementTree):
+
+    def __unicode__(self):
+        return self._text
+
+    def __str__(self):
+        return self._text.encode(self.docinfo.encoding)
+
+
+class __URIResolverImpl(URIResolver):
+
+    def __init__(self, tree):
+        self.__logger = logging.getLogger(__name__+'.'+type(self).__name__)
+        self.base = tree.docinfo.URL
+
+    def resolve(self, href, base):
+        self.__logger.debug('default_base: %r', self.base)
+        self.__logger.debug('href: %r', href)
+        self.__logger.debug('base: %r', base)
+        if base is None:
+            base = self.base
+
+        if base is not None:
+            href = urljoin(base, href)
+        else:
+            href = href
+
+        href = urlparse(href)
+
+        # if href is not a URL
+        if not href.scheme and not href.hostname:
+            return StreamSource(File(href.path))
+
+
+def parse(source, parser=None, base_url=None):
+    if base_url is not None:
+        raise NotImplementedError('base_url is not supported')
+
+    if isinstance(source, basestring):
+        with open(source) as f:
+            return ElementTree(file=f)
+    if hasattr(source, 'read'):
+        return ElementTree(file=source)
+    assert False, 'source should be a string or file-like object'
+
+
+def fromstring(text, parser=None, base_url=None):
+    if base_url is not None:
+        raise NotImplementedError('base_url is not supported')
+    from StringIO import StringIO
+    f = StringIO(text)
+    return ElementTree(file=f)
+
+
+def tostring(element_or_tree, encoding=None, method='xml',
+             xml_declaration=None, pretty_print=False, with_tail=True,
+             standalone=None, doctype=None, exclusive=False,
+             with_comments=True, inclusive_ns_prefixes=None):
+    if isinstance(element_or_tree, _ElementTree):
+        source = DOMSource(element_or_tree._dom_doc)
+    else:
+        source = DOMSource(element_or_tree._dom_element)
+
+    outputstream = ByteArrayOutputStream()
+    result = StreamResult(outputstream)
+    transformer = transformfac.newTransformer()
+    if xml_declaration:
+        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION,
+                                      'no')
+    else:
+        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION,
+                                      'yes')
+    if pretty_print:
+        transformer.setOutputProperty(OutputKeys.INDENT, 'yes')
+    else:
+        transformer.setOutputProperty(OutputKeys.INDENT, 'no')
+    transformer.transform(source, result)
+
+    if encoding is None:
+        encoding = 'ascii'
+    return outputstream.toString(encoding)
+
+
+def XML(s):
+    from StringIO import StringIO
+    sio = StringIO(s)
+    return parse(sio).getroot()

tools/jxml/lxml/lxml/__init__.py

@@ -0,0 +1 @@
+from jxml import *

tools/jxml/lxml/lxml/etree/__init__.py

@@ -0,0 +1 @@
+from jxml.etree import *

tools/jxml/lxml/setup.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup, find_packages
+import os.path
+import sys
+if not sys.platform.startswith('java'):
+    raise SystemExit(1)
+os.chdir(os.path.dirname(__file__))
+setup(name='jxml.lxml',
+      packages=find_packages())

tools/jxml/setup.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup, find_packages
+import os.path
+import sys
+if not sys.platform.startswith('java'):
+    raise SystemExit(1)
+os.chdir(os.path.dirname(__file__))
+setup(name='jxml',
+      packages=find_packages())

tools/jxml/tests/Makefile

@@ -0,0 +1,52 @@
+BUILDOUT_DIR := ${realpath ../../..}
+JXML_DIR := ${realpath ..}
+JXML_BIN_DIR:=$(JXML_DIR)/bin
+JXML_LXML_DIR := ${JXML_DIR}/lxml
+TEST_XSL_DIR := ${JXML_DIR}/tests/test-xsl
+XML_FIXT_DIR := ${TEST_XSL_DIR}/fxt
+TEST_GEN_DIR := ${TEST_XSL_DIR}/gen
+
+
+
+XALAN_J_ARCHIVE = ${BUILDOUT_DIR}/parts/xalan-j_2_7_1-bin-2jars.tar.gz
+XALAN_J_DIR = ${BUILDOUT_DIR}/parts/xalan-j_2_7_1
+XALAN_J_CLASSPATH = ${XALAN_J_DIR}/xalan.jar:${XALAN_J_DIR}/xercesImpl.jar:${XALAN_J_DIR}/serializer.jar:${XALAN_J_DIR}/xml-apis.jar
+XALAN_J_SYS_PROPS = -Djavax.xml.transform.TransformerFactory=org.apache.xalan.processor.TransformerFactoryImpl -Djavax.xml.parsers.DocumentBuilderFactory=org.apache.xerces.jaxp.DocumentBuilderFactoryImpl -Djavax.xml.parsers.SAXParserFactory=org.apache.xerces.jaxp.SAXParserFactoryImpl
+XALAN_J_ENVSET = CLASSPATH=${XALAN_J_CLASSPATH}
+XALAN_J_JYTHON = ${XALAN_J_ENVSET} ${JXML_BIN_DIR}/jython ${XALAN_J_SYS_PROPS}
+
+
+DEFAULT_JYTHON = ${JXML_BIN_DIR}/jython
+JXML_ENVSET = JYTHONPATH=${JXML_DIR}:${JXML_LXML_DIR}
+
+.PHONY: test-jaxp test-jaxp-xalan test-python test-jython test-jython-xalan test-xsl test-xsl-xalan test-jxml-cov-test test-jxml-annotate
+all: test-jaxp test-jaxp-xalan test-python test-jython test-jython-xalan test-xsl test-xsl-xalan test-jxml-cov-test test-jxml-annotate
+
+test-python:
+	python test_lxml.py
+test-jython:
+	${JXML_ENVSET} ${DEFAULT_JYTHON} test_lxml.py
+test-jython-xalan: ${XALAN_J_DIR}
+	#${XALAN_J_JYTHON} test_textout.py
+	${JXML_ENVSET} ${XALAN_J_JYTHON} test_lxml.py
+test-xsl:
+	for fn in `ls ${BUILDOUT_DIR}/test-xsl/gen/*.py`; do echo $$fn; ${JXML_ENVSET} ${DEFAULT_JYTHON} $$fn; done
+test-xsl-xalan: ${XALAN_J_DIR}
+	for fn in `ls ${BUILDOUT_DIR}/test-xsl/gen/*.py`; do echo $$fn; ${JXML_ENVSET} ${XALAN_J_JYTHON} $$fn; done
+test-jaxp:
+	${DEFAULT_JYTHON} test_jaxp.py
+test-jaxp-xalan:
+	${XALAN_J_JYTHON} test_jaxp.py
+
+test-jxml-cov-test:
+	${XALAN_J_ENVSET} ${JXML_BIN_DIR}/jxml-cov-test coverage.xml ${BUILDOUT_DIR}/test-xsl/gen/*.py
+test-jxml-annotate: test-jxml-cov-test
+	${JXML_BIN_DIR}/jxml-annotate --color=yes coverage.xml > coverage.color.txt
+
+
+
+${XALAN_J_DIR}: ${XALAN_J_ARCHIVE}
+	${BUILDOUT_DIR}/bin/pyhwp-unpack $< $@
+
+${XALAN_J_ARCHIVE}:
+	${BUILDOUT_DIR}/bin/pyhwp-download http://mirror.apache-kr.org/xalan/xalan-j/binaries/xalan-j_2_7_1-bin-2jars.tar.gz ${BUILDOUT_DIR}/parts 3ccda39bcd08b780436dfd2f22fb23d5

tools/jxml/tests/hello.xml

@@ -0,0 +1 @@
+<?xml version="1.0"?><hello />

tools/jxml/tests/sample.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<x:document xmlns:x="http://example.tld" version="1.0">
+  <x:paragraph>text<x:span>foo</x:span></x:paragraph>tail<z:object xmlns:z="http://z.example.tld" a="1" x:b="2" z:c="3" />
+  <x:third />
+</x:document>

tools/jxml/tests/test_jaxp.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+import unittest
+
+from java.lang import System
+from java.io import File
+from java.io import ByteArrayOutputStream
+from javax.xml.parsers import DocumentBuilderFactory
+from javax.xml.transform import TransformerFactory
+from javax.xml.transform.dom import DOMSource
+from javax.xml.transform.stream import StreamSource
+from javax.xml.transform.stream import StreamResult
+
+dbfac = DocumentBuilderFactory.newInstance()
+dbfac.namespaceAware = True
+docfac = dbfac.newDocumentBuilder()
+print type(dbfac)
+
+transfac = TransformerFactory.newInstance()
+
+src_dom = docfac.parse('hello.xml')
+src_source = DOMSource(src_dom)
+
+
+def unsigned_byte(x):
+    if x < 0:
+        return 256 + x
+    return x
+
+
+def Transformer(xsl_source):
+    transformer = transfac.newTransformer(xsl_source)
+    def transform(src_source):
+        outputstream = ByteArrayOutputStream()
+        dst_result = StreamResult(outputstream)
+        transformer.transform(src_source, dst_result)
+        return ''.join(chr(unsigned_byte(x)) for x in outputstream.toByteArray())
+    return transform
+
+
+def transform(xsl_source, src_source):
+    transform = Transformer(xsl_source)
+    return transform(src_source)
+
+
+class TestXSLT(unittest.TestCase):
+
+    xsl_path = 'xsl/import-test.xsl'
+
+    def test_xsl_dom(self):
+
+        xsl_dom = docfac.parse(self.xsl_path)
+        # DOMSource with System Id
+        xsl_source = DOMSource(xsl_dom, self.xsl_path)
+
+        result = transform(xsl_source, src_source)
+        #print result
+        self.assertTrue('world' in result)
+
+    def test_xsl_stream(self):
+        xsl_source = StreamSource(self.xsl_path)
+
+        result = transform(xsl_source, src_source)
+        #print result
+        self.assertTrue('world' in result)
+
+
+if __name__ == '__main__':
+    unittest.main()

tools/jxml/tests/test_lxml.py

@@ -0,0 +1,664 @@
+# -*- coding: utf-8 -*-
+from __future__ import with_statement
+
+import os.path
+import sys
+import unittest
+from unittest import TestCase
+
+from lxml import etree
+from lxml.etree import ElementTree
+from lxml.etree import Element
+from lxml.etree import SubElement
+from lxml.etree import QName
+
+
+class ElementTreeTest(TestCase):
+
+    def test_etree_parse(self):
+        with open('sample.xml') as f:
+            et = etree.parse(f)
+        et = etree.parse('sample.xml')
+
+    def test_etree_fromstring(self):
+        with open('sample.xml') as f:
+            text = f.read()
+        et = etree.fromstring(text)
+
+    def test_etree_from_file(self):
+        with open('sample.xml') as f:
+            et = ElementTree(file=f)
+        root = et.getroot()
+        self.assertEqual('{http://example.tld}document', root.tag)
+        self.assertEqual('x', root.prefix)
+        self.assertTrue('x' in root.nsmap)
+
+        with open('hello.xml') as f:
+            et = ElementTree(file=f)
+        root = et.getroot()
+        self.assertEqual('hello', root.tag)
+        self.assertEqual(None, root.prefix)
+        self.assertEqual({}, root.nsmap)
+
+    def test_etree_tostring(self):
+        with open('sample.xml') as f:
+            et = etree.parse(f)
+        etree.tostring(et, encoding='utf-8', xml_declaration=True)
+        etree.tostring(et.getroot()[0], encoding='utf-8', xml_declaration=True)
+
+    def test_from_element(self):
+        elem = Element('document')
+        tree = ElementTree(elem)
+        self.assertEqual('document', tree.getroot().tag)
+
+        with open('sample.xml') as f:
+            et = ElementTree(file=f)
+        root = et.getroot()
+
+        tree = ElementTree(root)
+        self.assertEqual(root.base, tree.getroot().base)
+        self.assertEqual(et.docinfo.URL, tree.docinfo.URL)
+
+    def test_docinfo(self):
+        with open('sample.xml') as f:
+            et = etree.parse(f)
+        import os.path
+        self.assertEqual(os.path.abspath('sample.xml'), et.docinfo.URL)
+        self.assertEqual('', et.docinfo.doctype)
+        self.assertEqual('utf-8', et.docinfo.encoding)
+        self.assertEqual(None, et.docinfo.externalDTD)
+        self.assertEqual(None, et.docinfo.internalDTD)
+        self.assertEqual(None, et.docinfo.public_id)
+        self.assertEqual('document', et.docinfo.root_name)
+        self.assertFalse(et.docinfo.standalone)
+        self.assertEqual(None, et.docinfo.system_url)
+        self.assertEqual('1.0', et.docinfo.xml_version)
+
+        et.docinfo.URL = 'http://example.tld'
+        self.assertEqual('http://example.tld', et.docinfo.URL)
+
+    def test_parser(self):
+        pass
+
+    def test__copy__(self):
+        pass
+
+    def test__deepcopy__(self):
+        pass
+
+    def test_setroot(self):
+        from lxml.etree import XML
+        a = XML('<a />').getroottree()
+        b = XML('<b />').getroottree()
+        a._setroot(b.getroot())
+        self.assertEqual('b', a.getroot().tag)
+
+    def test_find(self):
+        pass
+
+    def test_findall(self):
+        pass
+
+    def test_findtext(self):
+        pass
+
+    def test_getiterator(self):
+        pass
+
+    def test_getpath(self):
+        pass
+
+    def test_getroot(self):
+        with open('sample.xml') as f:
+            et = etree.parse(f)
+        tree = etree.parse('sample.xml')
+        root = tree.getroot()
+        self.assertEqual('{http://example.tld}document', root.tag)
+
+    def test_iter(self):
+        pass
+
+    def test_iterfind(self):
+        pass
+
+    def test_parse(self):
+        pass
+
+    def test_relaxng(self):
+        pass
+
+    def test_write(self):
+        with open('sample.xml') as f:
+            tree = etree.parse(f)
+
+        import tempfile
+        import os
+        fd, name = tempfile.mkstemp()
+        try:
+            with os.fdopen(fd, 'w') as f:
+                tree.write(f)
+            with open(name) as f:
+                tree2 = etree.parse(f)
+        finally:
+            os.unlink(name)
+        self.assertEqual(tree.getroot().tag, tree2.getroot().tag)
+
+    def test_write_c14n(self):
+        pass
+
+    def test_xinclude(self):
+        pass
+
+    def test_xmlschema(self):
+        pass
+
+    def test_xpath(self):
+        with open('sample.xml') as f:
+            et = etree.parse(f)
+        tree = etree.parse('sample.xml')
+
+        nsmap = dict(x='http://example.tld')
+
+        # element
+        result = tree.xpath('//x:paragraph', namespaces=nsmap)
+        self.assertEqual(1, len(result))
+        self.assertEqual('{http://example.tld}paragraph',
+                          result[0].tag)
+
+        # attribute
+        result = tree.xpath('@version', namespaces=nsmap)
+        self.assertEqual(['1.0'], result)
+
+        # string
+        result = tree.xpath('"foo"', namespaces=nsmap)
+        self.assertEqual('foo', result)
+
+        # number expression
+        result = tree.xpath('1', namespaces=nsmap)
+        self.assertEqual(1.0, result)
+
+        result = tree.xpath('"1.0"', namespaces=nsmap)
+        # should be string, but alas, it returns a number in jxml
+        if sys.platform.startswith('java'):
+            self.assertEqual(1.0, result)
+        else:
+            self.assertEqual('1.0', result)
+
+    def test_xslt(self):
+        tree = etree.XML('<hello />').getroottree()
+        with open('xsl/import-test.xsl') as f:
+            xsl_tree = etree.parse(f)
+        result = tree.xslt(xsl_tree)
+        self.assertEqual('world', result.getroot().tag)
+
+
+class ElementTest(TestCase):
+
+    def setUp(self):
+        with open('sample.xml') as f:
+            self.et = ElementTree(file=f)
+        self.root = self.et.getroot()
+
+    def tearDown(self):
+        pass
+
+    def test_Element(self):
+        elem = Element('document', dict(a='1', b='2'), c='3')
+        self.assertEqual('document', elem.tag)
+        self.assertEqual(dict(a='1', b='2', c='3'),
+                          elem.attrib)
+
+        nsmap = dict(a='http://a.example.tld', c='http://c.example.tld')
+        elem = Element('{http://a.example.tld}document',
+                       {'{http://a.example.tld}a': '1',
+                        '{http://b.example.tld}a': '2',
+                        'a': '3'},
+                       nsmap)
+
+        self.assertEqual('a', elem.prefix)
+        self.assertEqual('{http://a.example.tld}document', elem.tag)
+        self.assertEqual(nsmap['a'], elem.nsmap['a'])
+        self.assertEqual(nsmap['c'], elem.nsmap['c'])
+        self.assertTrue('http://b.example.tld' in elem.nsmap.values())
+        self.assertEqual('1', elem.get('{http://a.example.tld}a'))
+        self.assertEqual('2', elem.get('{http://b.example.tld}a'))
+        self.assertEqual('3', elem.get('a'))
+
+    def test_SubElement(self):
+        elem = Element('document')
+        child = SubElement(elem, 'paragraph')
+        grandchild = SubElement(child, 'span')
+        self.assertEqual('paragraph', elem[0].tag)
+        self.assertEqual('span', elem[0][0].tag)
+
+    def test_base(self):
+        uri = os.path.abspath('sample.xml')
+        with open(uri) as f:
+            et = etree.parse(f)
+        root = et.getroot()
+        self.assertEqual(uri, root.base)
+
+    def test_tag(self):
+        elem = Element('HwpDoc')
+        self.assertEqual('HwpDoc', elem.tag)
+
+        elem = Element('{http://www.w3.org/1999/XSL/Transform}stylesheet')
+        self.assertTrue(elem.prefix)
+        self.assertEqual('{http://www.w3.org/1999/XSL/Transform}stylesheet', elem.tag)
+
+        elem = Element('{http://www.w3.org/1999/XSL/Transform}stylesheet',
+                       nsmap=dict(xsl='http://www.w3.org/1999/XSL/Transform'))
+        self.assertEqual('xsl', elem.prefix)
+        self.assertEqual('{http://www.w3.org/1999/XSL/Transform}stylesheet', elem.tag)
+
+    def test_nsmap(self):
+        self.assertEqual(dict(x='http://example.tld'),
+                          self.root.nsmap)
+        self.assertEqual(dict(x='http://example.tld',
+                               z='http://z.example.tld'),
+                          self.root[1].nsmap)
+
+    def test_prefix(self):
+        self.assertEqual('x', self.root.prefix)
+        self.assertEqual('z', self.root[1].prefix)
+
+    def test_text(self):
+        self.assertEqual('text', self.root[0].text)
+        self.assertEqual(None, self.root[1].text)
+
+    def test_tail(self):
+        self.assertEqual('tail', self.root[0].tail)
+        self.assertEqual(None, self.root[0][0].tail)
+
+    def test_attrib(self):
+        self.assertEqual({'version': '1.0'},
+                          self.root.attrib)
+        self.assertEqual({'a': '1',
+                           '{http://example.tld}b': '2',
+                           '{http://z.example.tld}c': '3'},
+                          self.root[1].attrib)
+
+    def test__contains__(self):
+        pass
+
+    def test__copy__(self):
+        pass
+
+    def test__deepcopy__(self):
+        pass
+
+    def test__delitem__(self):
+        pass
+
+    def test__getitem__(self):
+        paragraph = self.root.__getitem__(0)
+        self.assertEqual('{http://example.tld}paragraph', paragraph.tag)
+        paragraph = self.root[0]
+        self.assertEqual('{http://example.tld}paragraph', paragraph.tag)
+
+        paragraph = self.root.__getitem__(1)
+        self.assertEqual('{http://z.example.tld}object', paragraph.tag)
+        paragraph = self.root[1]
+        self.assertEqual('{http://z.example.tld}object', paragraph.tag)
+
+        child = self.root.__getitem__(-1)
+        self.assertEqual('{http://example.tld}third', child.tag)
+        child = self.root[-1]
+        self.assertEqual('{http://example.tld}third', child.tag)
+
+    def test__iter__(self):
+        it = self.root.__iter__()
+
+        paragraph = it.next()
+        self.assertEqual('{http://example.tld}paragraph',
+                          paragraph.tag)
+        self.assertEqual('text', paragraph.text)
+        self.assertEqual('tail', paragraph.tail)
+
+        paragraph = it.next()
+        self.assertEqual('{http://z.example.tld}object',
+                          paragraph.tag)
+
+        child = it.next()
+        self.assertEqual('{http://example.tld}third',
+                          child.tag)
+
+        self.assertRaises(StopIteration, it.next)
+
+    def test__len__(self):
+        self.assertEqual(3, self.root.__len__())
+        self.assertEqual(3, len(self.root))
+
+    def test__nonzero__(self):
+        pass
+
+    def test__repr__(self):
+        pass
+
+    def test__reversed__(self):
+        it = self.root.__reversed__()
+
+        child = it.next()
+        self.assertEqual('{http://example.tld}third',
+                          child.tag)
+
+        paragraph = it.next()
+        self.assertEqual('{http://z.example.tld}object',
+                          paragraph.tag)
+
+        paragraph = it.next()
+        self.assertEqual('{http://example.tld}paragraph',
+                          paragraph.tag)
+        self.assertEqual('text', paragraph.text)
+        self.assertEqual('tail', paragraph.tail)
+
+        self.assertRaises(StopIteration, it.next)
+
+    def test__setitem__(self):
+        new_child = Element('new-child')
+        self.root.__setitem__(1, new_child)
+        self.assertEqual('new-child', self.root[1].tag)
+
+        new_child = Element('new-child2')
+        self.assertRaises(IndexError, self.root.__setitem__, 3, new_child)
+
+    def test_addnext(self):
+        pass
+
+    def test_addprevious(self):
+        pass
+
+    def test_append(self):
+        new_child = Element('new-child')
+        self.root.append(new_child)
+
+        child = self.root[3]
+        self.assertEqual('new-child', child.tag)
+
+    def test_clear(self):
+        pass
+
+    def test_extend(self):
+        pass
+
+    def test_find(self):
+        pass
+
+    def test_findall(self):
+        pass
+
+    def test_findtext(self):
+        pass
+
+    def test_get(self):
+        self.assertEqual(None, self.root.get('nonexists'))
+        self.assertEqual('1.0', self.root.get('version'))
+        self.assertEqual('1', self.root[1].get('a'))
+        self.assertEqual('2', self.root[1].get('{http://example.tld}b'))
+        self.assertEqual('3', self.root[1].get('{http://z.example.tld}c'))
+
+    def test_getchildren(self):
+        children = self.root.getchildren()
+
+        child = children[0]
+        self.assertEqual('{http://example.tld}paragraph',
+                          child.tag)
+        self.assertEqual('text', child.text)
+        self.assertEqual('tail', child.tail)
+
+        child = children[1]
+        self.assertEqual('{http://z.example.tld}object',
+                          child.tag)
+
+        child = children[2]
+        self.assertEqual('{http://example.tld}third',
+                          child.tag)
+
+    def test_getiterator(self):
+        pass
+
+    def test_getnext(self):
+        child = self.root[0]
+        child = child.getnext()
+        self.assertEqual('{http://z.example.tld}object',
+                          child.tag)
+        child = child.getnext()
+        self.assertEqual('{http://example.tld}third',
+                          child.tag)
+        child = child.getnext()
+        self.assertEqual(None, child)
+
+    def test_getparent(self):
+        parent = self.root.getparent()
+        self.assertEqual(None, parent)
+
+        for child in self.root:
+            parent = child.getparent()
+            self.assertEqual('{http://example.tld}document',
+                              parent.tag)
+
+    def test_getprevious(self):
+        child = self.root[-1]
+        self.assertEqual('{http://example.tld}third',
+                          child.tag)
+        child = child.getprevious()
+        self.assertEqual('{http://z.example.tld}object',
+                          child.tag)
+        child = child.getprevious()
+        self.assertEqual('{http://example.tld}paragraph',
+                          child.tag)
+        child = child.getprevious()
+        self.assertEqual(None, child)
+
+    def test_getroottree(self):
+        elem = Element('HwpDoc')
+        self.assertTrue(elem.getroottree() is not None)
+
+    def test_index(self):
+        pass
+
+    def test_insert(self):
+        pass
+
+    def test_items(self):
+        pass
+
+    def test_iter(self):
+        pass
+
+    def test_iterancestors(self):
+        span = self.root[0][0]
+        it = span.iterancestors()
+
+        parent = it.next()
+        self.assertEqual('{http://example.tld}paragraph',
+                          parent.tag)
+
+        parent = it.next()
+        self.assertEqual('{http://example.tld}document',
+                          parent.tag)
+
+        self.assertRaises(StopIteration, it.next)
+
+        # with tags predicate
+
+        it = span.iterancestors('{http://example.tld}document')
+
+        parent = it.next()
+        self.assertEqual('{http://example.tld}document',
+                          parent.tag)
+
+        self.assertRaises(StopIteration, it.next)
+
+    def test_iterchildren(self):
+        pass
+
+    def test_descendants(self):
+        pass
+
+    def test_iterfind(self):
+        pass
+
+    def test_siblings(self):
+        pass
+
+    def test_itertext(self):
+        pass
+
+    def test_keys(self):
+        self.assertEqual(set(['version']),
+                          set(self.root.keys()))
+        self.assertEqual(set(['a', '{http://example.tld}b',
+                               '{http://z.example.tld}c']),
+                          set(self.root[1].keys()))
+
+    def test_makeelement(self):
+        pass
+
+    def test_remove(self):
+        pass
+
+    def test_replace(self):
+        pass
+
+    def test_set(self):
+        self.root.set('{http://example.tld}a', '1')
+        self.assertEqual('1', self.root.get('{http://example.tld}a'))
+        self.root.set('{http://c.example.tld}a', '2')
+        self.assertEqual('2', self.root.get('{http://c.example.tld}a'))
+        self.root.set('a', '3')
+        self.assertEqual('3', self.root.get('a'))
+
+    def test_values(self):
+        self.root[1].values()
+
+    def test_xpath(self):
+        nsmap = dict(x='http://example.tld')
+
+        # element
+        result = self.root.xpath('//x:paragraph', namespaces=nsmap)
+        self.assertEqual(1, len(result))
+        self.assertEqual('{http://example.tld}paragraph',
+                          result[0].tag)
+
+        # attribute
+        result = self.root.xpath('@version', namespaces=nsmap)
+        self.assertEqual(['1.0'], result)
+
+        # string
+        result = self.root.xpath('"foo"', namespaces=nsmap)
+        self.assertEqual('foo', result)
+
+        # number expression
+        result = self.root.xpath('1', namespaces=nsmap)
+        self.assertEqual(1.0, result)
+
+        result = self.root.xpath('"1.0"', namespaces=nsmap)
+        # should be string, but alas, it returns a number in jxml
+        if sys.platform.startswith('java'):
+            self.assertEqual(1.0, result)
+        else:
+            self.assertEqual('1.0', result)
+
+
+class QNameTest(TestCase):
+
+    text = '{http://example.tld}document'
+    namespace = 'http://example.tld'
+    localname = 'document'
+
+    def test_from_text(self):
+        qname = QName(self.text)
+        self.assertEqual(self.text, qname.text)
+        self.assertEqual(self.namespace, qname.namespace)
+        self.assertEqual(self.localname, qname.localname)
+
+        qname = QName('document')
+        self.assertEqual('document', qname.text)
+        self.assertEqual(None, qname.namespace)
+        self.assertEqual('document', qname.localname)
+
+    def test_from_nsuri_and_tag(self):
+        qname = QName(self.namespace, self.localname)
+        self.assertEqual(self.text, qname.text)
+        self.assertEqual(self.namespace, qname.namespace)
+        self.assertEqual(self.localname, qname.localname)
+
+    def test_from_element(self):
+        element = Element(self.text)
+        qname = QName(element)
+        self.assertEqual(self.text, qname.text)
+        self.assertEqual(self.namespace, qname.namespace)
+        self.assertEqual(self.localname, qname.localname)
+
+
+class XPathTest(TestCase):
+
+    def test_xpath(self):
+        from lxml.etree import parse
+        from lxml.etree import XPath
+        with file('sample.xml') as f:
+            doc = parse(f)
+
+        nsmap = dict(x='http://example.tld')
+
+        # element
+        xpath = XPath('//x:paragraph', namespaces=nsmap)
+        result = xpath(doc)
+        self.assertEqual(1, len(result))
+        self.assertEqual('{http://example.tld}paragraph',
+                          result[0].tag)
+
+        # attribute
+        xpath = XPath('@version', namespaces=nsmap)
+        result = xpath(doc)
+        self.assertEqual(['1.0'], result)
+
+        # string
+        xpath = XPath('"foo"', namespaces=nsmap)
+        result = xpath(doc)
+        self.assertEqual('foo', result)
+
+        # number
+        xpath = XPath('1', namespaces=nsmap)
+        self.assertEqual(1, xpath(doc))
+
+        # string, but alas, it returns a number in jxml
+        xpath = XPath('"1.0"', namespaces=nsmap)
+        result = xpath(doc)
+        if sys.platform.startswith('java'):
+            self.assertEqual(1.0, result)
+        else:
+            self.assertEqual('1.0', result)
+
+        # Boolean
+        xpath = XPath('1 = 1', namespaces=nsmap)
+        self.assertEqual(True, xpath(doc))
+
+
+class XSLTTest(TestCase):
+
+    def test_from_element(self):
+        with open('xsl/import-test.xsl') as f:
+            xsl_tree = etree.parse(f)
+        etree.XSLT(xsl_tree.getroot())
+
+    def test_xslt_with_default_parser(self):
+        with open('xsl/import-test.xsl') as f:
+            xsl_tree = etree.parse(f)
+        transform = etree.XSLT(xsl_tree)
+        result = transform(etree.XML('<hello />'))
+        self.assertEqual('world', result.getroot().tag)
+
+    def test_text_output(self):
+        with open('text-output.xsl') as f:
+            xsl_tree = etree.parse(f)
+        transform = etree.XSLT(xsl_tree)
+        result = transform(etree.XML('<hello/>'))
+        self.assertEqual(None, result.getroot())
+        self.assertEqual(u'world', unicode(result))
+        self.assertEqual('world', str(result))
+
+
+if __name__ == '__main__':
+    unittest.main()

tools/jxml/tests/text-output.xsl

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0"
+  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+  >
+  <xsl:output method="text" encoding="utf-8" indent="no" />
+  <xsl:template match="/hello">world</xsl:template>
+</xsl:stylesheet>

tools/jxml/tests/xsl/import-test.xsl

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0"
+  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+  >
+  <xsl:import href="imported.xsl" />
+  <xsl:output method="xml" encoding="utf-8" indent="no" />
+  <xsl:template match="/">
+    <xsl:apply-templates />
+  </xsl:template>
+</xsl:stylesheet>

tools/jxml/tests/xsl/imported.xsl

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0"
+  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+  >
+  <xsl:output method="xml" encoding="utf-8" indent="no" />
+  <xsl:template match="hello"><world /></xsl:template>
+</xsl:stylesheet>

tools/oxt.tool/oxt_tool/__init__.py

@@ -0,0 +1,405 @@
+# -*- coding: utf-8 -*-
+import logging
+
+
+def console(soffice='soffice'):
+    import uno
+    import unokit.contexts
+    import unokit.services
+    import oxt_tool.remote
+
+    with oxt_tool.remote.new_remote_context(soffice=soffice) as context:
+        desktop = unokit.services.css.frame.Desktop()
+        def new_textdoc():
+            return desktop.loadComponentFromURL('private:factory/swriter',
+                                                '_blank', 0, tuple())
+        from unokit.util import dump, dumpdir
+        local = dict(uno=uno, context=context,
+                     css=unokit.services.css, dump=dump, dumpdir=dumpdir,
+                     desktop=desktop, new_textdoc=new_textdoc)
+        __import__('code').interact(banner='oxt-console', local=local)
+
+
+def dict_to_namedvalue(d):
+    import uno
+    nv = list()
+    for n, v in d.items():
+        if isinstance(v, dict):
+            v = dict_to_namedvalue(v)
+        item = uno.createUnoStruct('com.sun.star.beans.NamedValue')
+        item.Name = n
+        item.Value = v
+        nv.append(item)
+    return tuple(nv)
+
+
+def test_remotely(soffice, discover_dirs, extra_path, logconf_path):
+    import sys
+    import os
+    import os.path
+    import discover
+    import oxt_tool.remote
+
+    logger = logging.getLogger('unokit')
+    logger.addHandler(logging.StreamHandler())
+    logger.setLevel(logging.INFO)
+
+    logfmt = logging.Formatter(('frontend %5d ' % os.getpid())
+                               +'%(message)s')
+    logchn = logging.StreamHandler()
+    logchn.setFormatter(logfmt)
+    logger = logging.getLogger('frontend')
+    logger.addHandler(logchn)
+    logger.setLevel(logging.INFO)
+
+    working_dir = sys.argv[1]
+    working_dir = os.path.abspath(working_dir)
+
+    for path in sys.path:
+        logger.info('sys.path: %s', path)
+
+    if logconf_path:
+        logconf_path = os.path.abspath(logconf_path)
+
+    backend_path = sys.modules['oxt_tool'].__file__
+    backend_path = os.path.dirname(backend_path)
+    backend_path = os.path.join(backend_path, 'backend.py')
+    backend_name = 'backend.TestRunnerJob'
+
+    tss = []
+    for d in discover_dirs:
+        d = os.path.abspath(d)
+        logger.info('discover tests: %s', d)
+        testloader = discover.DiscoveringTestLoader()
+        testsuite = testloader.discover(d)
+        tss.append(testsuite)
+    import unittest
+    testsuite = unittest.TestSuite(tss)
+
+    with oxt_tool.remote.new_remote_context(soffice=soffice) as context:
+        logger.info('remote context created')
+        factory = load_component(backend_path, backend_name)
+        if factory:
+            backendjob = factory.createInstanceWithContext(context)
+            if backendjob:
+                import cPickle
+                from unokit.adapters import OutputStreamToFileLike
+                pickled_testsuite = cPickle.dumps(testsuite)
+                outputstream = OutputStreamToFileLike(sys.stderr)
+                logstream = OutputStreamToFileLike(sys.stderr)
+                args = dict(outputstream=outputstream,
+                            logstream=logstream,
+                            pickled_testsuite=pickled_testsuite,
+                            extra_path=tuple(extra_path),
+                            logconf_path=logconf_path,
+                            working_dir=working_dir)
+                args = dict_to_namedvalue(args)
+                result = backendjob.execute(args)
+                result = str(result)
+                result = cPickle.loads(result)
+                return 0 if result['successful'] else 1
+    return -1
+
+
+def load_component(component_path, component_name):
+    import os
+    import os.path
+    import uno
+    from unokit.services import css
+    loader = css.loader.Python()
+    if loader:
+        component_path = os.path.abspath(component_path)
+        component_url = uno.systemPathToFileUrl(component_path)
+
+        return loader.activate(component_name, '',
+                               component_url, None)
+
+
+def console_in_proc(soffice='soffice'):
+    import os
+    import unohelper
+    from com.sun.star.task import XJob
+    import oxt_tool.remote
+
+    logfmt = logging.Formatter(('frontend %5d ' % os.getpid())
+                               +'%(message)s')
+    logchn = logging.StreamHandler()
+    logchn.setFormatter(logfmt)
+    logger = logging.getLogger('frontend')
+    logger.addHandler(logchn)
+    logger.setLevel(logging.INFO)
+
+    class ConsoleInput(unohelper.Base, XJob):
+
+        def __init__(self, context):
+            self.context = context
+
+        def execute(self, arguments):
+            prompt, = arguments
+            try:
+                return raw_input(prompt.Value)
+            except EOFError:
+                return None
+
+    import sys
+    import os.path
+    backend_path = sys.modules['oxt_tool'].__file__
+    backend_path = os.path.dirname(backend_path)
+    backend_path = os.path.join(backend_path, 'backend.py')
+    backend_name = 'backend.ConsoleJob'
+
+    with oxt_tool.remote.new_remote_context(soffice=soffice) as context:
+        logger.info('remote context created')
+        factory = load_component(backend_path, backend_name)
+        if factory:
+            backendjob = factory.createInstanceWithContext(context)
+            if backendjob:
+                from unokit.adapters import OutputStreamToFileLike
+                outstream = OutputStreamToFileLike(sys.stderr)
+                args = dict(inp=ConsoleInput(context),
+                            outstream=outstream)
+                args = dict_to_namedvalue(args)
+                backendjob.execute(args)
+
+
+class LoEnviron(object):
+
+    def __init__(self, program_dir):
+        self.program_dir = program_dir
+
+    @property
+    def rc_ext(self):
+        import sys
+        if sys.platform == 'win32':
+            return '.ini'
+        else:
+            return 'rc'
+
+
+    @property
+    def fundamentalrc(self):
+        import os.path
+        filename = 'fundamental' + self.rc_ext
+        return os.path.join(self.program_dir, filename)
+
+
+    @property
+    def ure_bootstrap(self):
+        return 'vnd.sun.star.pathname:' + self.fundamentalrc
+
+
+def run_in_lo(soffice='soffice'):
+    import os
+    import sys
+    import os.path
+
+    uno_pythonpath = os.environ['UNO_PYTHONPATH'].split(os.pathsep)
+    sys.path.extend(uno_pythonpath)
+
+    loenv = LoEnviron(os.environ['LO_PROGRAM'])
+    os.environ['URE_BOOTSTRAP'] = loenv.ure_bootstrap
+
+    import oxt_tool.remote
+
+    logger = logging.getLogger('unokit')
+    logger.addHandler(logging.StreamHandler())
+    logger.setLevel(logging.INFO)
+
+    logger = logging.getLogger('oxt_tool')
+    logger.addHandler(logging.StreamHandler())
+    logger.setLevel(logging.INFO)
+
+    logfmt = logging.Formatter(('frontend %5d ' % os.getpid())
+                               +'%(message)s')
+    logchn = logging.StreamHandler()
+    logchn.setFormatter(logfmt)
+    logger = logging.getLogger('frontend')
+    logger.addHandler(logchn)
+    logger.setLevel(logging.INFO)
+
+    for path in sys.path:
+        logger.info('sys.path: %s', path)
+
+    working_dir = os.getcwd()
+    working_dir = os.path.abspath(working_dir)
+    argv = list(sys.argv[1:])
+
+    if argv[0].startswith('--logfile='):
+        logfile = argv[0][len('--logfile='):]
+        argv = argv[1:]
+    else:
+        logfile = None
+    argv[0] = os.path.abspath(argv[0])
+    print argv
+
+    backend_path = sys.modules['oxt_tool'].__file__
+    backend_path = os.path.dirname(backend_path)
+    backend_path = os.path.join(backend_path, 'backend.py')
+    backend_name = 'backend.RemoteRunJob'
+
+    with oxt_tool.remote.new_remote_context(soffice=soffice) as context:
+        logger.info('remote context created')
+        factory = load_component(backend_path, backend_name)
+        if factory:
+            backendjob = factory.createInstanceWithContext(context)
+            if backendjob:
+                import cPickle
+                from unokit.adapters import OutputStreamToFileLike
+                from unokit.adapters import InputStreamFromFileLike
+                stdin = InputStreamFromFileLike(sys.stdin)
+                stdout = OutputStreamToFileLike(sys.stdout)
+                stderr = OutputStreamToFileLike(sys.stderr)
+                path = cPickle.dumps(sys.path)
+                argv = cPickle.dumps(argv)
+                args = dict(logfile=logfile,
+                            working_dir=working_dir,
+                            path=path,
+                            argv=argv,
+                            stdin=stdin,
+                            stdout=stdout,
+                            stderr=stderr)
+                args = dict_to_namedvalue(args)
+                return backendjob.execute(args)
+    return -1
+
+
+def install(unopkg='unopkg'):
+    import sys
+    cmd = [unopkg, 'add', '-v', '-s']
+    cmd.extend(sys.argv[1:])
+    cmd = [('"%s"' % x) if ' ' not in x else x
+            for x in cmd]
+    cmd = ' '.join(cmd)
+    import os
+    return os.system(cmd)
+
+
+class Console(object):
+    def __init__(self, buildout, name, options):
+        import os.path
+        self.__name = name
+        self.__logger = logging.getLogger(name)
+        self.__bindir = buildout['buildout']['bin-directory']
+
+        soffice = options.get('soffice', 'soffice').strip()
+        if not os.path.exists(soffice):
+            self.__skip = True
+            self.__logger.info('soffice not found at: %s', soffice)
+            self.__logger.info('installation will be skipped')
+            return
+
+        in_proc = options.get('in_proc', 'true').strip().lower()
+        in_proc = in_proc in ['true', 'yes', '1']
+
+        self.__python = options.get('python', '').strip()
+        self.__soffice = soffice
+        self.__in_proc = in_proc
+        self.__skip = False
+
+    def install(self):
+        if self.__skip:
+            self.__logger.info('skipped')
+            return []
+
+        from zc.buildout import easy_install
+        import pkg_resources
+        import sys
+        ws = [pkg_resources.get_distribution(dist)
+              for dist in ['unokit', 'oxt.tool']]
+        if self.__in_proc:
+            func = 'console_in_proc'
+        else:
+            func = 'console'
+        entrypoints = [(self.__name, 'oxt_tool', func)]
+        arguments = '%r' % self.__soffice
+        if self.__python:
+            python = self.__python
+        else:
+            python = sys.executable
+        return easy_install.scripts(entrypoints,
+                                    ws, python, self.__bindir,
+                                    arguments=arguments)
+
+    update = install
+
+
+class TestRunner(object):
+    def __init__(self, buildout, name, options):
+        import os.path
+        self.__name = name
+        self.__logger = logging.getLogger(name)
+        self.__bindir = buildout['buildout']['bin-directory']
+        self.__skip = False
+        self.__python = options.get('python', '').strip()
+
+        self.__soffice = options.get('soffice', 'soffice').strip()
+        if not os.path.exists(self.__soffice):
+            self.__skip = True
+            self.__logger.info('soffice not found at: %s', self.__soffice)
+            self.__logger.info('installation will be skipped')
+            return
+        self.__discover = options['discover'].split()
+        self.__extra_path = options['extra_path'].split()
+        self.__logconf_path = options.get('logconf_path')
+
+    def install(self):
+        if self.__skip:
+            self.__logger.info('skipped')
+            return []
+
+        from zc.buildout import easy_install
+        import pkg_resources
+        import sys
+        ws = [pkg_resources.get_distribution(dist)
+              for dist in ['unokit', 'oxt.tool', 'discover']]
+        entrypoints = [(self.__name, 'oxt_tool', 'test_remotely')]
+        arguments = '%r, %r, %r, %r'
+        arguments = arguments % (self.__soffice,
+                                 self.__discover,
+                                 self.__extra_path,
+                                 self.__logconf_path)
+        if self.__python:
+            python = self.__python
+        else:
+            python = sys.executable
+        return easy_install.scripts(entrypoints,
+                                    ws, python, self.__bindir,
+                                    arguments=arguments)
+
+    update = install
+
+
+class Installer(object):
+    def __init__(self, buildout, name, options):
+        import os.path
+        self.__name = name
+        self.__logger = logging.getLogger(name)
+        self.__bindir = buildout['buildout']['bin-directory']
+
+        unopkg = options.get('unopkg', 'unopkg').strip()
+        if not os.path.exists(unopkg):
+            self.__skip = True
+            self.__logger.info('unopkg not found at: %s', unopkg)
+            self.__logger.info('installation will be skipped')
+            return
+
+        self.__unopkg = unopkg
+        self.__skip = False
+
+    def install(self):
+        if self.__skip:
+            self.__logger.info('skipped')
+            return []
+
+        from zc.buildout import easy_install
+        import pkg_resources
+        import sys
+        ws = [pkg_resources.get_distribution(dist)
+              for dist in ['unokit', 'oxt.tool']]
+        entrypoints = [(self.__name, 'oxt_tool', 'install')]
+        arguments = '%r' % self.__unopkg
+        return easy_install.scripts(entrypoints,
+                                    ws, sys.executable, self.__bindir,
+                                    arguments=arguments)
+
+    update = install

tools/oxt.tool/oxt_tool/backend.py

@@ -0,0 +1,361 @@
+# -*- coding: utf-8 -*-
+import logging
+import sys
+import os
+
+logfmt = logging.Formatter((' backend %5d ' % os.getpid())
+                           +'%(message)s')
+logger = logging.getLogger('backend')
+logger.setLevel(logging.INFO)
+
+
+logger.info('backend: %s', os.getpid())
+logger.info('sys.executable = %s', sys.executable)
+
+import unohelper
+g_ImplementationHelper = unohelper.ImplementationHelper()
+
+def implementation(component_name, *services):
+    def decorator(cls):
+        g_ImplementationHelper.addImplementation(cls, component_name, services)
+        return cls
+    return decorator
+
+
+from com.sun.star.task import XJob
+
+@implementation('backend.TestRunnerJob')
+class TestRunnerJob(unohelper.Base, XJob):
+
+    def __init__(self, context):
+        self.context = context
+
+    def execute(self, arguments):
+        import sys
+        args = dict((nv.Name, nv.Value) for nv in arguments)
+
+        cwd = os.getcwd()
+        working_dir = args['working_dir']
+        os.chdir(working_dir)
+        try:
+            logstream = args['logstream']
+            logstream = FileFromStream(logstream)
+            loghandler = logging.StreamHandler(logstream)
+            loghandler.setFormatter(logfmt)
+            logger.addHandler(loghandler)
+            try:
+                logger.info('current dir: %s', cwd)
+                logger.info('working dir: %s', working_dir)
+                logger.info('sys.path:')
+                for x in sys.path:
+                    logger.info('- %s', x)
+                return self.run(args)
+            finally:
+                logger.removeHandler(loghandler)
+        finally:
+            os.chdir(cwd)
+
+    def run(self, args):
+        import cPickle
+        outstream = args.get('outputstream')
+        outstream = FileFromStream(outstream)
+
+        extra_path = args.get('extra_path')
+        if extra_path:
+            logger.info('extra_path: %s', ' '.join(extra_path))
+            sys.path.extend(extra_path)
+
+        logconf_path = args.get('logconf_path')
+        if logconf_path:
+            import logging.config
+            logging.config.fileConfig(logconf_path)
+
+        from hwp5.plat import _uno
+        _uno.enable()
+
+        pickled_testsuite = args.get('pickled_testsuite')
+        if not pickled_testsuite:
+            logger.error('pickled_testsuite is required')
+            return cPickle.dumps(dict(successful=False, tests=0, failures=0,
+                                      errors=0))
+
+        pickled_testsuite = str(pickled_testsuite)
+        testsuite = cPickle.loads(pickled_testsuite)
+        logger.info('Test Suite Unpickled')
+
+        from unittest import TextTestRunner
+        testrunner = TextTestRunner(stream=outstream)
+        result = testrunner.run(testsuite)
+        result = dict(successful=result.wasSuccessful(),
+                      tests=result.testsRun,
+                      failures=list(str(x) for x in result.failures),
+                      errors=list(str(x) for x in result.errors))
+        return cPickle.dumps(result)
+
+
+import contextlib
+
+
+@contextlib.contextmanager
+def sandbox(working_dir, **kwargs):
+    import os
+    import sys
+
+    backup = dict()
+    class NOTHING:
+        pass
+    if not hasattr(sys, 'argv'):
+        sys.argv = NOTHING
+
+    NAMES = ['path', 'argv', 'stdin', 'stdout', 'stderr']
+    for x in NAMES:
+        assert x in kwargs
+
+    backup['cwd'] = os.getcwd()
+    os.chdir(working_dir)
+    for x in NAMES:
+        backup[x] = getattr(sys, x)
+        setattr(sys, x, kwargs[x])
+
+    try:
+        yield
+    finally:
+        for x in NAMES:
+            setattr(sys, x, backup[x])
+        os.chdir(backup['cwd'])
+
+        if sys.argv is NOTHING:
+            del sys.argv
+
+
+@implementation('backend.RemoteRunJob')
+class RemoteRunJob(unohelper.Base, XJob):
+
+    def __init__(self, context):
+        self.context = context
+
+    def execute(self, arguments):
+        args = dict((nv.Name, nv.Value) for nv in arguments)
+
+        logpath = args.get('logfile')
+        if logpath is not None:
+            logfile = file(logpath, 'a')
+            loghandler = logging.StreamHandler(logfile)
+            logger.addHandler(loghandler)
+
+        import datetime
+        logger.info('-'*10 + (' start at %s' % datetime.datetime.now()) + '-'*10)
+        try:
+            return self.run(args)
+        finally:
+            logger.info('-'*10 + (' stop at %s' % datetime.datetime.now()) + '-'*10)
+            if logpath is not None:
+                logger.removeHandler(loghandler)
+
+    def run(self, args):
+        import cPickle
+
+        working_dir = args['working_dir']
+        path = cPickle.loads(str(args['path']))
+        argv = cPickle.loads(str(args['argv']))
+        stdin = FileFromStream(args['stdin'])
+        stdout = FileFromStream(args['stdout'])
+        stderr = FileFromStream(args['stderr'])
+
+        script = argv[0]
+        with sandbox(working_dir, path=path, argv=argv, stdin=stdin,
+                     stdout=stdout, stderr=stderr):
+            g = dict(__name__='__main__')
+            try:
+                execfile(script, g)
+            except SystemExit, e:
+                return e.code
+            except Exception, e:
+                logger.exception(e)
+                raise
+            except:
+                import traceback
+                logger.error('%s' % traceback.format_exc())
+                raise
+
+
+@implementation('backend.ConsoleJob')
+class ConsoleJob(unohelper.Base, XJob):
+
+    def __init__(self, context):
+        self.context = context
+
+    def execute(self, arguments):
+        args = dict((nv.Name, nv.Value) for nv in arguments)
+
+        cwd = os.getcwd()
+        try:
+            inp = args['inp']
+            outstream = args['outstream']
+
+            outfile = FileFromStream(outstream)
+
+            import sys
+            orig = sys.stdout, sys.stderr
+            sys.stdout = sys.stderr = outfile
+            try:
+                console = Console(inp, outfile)
+                try:
+                    console.interact('LibreOffice Python Console (pid: %s)' %
+                                     os.getpid())
+                    return 0
+                except SystemExit, e:
+                    return e.code
+            finally:
+                sys.stdout, sys.stderr = orig
+        finally:
+            os.chdir(cwd)
+
+
+from code import InteractiveConsole
+class Console(InteractiveConsole):
+
+    def __init__(self, inp, outfile):
+        InteractiveConsole.__init__(self)
+        self.inp = inp
+        self.outfile = outfile
+
+    def write(self, data):
+        self.outfile.write(data)
+        self.outfile.flush()
+
+    def raw_input(self, prompt=''):
+        import uno
+        arg = uno.createUnoStruct('com.sun.star.beans.NamedValue')
+        arg.Name = 'prompt'
+        arg.Value = prompt
+        args = arg,
+        result = self.inp.execute(args)
+        if result is None:
+            raise EOFError()
+        return result
+
+
+class FileFromStream(object):
+    ''' A file-like object based on XInputStream/XOuputStream/XSeekable
+
+    :param stream: a stream object which implements
+    com.sun.star.io.XInputStream, com.sun.star.io.XOutputStream or
+    com.sun.star.io.XSeekable
+    '''
+    def __init__(self, stream, encoding='utf-8'):
+        import uno
+        self.stream = stream
+        self.encoding = encoding
+
+        if hasattr(stream, 'readBytes'):
+            def read(size=None):
+                if size is None:
+                    data = ''
+                    while True:
+                        bytes = uno.ByteSequence('')
+                        n_read, bytes = stream.readBytes(bytes, 4096)
+                        if n_read == 0:
+                            return data
+                        data += bytes.value
+                bytes = uno.ByteSequence('')
+                n_read, bytes = stream.readBytes(bytes, size)
+                return bytes.value
+            self.read = read
+
+        if hasattr(stream, 'seek'):
+            self.tell = stream.getPosition
+
+            def seek(offset, whence=0):
+                if whence == 0:
+                    pass
+                elif whence == 1:
+                    offset += stream.getPosition()
+                elif whence == 2:
+                    offset += stream.getLength()
+                stream.seek(offset)
+            self.seek = seek
+
+        if hasattr(stream, 'writeBytes'):
+            def write(s):
+                if isinstance(s, unicode):
+                    s = s.encode(self.encoding)
+                stream.writeBytes(uno.ByteSequence(s))
+            self.write = write
+
+            def flush():
+                stream.flush()
+            self.flush = flush
+
+    def close(self):
+        if hasattr(self.stream, 'closeInput'):
+            self.stream.closeInput()
+        elif hasattr(self.stream, 'closeOutput'):
+            self.stream.closeOutput()
+
+
+'''
+import os.path
+from uno import systemPathToFileUrl
+from unokit.ucb import open_url
+from unokit.services import css
+
+path = os.path.abspath('samples/sample-5017.hwp')
+print path
+url = systemPathToFileUrl(path)
+print url
+inp = open_url(url)
+print inp
+
+# 여기서 segfault
+stg = css.embed.OLESimpleStorage(inp)
+print stg
+'''
+
+
+'''
+SegFault가 나는 stacktrace는 다음과 같다
+
+StgDirEntry::StgDirEntry
+    sot/source/sdstor/
+StgEntry::Load
+    sot/source/sdstor/
+ToUpperUnicode
+    sot/source/sdstor/stgelem.cxx
+CharClass
+    unotools/source/i18n/charclass.cxx
+intl_createInstance
+    unotools/source/i18n/instance.hxx
+
+여기서 ::comphelper::getProcessServiceFactory로 얻은 XMultiServiceFactory가
+null 값인 것 같다.
+
+----
+
+uno를 사용하는 프로그램들 (desktop app/unopkg, 각종 unittest 프로그램)은
+처음 실행 시 다음과 같은 과정을 거치는 듯 하다.
+
+1. ::cppu::defaultBootstrap_InitialComponentContext()을 호출, local context 생성
+   - unorc 등을 검색, application.rdb, user.rdb 등에 접근
+
+   - pyuno.so 의 getComponentContext()에서 수행: PYUNOLIBDIR 즉 pyuno.so가 있는
+     디렉토리에서 pyuno.rc가 있으면 그것으로 초기화)
+   - desktop app: appinit.cxx의 CreateApplicationServiceManager()에서 수행
+   - unopkg: unopkg_misc.cxx의 bootstrapStandAlone()에서 수행.
+     ucbhelper::ContentBroker도 함께 초기화한다.
+
+2. 이렇게 생성한 local context로부터 ServiceManager를 얻어
+   ::comphelper::setProcessServiceFactory()를 사용하여 프로세스 전역 service
+   factory로 등록
+
+   - uno.py와 pyuno.so는 이 작업을 하지 않는다.
+   - desktop app: app.cxx의 ensureProcessServiceFactory()에서 수행
+   - unopkg: unopkg_misc.cxx의 bootstrapStandAlone()에서 함께 수행.
+
+
+* desktop app: desktop/source/app/
+* unopkg: desktop/source/pkgchk/unopkg/
+
+'''
+
+logger.info('%s: end of file', __name__)

tools/oxt.tool/oxt_tool/description.py

@@ -0,0 +1,379 @@
+# -*- coding: utf-8 -*-
+from __future__ import with_statement
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+NS_URI = 'http://openoffice.org/extensions/description/2006'
+NS_URI_DEP = 'http://openoffice.org/extensions/description/2006'
+NS_URI_XLINK = 'http://www.w3.org/1999/xlink'
+
+NS = '{' + NS_URI + '}'
+NS_DEP = '{' + NS_URI_DEP + '}'
+NS_XLINK = '{' + NS_URI_XLINK + '}'
+
+
+def as_dict(f):
+    def wrapper(*args, **kwargs):
+        return dict(f(*args, **kwargs))
+    wrapper.items = f
+    return wrapper
+
+
+@as_dict
+def get_display_name(doc):
+    root = doc.getroot()
+    for elt in root.findall(NS + 'display-name/' + NS + 'name'):
+        yield elt.get('lang'), elt.text
+
+
+def set_display_name(doc, display_name):
+    import xml.etree.ElementTree as ET
+    root = doc.getroot()
+    dispname = ET.SubElement(root, 'display-name')
+    for lang, name in display_name.items():
+        elt = ET.SubElement(dispname, 'name')
+        elt.set('lang', lang)
+        elt.text = name
+
+
+@as_dict
+def get_extension_description(doc):
+    root = doc.getroot()
+    for elt in root.findall(NS + 'extension-description/' + NS + 'src'):
+        yield elt.get('lang'), elt.get(NS_XLINK + 'href')
+
+
+def set_extension_description(doc, description):
+    import xml.etree.ElementTree as ET
+    root = doc.getroot()
+    desc = ET.SubElement(root, 'extension-description')
+    for lang, url in description.items():
+        elt = ET.SubElement(desc, 'src')
+        elt.set('lang', lang)
+        elt.set('xlink:href', url)
+
+
+@as_dict
+def get_publisher(doc):
+    root = doc.getroot()
+    for elt in root.findall(NS + 'publisher/' + NS + 'name'):
+        yield elt.get('lang'), dict(name=elt.text,
+                                    url=elt.get(NS_XLINK + 'href'))
+
+
+def set_publisher(doc, publisher):
+    import xml.etree.ElementTree as ET
+    root = doc.getroot()
+    pub = ET.SubElement(root, 'publisher')
+    for lang, dct in publisher.items():
+        elt = ET.SubElement(pub, 'name')
+        elt.set('lang', lang)
+        elt.set('xlink:href', dct['url'])
+        elt.text = dct['name']
+
+
+def get_license_accept_by(doc):
+    root = doc.getroot()
+    for elt in root.findall(NS + 'registration/' + NS + 'simple-license'):
+        accept_by = elt.get('accept-by')
+        if accept_by:
+            return accept_by
+
+
+def get_license(doc):
+    root = doc.getroot()
+    for elt in root.findall(NS + 'registration/' + NS + 'simple-license'):
+        return dict((elt.get('lang'), elt.get(NS_XLINK + 'href'))
+                    for elt in elt.findall(NS + 'license-text'))
+    return dict()
+
+
+def get_oo_min_version(doc):
+    root = doc.getroot()
+    for dep in root.findall(NS + 'dependencies'):
+        for elt in dep.findall(NS + 'OpenOffice.org-minimal-version'):
+            return elt.get('value')
+
+
+class Description(object):
+
+    @classmethod
+    def parse(cls, f):
+        import xml.etree.ElementTree as ET
+
+        doc = ET.parse(f)
+        root = doc.getroot()
+
+        def getvalue(xpath, default=None):
+            for elt in root.findall(xpath):
+                value = elt.get('value', default)
+                if value:
+                    return value
+            return default
+
+        return cls(identifier=getvalue(NS + 'identifier'),
+                   version=getvalue(NS + 'version'),
+                   platform=getvalue(NS + 'platform', 'all'),
+                   display_name=get_display_name(doc),
+                   description=get_extension_description(doc),
+                   publisher=get_publisher(doc),
+                   license_accept_by=get_license_accept_by(doc),
+                   license=get_license(doc),
+                   oo_min_version=get_oo_min_version(doc))
+
+    def __init__(self,
+                 identifier='noname',
+                 version='0.0',
+                 platform='all',
+                 display_name=dict(),
+                 description=dict(),
+                 publisher=dict(),
+                 license_accept_by='admin',
+                 license=dict(),
+                 oo_min_version=None):
+        ''' Generate description.xml
+
+        :param f: output file
+        :param identifier: extension identifier
+        :param version: extension version
+        :param platform: target platform
+        :param display_name: localizations of display name
+        :param description: localizations of extension description
+        :param publisher: localizations of publisher
+        :param license_accept_by: who is supposed to accept the license
+        :param license: localization of license
+        :param oo_min_version: minimal version of LibreOffice
+
+        Each localization parameters are dicts, whose keys are language identifiers
+        defined in RFC 3066.
+
+        ``identifier`` specifies `Extension Identifier
+        <http://wiki.openoffice.org/wiki/Documentation/DevGuide/Extensions/Extension_Identifiers>`_.
+
+        ``version`` specifies `Extension Version
+        <http://wiki.openoffice.org/wiki/Documentation/DevGuide/Extensions/Extension_Versions>`_.
+
+        ``platform`` specifies supposed `Target Platform
+        <http://wiki.openoffice.org/wiki/Documentation/DevGuide/Extensions/Target_Platform>`_  on which this extension
+        runs. Default value is ``all``.
+
+        ``display_name`` specifies localized `Display Names
+        <http://wiki.openoffice.org/wiki/Documentation/DevGuide/Extensions/Display_Name>`_.
+        It's a localization dict whose values are localized unicode strings, e.g.::
+
+            display_name = {
+                'en': 'Example Filter',
+                'ko': u'예제 필터'
+            }
+
+        Values of ``description`` is a URL of description file, e.g.::
+
+            description = {
+                'en': 'description/en.txt',
+                'ko': 'description/ko.txt'
+            }
+
+        ``publisher`` specifies `Publisher Information
+        <http://wiki.openoffice.org/wiki/Documentation/DevGuide/Extensions/Publisher_Information>`_.
+        It's a localization dict whose values are dicts themselves, which have
+        ``name`` and ``url``.  ``name`` is a localized name of the publisher and
+        ``url`` is a URL of the publisher. For example::
+
+            publisher = {
+                'en': {
+                    'name': 'John Doe',
+                    'url': 'http://example.tld'
+                },
+                'ko': {
+                    'name': u'홍길동',
+                    'url': 'http://example.tld'
+                }
+            }
+
+        Optional ``license_accept_by`` specifies who is supposed to accept the
+        license. ``admin`` or ``user``. Default value is 'admin'.
+
+        Optional ``license`` is a localization dict whose values are an URL of
+        license file. For example::
+
+            license = {
+                'en': 'registration/COPYING'
+            }
+
+        See `Simple License
+        <http://wiki.openoffice.org/wiki/Documentation/DevGuide/Extensions/Simple_License>`_.
+        '''
+        self.identifier = identifier
+        self.version = version
+        self.platform = platform
+        self.display_name = display_name
+        self.description = description
+        self.publisher = publisher
+        self.license_accept_by = license_accept_by
+        self.license = license
+        self.oo_min_version = oo_min_version
+
+    def write(self, f):
+
+        # see http://wiki.openoffice.org/wiki/Documentation/DevGuide/Extensions/Description_of_XML_Elements
+
+        import xml.etree.ElementTree as ET
+
+        root = ET.Element('description', {'xmlns': NS_URI,
+                                          'xmlns:dep': NS_URI_DEP,
+                                          'xmlns:xlink': NS_URI_XLINK})
+        doc = ET.ElementTree(root)
+
+        ET.SubElement(root, 'identifier').set('value', self.identifier)
+        ET.SubElement(root, 'version').set('value', self.version)
+        ET.SubElement(root, 'platform').set('value', self.platform)
+
+        set_display_name(doc, self.display_name)
+
+        set_extension_description(doc, self.description)
+
+        set_publisher(doc, self.publisher)
+
+        if self.license:
+            reg = ET.SubElement(root, 'registration')
+            lic = ET.SubElement(reg, 'simple-license')
+            lic.set('accept-by', self.license_accept_by)
+            for lang, url in self.license.items():
+                elt = ET.SubElement(lic, 'license-text')
+                elt.set('lang', lang)
+                elt.set('xlink:href', url)
+
+        if self.oo_min_version is not None:
+            dep = ET.SubElement(root, 'dependencies')
+            minver = ET.SubElement(dep, 'OpenOffice.org-minimal-version')
+            minver.set('dep:name', 'LibreOffice ' + self.oo_min_version)
+            minver.set('value', self.oo_min_version)
+
+        f.write('<?xml version="1.0" encoding="utf-8"?>')
+        doc.write(f, encoding='utf-8')
+
+    def required_files(self):
+        for url in self.description.values():
+            yield url
+        for url in self.license.values():
+            yield url
+
+
+def print_human_readable(desc, root_stg=None):
+    ''' Print summary in human readable form.
+
+    :param desc: an instance of Description
+    :param root_stg: root storage of description.xml
+    '''
+    from storage import resolve_path
+    print 'identifier:', desc.identifier
+    print 'version:', desc.version
+    print 'platform:', desc.platform
+
+    print 'display-name:'
+    for lang, name in desc.display_name.items():
+        print '  [%s] %s' % (lang, name)
+
+    print 'extension-description:'
+    for lang, url in desc.description.items():
+        if not root_stg or resolve_path(root_stg, url):
+            state = ''
+        else:
+            state = ' -- MISSING'
+        print '  [%s] %s%s' % (lang, url, state)
+
+    print 'publisher:'
+    for lang, publisher in desc.publisher.items():
+        print '  [%s] %s (%s)' % (lang,
+                                       publisher['name'],
+                                       publisher['url'])
+    if desc.license:
+        print 'license: accept-by', desc.license_accept_by
+        for lang, url in desc.license.items():
+            if not root_stg or resolve_path(root_stg, url):
+                state = ''
+            else:
+                state = ' -- MISSING'
+            print '  [%s] %s%s' % (lang, url, state)
+
+    if desc.oo_min_version:
+        print 'dependencies:'
+        print '  LibreOffice minimal version:', desc.oo_min_version
+
+
+def init_main():
+    doc = '''Usage: oxt-desc-init [options] <desc-file>
+
+    --help      Print this screen.
+    '''
+
+    from docopt import docopt
+    args = docopt(doc)
+    logging.basicConfig(level=logging.INFO)
+
+    description = Description(identifier='tld.example',
+                              version='0.1',
+                              display_name=dict(en='Example extension'),
+                              publisher=dict(en=dict(name='Publisher Name',
+                                                     url='http://example.tld')),
+                              license=dict(url=dict(en='COPYING')),
+                              description=dict(en='description/en.txt'))
+    with file(args['<desc-file>'], 'w') as f:
+        description.write(f)
+
+
+def show_main():
+    doc = '''Usage: oxt-desc-show [options] <desc-file>
+
+    --help      Show this screen.
+    '''
+    from docopt import docopt
+    args = docopt(doc)
+    logging.basicConfig(level=logging.INFO)
+
+    with file(args['<desc-file>']) as f:
+        desc = Description.parse(f)
+
+    print_human_readable(desc)
+
+
+def version_main():
+    doc = '''Usage: oxt-desc-version [options] <desc-file> [<new-version>]
+
+    --help      Show this screen.
+    '''
+    from docopt import docopt
+    args = docopt(doc)
+    logging.basicConfig(level=logging.INFO)
+
+    with file(args['<desc-file>'], 'r') as f:
+        desc = Description.parse(f)
+
+    new_version = args['<new-version>']
+    if new_version is not None:
+        logger.info('old: %s', desc.version)
+        desc.version = new_version
+        logger.info('new: %s', desc.version)
+        with file(args['<desc-file>'], 'w') as f:
+            desc.write(f)
+    else:
+        print desc.version
+
+
+def ls_main():
+    doc = '''Usage: oxt-desc-ls [options] <desc-file>
+
+    --help      Show this screen.
+    '''
+    from docopt import docopt
+    args = docopt(doc)
+    logging.basicConfig(level=logging.INFO)
+
+    with file(args['<desc-file>']) as f:
+        desc = Description.parse(f)
+
+    for path in desc.required_files():
+        print path