*: kill all unnecessary shebangs.

contrib/setup3k.py

@@ -1,374 +1,373 b''
-#!/usr/bin/env python
 #
 # This is an experimental py3k-enabled mercurial setup script.
 #
 # 'python setup.py install', or
 # 'python setup.py --help' for more options
 
 from distutils.command.build_py import build_py_2to3
 from lib2to3.refactor import get_fixers_from_package as getfixers
 
 import sys
 if not hasattr(sys, 'version_info') or sys.version_info < (2, 4, 0, 'final'):
     raise SystemExit("Mercurial requires Python 2.4 or later.")
 
 if sys.version_info[0] >= 3:
     def b(s):
         '''A helper function to emulate 2.6+ bytes literals using string
         literals.'''
         return s.encode('latin1')
 else:
     def b(s):
         '''A helper function to emulate 2.6+ bytes literals using string
         literals.'''
         return s
 
 # Solaris Python packaging brain damage
 try:
     import hashlib
     sha = hashlib.sha1()
 except:
     try:
         import sha
     except:
         raise SystemExit(
             "Couldn't import standard hashlib (incomplete Python install).")
 
 try:
     import zlib
 except:
     raise SystemExit(
         "Couldn't import standard zlib (incomplete Python install).")
 
 try:
     import bz2
 except:
     raise SystemExit(
         "Couldn't import standard bz2 (incomplete Python install).")
 
 import os, subprocess, time
 import shutil
 import tempfile
 from distutils import log
 from distutils.core import setup, Extension
 from distutils.dist import Distribution
 from distutils.command.build import build
 from distutils.command.build_ext import build_ext
 from distutils.command.build_py import build_py
 from distutils.spawn import spawn, find_executable
 from distutils.ccompiler import new_compiler
 from distutils.errors import CCompilerError
 
 scripts = ['hg']
 if os.name == 'nt':
     scripts.append('contrib/win32/hg.bat')
 
 # simplified version of distutils.ccompiler.CCompiler.has_function
 # that actually removes its temporary files.
 def hasfunction(cc, funcname):
     tmpdir = tempfile.mkdtemp(prefix='hg-install-')
     devnull = oldstderr = None
     try:
         try:
             fname = os.path.join(tmpdir, 'funcname.c')
             f = open(fname, 'w')
             f.write('int main(void) {\n')
             f.write('    %s();\n' % funcname)
             f.write('}\n')
             f.close()
             # Redirect stderr to /dev/null to hide any error messages
             # from the compiler.
             # This will have to be changed if we ever have to check
             # for a function on Windows.
             devnull = open('/dev/null', 'w')
             oldstderr = os.dup(sys.stderr.fileno())
             os.dup2(devnull.fileno(), sys.stderr.fileno())
             objects = cc.compile([fname], output_dir=tmpdir)
             cc.link_executable(objects, os.path.join(tmpdir, "a.out"))
         except:
             return False
         return True
     finally:
         if oldstderr is not None:
             os.dup2(oldstderr, sys.stderr.fileno())
         if devnull is not None:
             devnull.close()
         shutil.rmtree(tmpdir)
 
 # py2exe needs to be installed to work
 try:
     import py2exe
     py2exeloaded = True
 
     # Help py2exe to find win32com.shell
     try:
         import modulefinder
         import win32com
         for p in win32com.__path__[1:]: # Take the path to win32comext
             modulefinder.AddPackagePath("win32com", p)
         pn = "win32com.shell"
         __import__(pn)
         m = sys.modules[pn]
         for p in m.__path__[1:]:
             modulefinder.AddPackagePath(pn, p)
     except ImportError:
         pass
 
 except ImportError:
     py2exeloaded = False
     pass
 
 def runcmd(cmd, env):
     p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE, env=env)
     out, err = p.communicate()
     # If root is executing setup.py, but the repository is owned by
     # another user (as in "sudo python setup.py install") we will get
     # trust warnings since the .hg/hgrc file is untrusted. That is
     # fine, we don't want to load it anyway.  Python may warn about
     # a missing __init__.py in mercurial/locale, we also ignore that.
     err = [e for e in err.splitlines()
            if not e.startswith(b('Not trusting file')) \
               and not e.startswith(b('warning: Not importing'))]
     if err:
         return ''
     return out
 
 version = ''
 
 if os.path.isdir('.hg'):
     # Execute hg out of this directory with a custom environment which
     # includes the pure Python modules in mercurial/pure. We also take
     # care to not use any hgrc files and do no localization.
     pypath = ['mercurial', os.path.join('mercurial', 'pure')]
     env = {'PYTHONPATH': os.pathsep.join(pypath),
            'HGRCPATH': '',
            'LANGUAGE': 'C'}
     if 'LD_LIBRARY_PATH' in os.environ:
         env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']
     if 'SystemRoot' in os.environ:
         # Copy SystemRoot into the custom environment for Python 2.6
         # under Windows. Otherwise, the subprocess will fail with
         # error 0xc0150004. See: http://bugs.python.org/issue3440
         env['SystemRoot'] = os.environ['SystemRoot']
     cmd = [sys.executable, 'hg', 'id', '-i', '-t']
     l = runcmd(cmd, env).split()
     while len(l) > 1 and l[-1][0].isalpha(): # remove non-numbered tags
         l.pop()
     if len(l) > 1: # tag found
         version = l[-1]
         if l[0].endswith('+'): # propagate the dirty status to the tag
             version += '+'
     elif len(l) == 1: # no tag found
         cmd = [sys.executable, 'hg', 'parents', '--template',
                '{latesttag}+{latesttagdistance}-']
         version = runcmd(cmd, env) + l[0]
     if version.endswith('+'):
         version += time.strftime('%Y%m%d')
 elif os.path.exists('.hg_archival.txt'):
     kw = dict([[t.strip() for t in l.split(':', 1)]
                for l in open('.hg_archival.txt')])
     if 'tag' in kw:
         version =  kw['tag']
     elif 'latesttag' in kw:
         version = '%(latesttag)s+%(latesttagdistance)s-%(node).12s' % kw
     else:
         version = kw.get('node', '')[:12]
 
 if version:
     f = open("mercurial/__version__.py", "w")
     f.write('# this file is autogenerated by setup.py\n')
     f.write('version = "%s"\n' % version)
     f.close()
 
 
 try:
     from mercurial import __version__
     version = __version__.version
 except ImportError:
     version = 'unknown'
 
 class hgbuildmo(build):
 
     description = "build translations (.mo files)"
 
     def run(self):
         if not find_executable('msgfmt'):
             self.warn("could not find msgfmt executable, no translations "
                      "will be built")
             return
 
         podir = 'i18n'
         if not os.path.isdir(podir):
             self.warn("could not find %s/ directory" % podir)
             return
 
         join = os.path.join
         for po in os.listdir(podir):
             if not po.endswith('.po'):
                 continue
             pofile = join(podir, po)
             modir = join('locale', po[:-3], 'LC_MESSAGES')
             mofile = join(modir, 'hg.mo')
             mobuildfile = join('mercurial', mofile)
             cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]
             if sys.platform != 'sunos5':
                 # msgfmt on Solaris does not know about -c
                 cmd.append('-c')
             self.mkpath(join('mercurial', modir))
             self.make_file([pofile], mobuildfile, spawn, (cmd,))
 
 # Insert hgbuildmo first so that files in mercurial/locale/ are found
 # when build_py is run next.
 build.sub_commands.insert(0, ('build_mo', None))
 # We also need build_ext before build_py. Otherwise, when 2to3 is called (in
 # build_py), it will not find osutil & friends, thinking that those modules are
 # global and, consequently, making a mess, now that all module imports are
 # global.
 build.sub_commands.insert(1, ('build_ext', None))
 
 Distribution.pure = 0
 Distribution.global_options.append(('pure', None, "use pure (slow) Python "
                                     "code instead of C extensions"))
 
 class hgbuildext(build_ext):
 
     def build_extension(self, ext):
         try:
             build_ext.build_extension(self, ext)
         except CCompilerError:
             if not hasattr(ext, 'optional') or not ext.optional:
                 raise
             log.warn("Failed to build optional extension '%s' (skipping)",
                      ext.name)
 
 class hgbuildpy(build_py_2to3):
     fixer_names = sorted(set(getfixers("lib2to3.fixes") +
                              getfixers("hgfixes")))
 
     def finalize_options(self):
         build_py.finalize_options(self)
 
         if self.distribution.pure:
             if self.py_modules is None:
                 self.py_modules = []
             for ext in self.distribution.ext_modules:
                 if ext.name.startswith("mercurial."):
                     self.py_modules.append("mercurial.pure.%s" % ext.name[10:])
             self.distribution.ext_modules = []
 
     def find_modules(self):
         modules = build_py.find_modules(self)
         for module in modules:
             if module[0] == "mercurial.pure":
                 if module[1] != "__init__":
                     yield ("mercurial", module[1], module[2])
             else:
                 yield module
 
     def run(self):
         # In the build_py_2to3 class, self.updated_files = [], but I couldn't
         # see when that variable was updated to point to the updated files, as
         # its names suggests. Thus, I decided to just find_all_modules and feed
         # them to 2to3. Unfortunately, subsequent calls to setup3k.py will
         # incur in 2to3 analysis overhead.
         self.updated_files = [i[2] for i in self.find_all_modules()]
 
         # Base class code
         if self.py_modules:
             self.build_modules()
         if self.packages:
             self.build_packages()
             self.build_package_data()
 
         # 2to3
         self.run_2to3(self.updated_files)
 
         # Remaining base class code
         self.byte_compile(self.get_outputs(include_bytecode=0))
 
 cmdclass = {'build_mo': hgbuildmo,
             'build_ext': hgbuildext,
             'build_py': hgbuildpy}
 
 packages = ['mercurial', 'mercurial.hgweb', 'hgext', 'hgext.convert',
             'hgext.highlight', 'hgext.zeroconf']
 
 pymodules = []
 
 extmodules = [
     Extension('mercurial.base85', ['mercurial/base85.c']),
     Extension('mercurial.bdiff', ['mercurial/bdiff.c']),
     Extension('mercurial.diffhelpers', ['mercurial/diffhelpers.c']),
     Extension('mercurial.mpatch', ['mercurial/mpatch.c']),
     Extension('mercurial.parsers', ['mercurial/parsers.c']),
     ]
 
 # disable osutil.c under windows + python 2.4 (issue1364)
 if sys.platform == 'win32' and sys.version_info < (2, 5, 0, 'final'):
     pymodules.append('mercurial.pure.osutil')
 else:
     extmodules.append(Extension('mercurial.osutil', ['mercurial/osutil.c']))
 
 if sys.platform == 'linux2' and os.uname()[2] > '2.6':
     # The inotify extension is only usable with Linux 2.6 kernels.
     # You also need a reasonably recent C library.
     # In any case, if it fails to build the error will be skipped ('optional').
     cc = new_compiler()
     if hasfunction(cc, 'inotify_add_watch'):
         inotify = Extension('hgext.inotify.linux._inotify',
                             ['hgext/inotify/linux/_inotify.c'],
                             ['mercurial'])
         inotify.optional = True
         extmodules.append(inotify)
         packages.extend(['hgext.inotify', 'hgext.inotify.linux'])
 
 packagedata = {'mercurial': ['locale/*/LC_MESSAGES/hg.mo',
                              'help/*.txt']}
 
 def ordinarypath(p):
     return p and p[0] != '.' and p[-1] != '~'
 
 for root in ('templates',):
     for curdir, dirs, files in os.walk(os.path.join('mercurial', root)):
         curdir = curdir.split(os.sep, 1)[1]
         dirs[:] = filter(ordinarypath, dirs)
         for f in filter(ordinarypath, files):
             f = os.path.join(curdir, f)
             packagedata['mercurial'].append(f)
 
 datafiles = []
 setupversion = version
 extra = {}
 
 if py2exeloaded:
     extra['console'] = [
         {'script':'hg',
          'copyright':'Copyright (C) 2005-2010 Matt Mackall and others',
          'product_version':version}]
 
 if os.name == 'nt':
     # Windows binary file versions for exe/dll files must have the
     # form W.X.Y.Z, where W,X,Y,Z are numbers in the range 0..65535
     setupversion = version.split('+', 1)[0]
 
 setup(name='mercurial',
       version=setupversion,
       author='Matt Mackall',
       author_email='[e-mail]',
       url='http://mercurial.selenic.com/',
       description='Scalable distributed SCM',
       license='GNU GPLv2+',
       scripts=scripts,
       packages=packages,
       py_modules=pymodules,
       ext_modules=extmodules,
       data_files=datafiles,
       package_data=packagedata,
       cmdclass=cmdclass,
       options=dict(py2exe=dict(packages=['hgext', 'email']),
                    bdist_mpkg=dict(zipdist=True,
                                    license='COPYING',
                                    readme='contrib/macosx/Readme.html',
                                    welcome='contrib/macosx/Welcome.html')),
       **extra)

contrib/shrink-revlog.py

@@ -1,289 +1,287 b''
-#!/usr/bin/env python
-
 """\
 reorder a revlog (the manifest by default) to save space
 
 Specifically, this topologically sorts the revisions in the revlog so that
 revisions on the same branch are adjacent as much as possible. This is a
 workaround for the fact that Mercurial computes deltas relative to the
 previous revision rather than relative to a parent revision.
 
 This is *not* safe to run on a changelog.
 """
 
 # Originally written by Benoit Boissinot <benoit.boissinot at ens-lyon.org>
 # as a patch to rewrite-log. Cleaned up, refactored, documented, and
 # renamed by Greg Ward <greg at gerg.ca>.
 
 # XXX would be nice to have a way to verify the repository after shrinking,
 # e.g. by comparing "before" and "after" states of random changesets
 # (maybe: export before, shrink, export after, diff).
 
 import os, tempfile, errno
 from mercurial import revlog, transaction, node, util
 from mercurial import changegroup
 from mercurial.i18n import _
 
 
 def postorder(start, edges):
     result = []
     visit = list(start)
     finished = set()
 
     while visit:
         cur = visit[-1]
         for p in edges[cur]:
             if p not in finished:
                 visit.append(p)
                 break
         else:
             result.append(cur)
             finished.add(cur)
             visit.pop()
 
     return result
 
 def toposort_reversepostorder(ui, rl):
     # postorder of the reverse directed graph
 
     # map rev to list of parent revs (p2 first)
     parents = {}
     heads = set()
     ui.status(_('reading revs\n'))
     try:
         for rev in rl:
             ui.progress(_('reading'), rev, total=len(rl))
             (p1, p2) = rl.parentrevs(rev)
             if p1 == p2 == node.nullrev:
                 parents[rev] = ()       # root node
             elif p1 == p2 or p2 == node.nullrev:
                 parents[rev] = (p1,)    # normal node
             else:
                 parents[rev] = (p2, p1) # merge node
             heads.add(rev)
             for p in parents[rev]:
                 heads.discard(p)
     finally:
         ui.progress(_('reading'), None)
 
     heads = list(heads)
     heads.sort(reverse=True)
 
     ui.status(_('sorting revs\n'))
     return postorder(heads, parents)
 
 def toposort_postorderreverse(ui, rl):
     # reverse-postorder of the reverse directed graph
 
     children = {}
     roots = set()
     ui.status(_('reading revs\n'))
     try:
         for rev in rl:
             ui.progress(_('reading'), rev, total=len(rl))
             (p1, p2) = rl.parentrevs(rev)
             if p1 == p2 == node.nullrev:
                 roots.add(rev)
             children[rev] = []
             if p1 != node.nullrev:
                 children[p1].append(rev)
             if p2 != node.nullrev:
                 children[p2].append(rev)
     finally:
         ui.progress(_('reading'), None)
 
     roots = list(roots)
     roots.sort()
 
     ui.status(_('sorting revs\n'))
     result = postorder(roots, children)
     result.reverse()
     return result
 
 def writerevs(ui, r1, r2, order, tr):
 
     ui.status(_('writing revs\n'))
 
     count = [0]
     def progress(*args):
         ui.progress(_('writing'), count[0], total=len(order))
         count[0] += 1
 
     order = [r1.node(r) for r in order]
 
     # this is a bit ugly, but it works
     lookup = lambda x: "%020d" % r1.linkrev(r1.rev(x))
     unlookup = lambda x: int(x, 10)
 
     try:
         group = util.chunkbuffer(r1.group(order, lookup, progress))
         group = changegroup.unbundle10(group, "UN")
         r2.addgroup(group, unlookup, tr)
     finally:
         ui.progress(_('writing'), None)
 
 def report(ui, r1, r2):
     def getsize(r):
         s = 0
         for fn in (r.indexfile, r.datafile):
             try:
                 s += os.stat(fn).st_size
             except OSError, inst:
                 if inst.errno != errno.ENOENT:
                     raise
         return s
 
     oldsize = float(getsize(r1))
     newsize = float(getsize(r2))
 
     # argh: have to pass an int to %d, because a float >= 2^32
     # blows up under Python 2.5 or earlier
     ui.write(_('old file size: %12d bytes (%6.1f MiB)\n')
              % (int(oldsize), oldsize / 1024 / 1024))
     ui.write(_('new file size: %12d bytes (%6.1f MiB)\n')
              % (int(newsize), newsize / 1024 / 1024))
 
     shrink_percent = (oldsize - newsize) / oldsize * 100
     shrink_factor = oldsize / newsize
     ui.write(_('shrinkage: %.1f%% (%.1fx)\n')
              % (shrink_percent, shrink_factor))
 
 def shrink(ui, repo, **opts):
     """shrink a revlog by reordering revisions
 
     Rewrites all the entries in some revlog of the current repository
     (by default, the manifest log) to save space.
 
     Different sort algorithms have different performance
     characteristics.  Use ``--sort`` to select a sort algorithm so you
     can determine which works best for your data.
     """
 
     if not repo.local():
         raise util.Abort(_('not a local repository: %s') % repo.root)
 
     fn = opts.get('revlog')
     if not fn:
         indexfn = repo.sjoin('00manifest.i')
     else:
         if not fn.endswith('.i'):
             raise util.Abort(_('--revlog option must specify the revlog index '
                                'file (*.i), not %s') % opts.get('revlog'))
 
         indexfn = os.path.realpath(fn)
         store = repo.sjoin('')
         if not indexfn.startswith(store):
             raise util.Abort(_('--revlog option must specify a revlog in %s, '
                                'not %s') % (store, indexfn))
 
     sortname = opts['sort']
     try:
         toposort = globals()['toposort_' + sortname]
     except KeyError:
         raise util.Abort(_('no such toposort algorithm: %s') % sortname)
 
     if not os.path.exists(indexfn):
         raise util.Abort(_('no such file: %s') % indexfn)
     if '00changelog' in indexfn:
         raise util.Abort(_('shrinking the changelog '
                            'will corrupt your repository'))
 
     ui.write(_('shrinking %s\n') % indexfn)
     prefix = os.path.basename(indexfn)[:-1]
     tmpindexfn = util.mktempcopy(indexfn, emptyok=True)
 
     r1 = revlog.revlog(util.opener(os.getcwd(), audit=False), indexfn)
     r2 = revlog.revlog(util.opener(os.getcwd(), audit=False), tmpindexfn)
 
     datafn, tmpdatafn = r1.datafile, r2.datafile
 
     oldindexfn = indexfn + '.old'
     olddatafn = datafn + '.old'
     if os.path.exists(oldindexfn) or os.path.exists(olddatafn):
         raise util.Abort(_('one or both of\n'
                            '  %s\n'
                            '  %s\n'
                            'exists from a previous run; please clean up '
                            'before running again') % (oldindexfn, olddatafn))
 
     # Don't use repo.transaction(), because then things get hairy with
     # paths: some need to be relative to .hg, and some need to be
     # absolute. Doing it this way keeps things simple: everything is an
     # absolute path.
     lock = repo.lock(wait=False)
     tr = transaction.transaction(ui.warn,
                                  open,
                                  repo.sjoin('journal'))
 
     def ignoremissing(func):
         def f(*args, **kw):
             try:
                 return func(*args, **kw)
             except OSError, inst:
                 if inst.errno != errno.ENOENT:
                     raise
         return f
 
     try:
         try:
             order = toposort(ui, r1)
 
             suboptimal = 0
             for i in xrange(1, len(order)):
                 parents = [p for p in r1.parentrevs(order[i])
                            if p != node.nullrev]
                 if parents and order[i - 1] not in parents:
                     suboptimal += 1
             ui.note(_('%d suboptimal nodes\n') % suboptimal)
 
             writerevs(ui, r1, r2, order, tr)
             report(ui, r1, r2)
             tr.close()
         except:
             # Abort transaction first, so we truncate the files before
             # deleting them.
             tr.abort()
             for fn in (tmpindexfn, tmpdatafn):
                 ignoremissing(os.unlink)(fn)
             raise
         if not opts.get('dry_run'):
             # racy, both files cannot be renamed atomically
             # copy files
             util.os_link(indexfn, oldindexfn)
             ignoremissing(util.os_link)(datafn, olddatafn)
 
             # rename
             util.rename(tmpindexfn, indexfn)
             try:
                 os.chmod(tmpdatafn, os.stat(datafn).st_mode)
                 util.rename(tmpdatafn, datafn)
             except OSError, inst:
                 if inst.errno != errno.ENOENT:
                     raise
                 ignoremissing(os.unlink)(datafn)
         else:
             for fn in (tmpindexfn, tmpdatafn):
                 ignoremissing(os.unlink)(fn)
     finally:
         lock.release()
 
     if not opts.get('dry_run'):
         ui.write(_('note: old revlog saved in:\n'
                    '  %s\n'
                    '  %s\n'
                    '(You can delete those files when you are satisfied that your\n'
                    'repository is still sane.  '
                    'Running \'hg verify\' is strongly recommended.)\n')
                  % (oldindexfn, olddatafn))
 
 cmdtable = {
     'shrink': (shrink,
                [('', 'revlog', '', _('index (.i) file of the revlog to shrink')),
                 ('n', 'dry-run', None, _('do not shrink, simulate only')),
                 ('', 'sort', 'reversepostorder', 'name of sort algorithm to use'),
                 ],
                _('hg shrink [--revlog PATH]'))
 }
 
 if __name__ == "__main__":
     print "shrink-revlog.py is now an extension (see hg help extensions)"

doc/hgmanpage.py

@@ -1,1102 +1,1101 b''
-#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # $Id: manpage.py 6110 2009-08-31 14:40:33Z grubert $
 # Author: Engelbert Gruber <[e-mail]>
 # Copyright: This module is put into the public domain.
 
 """
 Simple man page writer for reStructuredText.
 
 Man pages (short for "manual pages") contain system documentation on unix-like
 systems. The pages are grouped in numbered sections:
 
  1 executable programs and shell commands
  2 system calls
  3 library functions
  4 special files
  5 file formats
  6 games
  7 miscellaneous
  8 system administration
 
 Man pages are written *troff*, a text file formatting system.
 
 See http://www.tldp.org/HOWTO/Man-Page for a start.
 
 Man pages have no subsection only parts.
 Standard parts
 
   NAME ,
   SYNOPSIS ,
   DESCRIPTION ,
   OPTIONS ,
   FILES ,
   SEE ALSO ,
   BUGS ,
 
 and
 
   AUTHOR .
 
 A unix-like system keeps an index of the DESCRIPTIONs, which is accesable
 by the command whatis or apropos.
 
 """
 
 __docformat__ = 'reStructuredText'
 
 import re
 
 from docutils import nodes, writers, languages
 import roman
 
 FIELD_LIST_INDENT = 7
 DEFINITION_LIST_INDENT = 7
 OPTION_LIST_INDENT = 7
 BLOCKQOUTE_INDENT = 3.5
 
 # Define two macros so man/roff can calculate the
 # indent/unindent margins by itself
 MACRO_DEF = (r""".
 .nr rst2man-indent-level 0
 .
 .de1 rstReportMargin
 \\$1 \\n[an-margin]
 level \\n[rst2man-indent-level]
 level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 -
 \\n[rst2man-indent0]
 \\n[rst2man-indent1]
 \\n[rst2man-indent2]
 ..
 .de1 INDENT
 .\" .rstReportMargin pre:
 . RS \\$1
 . nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]
 . nr rst2man-indent-level +1
 .\" .rstReportMargin post:
 ..
 .de UNINDENT
 . RE
 .\" indent \\n[an-margin]
 .\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .nr rst2man-indent-level -1
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
 """)
 
 class Writer(writers.Writer):
 
     supported = ('manpage')
     """Formats this writer supports."""
 
     output = None
     """Final translated form of `document`."""
 
     def __init__(self):
         writers.Writer.__init__(self)
         self.translator_class = Translator
 
     def translate(self):
         visitor = self.translator_class(self.document)
         self.document.walkabout(visitor)
         self.output = visitor.astext()
 
 
 class Table:
     def __init__(self):
         self._rows = []
         self._options = ['center']
         self._tab_char = '\t'
         self._coldefs = []
     def new_row(self):
         self._rows.append([])
     def append_separator(self, separator):
         """Append the separator for table head."""
         self._rows.append([separator])
     def append_cell(self, cell_lines):
         """cell_lines is an array of lines"""
         start = 0
         if len(cell_lines) > 0 and cell_lines[0] == '.sp\n':
             start = 1
         self._rows[-1].append(cell_lines[start:])
         if len(self._coldefs) < len(self._rows[-1]):
             self._coldefs.append('l')
     def _minimize_cell(self, cell_lines):
         """Remove leading and trailing blank and ``.sp`` lines"""
         while (cell_lines and cell_lines[0] in ('\n', '.sp\n')):
             del cell_lines[0]
         while (cell_lines and cell_lines[-1] in ('\n', '.sp\n')):
             del cell_lines[-1]
     def as_list(self):
         text = ['.TS\n']
         text.append(' '.join(self._options) + ';\n')
         text.append('|%s|.\n' % ('|'.join(self._coldefs)))
         for row in self._rows:
             # row = array of cells. cell = array of lines.
             text.append('_\n')       # line above
             text.append('T{\n')
             for i in range(len(row)):
                 cell = row[i]
                 self._minimize_cell(cell)
                 text.extend(cell)
                 if not text[-1].endswith('\n'):
                     text[-1] += '\n'
                 if i < len(row)-1:
                     text.append('T}'+self._tab_char+'T{\n')
                 else:
                     text.append('T}\n')
         text.append('_\n')
         text.append('.TE\n')
         return text
 
 class Translator(nodes.NodeVisitor):
     """"""
 
     words_and_spaces = re.compile(r'\S+| +|\n')
     document_start = """Man page generated from reStructeredText."""
 
     def __init__(self, document):
         nodes.NodeVisitor.__init__(self, document)
         self.settings = settings = document.settings
         lcode = settings.language_code
         self.language = languages.get_language(lcode)
         self.head = []
         self.body = []
         self.foot = []
         self.section_level = 0
         self.context = []
         self.topic_class = ''
         self.colspecs = []
         self.compact_p = 1
         self.compact_simple = None
         # the list style "*" bullet or "#" numbered
         self._list_char = []
         # writing the header .TH and .SH NAME is postboned after
         # docinfo.
         self._docinfo = {
                 "title" : "", "title_upper": "",
                 "subtitle" : "",
                 "manual_section" : "", "manual_group" : "",
                 "author" : [],
                 "date" : "",
                 "copyright" : "",
                 "version" : "",
                     }
         self._docinfo_keys = []     # a list to keep the sequence as in source.
         self._docinfo_names = {}    # to get name from text not normalized.
         self._in_docinfo = None
         self._active_table = None
         self._in_literal = False
         self.header_written = 0
         self._line_block = 0
         self.authors = []
         self.section_level = 0
         self._indent = [0]
         # central definition of simple processing rules
         # what to output on : visit, depart
         # Do not use paragraph requests ``.PP`` because these set indentation.
         # use ``.sp``. Remove superfluous ``.sp`` in ``astext``.
         #
         # Fonts are put on a stack, the top one is used.
         # ``.ft P`` or ``\\fP`` pop from stack.
         # ``B`` bold, ``I`` italic, ``R`` roman should be available.
         # Hopefully ``C`` courier too.
         self.defs = {
                 'indent' : ('.INDENT %.1f\n', '.UNINDENT\n'),
                 'definition_list_item' : ('.TP', ''),
                 'field_name' : ('.TP\n.B ', '\n'),
                 'literal' : ('\\fB', '\\fP'),
                 'literal_block' : ('.sp\n.nf\n.ft C\n', '\n.ft P\n.fi\n'),
 
                 'option_list_item' : ('.TP\n', ''),
 
                 'reference' : (r'\%', r'\:'),
                 'emphasis': ('\\fI', '\\fP'),
                 'strong' : ('\\fB', '\\fP'),
                 'term' : ('\n.B ', '\n'),
                 'title_reference' : ('\\fI', '\\fP'),
 
                 'topic-title' : ('.SS ',),
                 'sidebar-title' : ('.SS ',),
 
                 'problematic' : ('\n.nf\n', '\n.fi\n'),
                     }
         # NOTE don't specify the newline before a dot-command, but ensure
         # it is there.
 
     def comment_begin(self, text):
         """Return commented version of the passed text WITHOUT end of
         line/comment."""
         prefix = '.\\" '
         out_text = ''.join(
             [(prefix + in_line + '\n')
             for in_line in text.split('\n')])
         return out_text
 
     def comment(self, text):
         """Return commented version of the passed text."""
         return self.comment_begin(text)+'.\n'
 
     def ensure_eol(self):
         """Ensure the last line in body is terminated by new line."""
         if self.body[-1][-1] != '\n':
             self.body.append('\n')
 
     def astext(self):
         """Return the final formatted document as a string."""
         if not self.header_written:
             # ensure we get a ".TH" as viewers require it.
             self.head.append(self.header())
         # filter body
         for i in xrange(len(self.body)-1, 0, -1):
             # remove superfluous vertical gaps.
             if self.body[i] == '.sp\n':
                 if self.body[i - 1][:4] in ('.BI ','.IP '):
                     self.body[i] = '.\n'
                 elif (self.body[i - 1][:3] == '.B ' and
                     self.body[i - 2][:4] == '.TP\n'):
                     self.body[i] = '.\n'
                 elif (self.body[i - 1] == '\n' and
                     self.body[i - 2][0] != '.' and
                     (self.body[i - 3][:7] == '.TP\n.B '
                         or self.body[i - 3][:4] == '\n.B ')
                      ):
                     self.body[i] = '.\n'
         return ''.join(self.head + self.body + self.foot)
 
     def deunicode(self, text):
         text = text.replace(u'\xa0', '\\ ')
         text = text.replace(u'\u2020', '\\(dg')
         return text
 
     def visit_Text(self, node):
         text = node.astext()
         text = text.replace('\\','\\e')
         replace_pairs = [
             (u'-', ur'\-'),
             (u'\'', ur'\(aq'),
             (u'´', ur'\''),
             (u'`', ur'\(ga'),
             ]
         for (in_char, out_markup) in replace_pairs:
             text = text.replace(in_char, out_markup)
         # unicode
         text = self.deunicode(text)
         if self._in_literal:
             # prevent interpretation of "." at line start
             if text[0] == '.':
                 text = '\\&' + text
             text = text.replace('\n.', '\n\\&.')
         self.body.append(text)
 
     def depart_Text(self, node):
         pass
 
     def list_start(self, node):
         class enum_char:
             enum_style = {
                     'bullet'     : '\\(bu',
                     'emdash'     : '\\(em',
                      }
 
             def __init__(self, style):
                 self._style = style
                 if 'start' in node:
                     self._cnt = node['start'] - 1
                 else:
                     self._cnt = 0
                 self._indent = 2
                 if style == 'arabic':
                     # indentation depends on number of childrens
                     # and start value.
                     self._indent = len(str(len(node.children)))
                     self._indent += len(str(self._cnt)) + 1
                 elif style == 'loweralpha':
                     self._cnt += ord('a') - 1
                     self._indent = 3
                 elif style == 'upperalpha':
                     self._cnt += ord('A') - 1
                     self._indent = 3
                 elif style.endswith('roman'):
                     self._indent = 5
 
             def next(self):
                 if self._style == 'bullet':
                     return self.enum_style[self._style]
                 elif self._style == 'emdash':
                     return self.enum_style[self._style]
                 self._cnt += 1
                 # TODO add prefix postfix
                 if self._style == 'arabic':
                     return "%d." % self._cnt
                 elif self._style in ('loweralpha', 'upperalpha'):
                     return "%c." % self._cnt
                 elif self._style.endswith('roman'):
                     res = roman.toRoman(self._cnt) + '.'
                     if self._style.startswith('upper'):
                         return res.upper()
                     return res.lower()
                 else:
                     return "%d." % self._cnt
             def get_width(self):
                 return self._indent
             def __repr__(self):
                 return 'enum_style-%s' % list(self._style)
 
         if 'enumtype' in node:
             self._list_char.append(enum_char(node['enumtype']))
         else:
             self._list_char.append(enum_char('bullet'))
         if len(self._list_char) > 1:
             # indent nested lists
             self.indent(self._list_char[-2].get_width())
         else:
             self.indent(self._list_char[-1].get_width())
 
     def list_end(self):
         self.dedent()
         self._list_char.pop()
 
     def header(self):
         tmpl = (".TH %(title_upper)s %(manual_section)s"
                 " \"%(date)s\" \"%(version)s\" \"%(manual_group)s\"\n"
                 ".SH NAME\n"
                 "%(title)s \- %(subtitle)s\n")
         return tmpl % self._docinfo
 
     def append_header(self):
         """append header with .TH and .SH NAME"""
         # NOTE before everything
         # .TH title_upper section date source manual
         if self.header_written:
             return
         self.body.append(self.header())
         self.body.append(MACRO_DEF)
         self.header_written = 1
 
     def visit_address(self, node):
         self.visit_docinfo_item(node, 'address')
 
     def depart_address(self, node):
         pass
 
     def visit_admonition(self, node, name=None):
         if name:
             self.body.append('.IP %s\n' %
                         self.language.labels.get(name, name))
 
     def depart_admonition(self, node):
         self.body.append('.RE\n')
 
     def visit_attention(self, node):
         self.visit_admonition(node, 'attention')
 
     depart_attention = depart_admonition
 
     def visit_docinfo_item(self, node, name):
         if name == 'author':
             self._docinfo[name].append(node.astext())
         else:
             self._docinfo[name] = node.astext()
         self._docinfo_keys.append(name)
         raise nodes.SkipNode
 
     def depart_docinfo_item(self, node):
         pass
 
     def visit_author(self, node):
         self.visit_docinfo_item(node, 'author')
 
     depart_author = depart_docinfo_item
 
     def visit_authors(self, node):
         # _author is called anyway.
         pass
 
     def depart_authors(self, node):
         pass
 
     def visit_block_quote(self, node):
         # BUG/HACK: indent alway uses the _last_ indention,
         # thus we need two of them.
         self.indent(BLOCKQOUTE_INDENT)
         self.indent(0)
 
     def depart_block_quote(self, node):
         self.dedent()
         self.dedent()
 
     def visit_bullet_list(self, node):
         self.list_start(node)
 
     def depart_bullet_list(self, node):
         self.list_end()
 
     def visit_caption(self, node):
         pass
 
     def depart_caption(self, node):
         pass
 
     def visit_caution(self, node):
         self.visit_admonition(node, 'caution')
 
     depart_caution = depart_admonition
 
     def visit_citation(self, node):
         num, text = node.astext().split(None, 1)
         num = num.strip()
         self.body.append('.IP [%s] 5\n' % num)
 
     def depart_citation(self, node):
         pass
 
     def visit_citation_reference(self, node):
         self.body.append('['+node.astext()+']')
         raise nodes.SkipNode
 
     def visit_classifier(self, node):
         pass
 
     def depart_classifier(self, node):
         pass
 
     def visit_colspec(self, node):
         self.colspecs.append(node)
 
     def depart_colspec(self, node):
         pass
 
     def write_colspecs(self):
         self.body.append("%s.\n" % ('L '*len(self.colspecs)))
 
     def visit_comment(self, node,
                       sub=re.compile('-(?=-)').sub):
         self.body.append(self.comment(node.astext()))
         raise nodes.SkipNode
 
     def visit_contact(self, node):
         self.visit_docinfo_item(node, 'contact')
 
     depart_contact = depart_docinfo_item
 
     def visit_container(self, node):
         pass
 
     def depart_container(self, node):
         pass
 
     def visit_compound(self, node):
         pass
 
     def depart_compound(self, node):
         pass
 
     def visit_copyright(self, node):
         self.visit_docinfo_item(node, 'copyright')
 
     def visit_danger(self, node):
         self.visit_admonition(node, 'danger')
 
     depart_danger = depart_admonition
 
     def visit_date(self, node):
         self.visit_docinfo_item(node, 'date')
 
     def visit_decoration(self, node):
         pass
 
     def depart_decoration(self, node):
         pass
 
     def visit_definition(self, node):
         pass
 
     def depart_definition(self, node):
         pass
 
     def visit_definition_list(self, node):
         self.indent(DEFINITION_LIST_INDENT)
 
     def depart_definition_list(self, node):
         self.dedent()
 
     def visit_definition_list_item(self, node):
         self.body.append(self.defs['definition_list_item'][0])
 
     def depart_definition_list_item(self, node):
         self.body.append(self.defs['definition_list_item'][1])
 
     def visit_description(self, node):
         pass
 
     def depart_description(self, node):
         pass
 
     def visit_docinfo(self, node):
         self._in_docinfo = 1
 
     def depart_docinfo(self, node):
         self._in_docinfo = None
         # NOTE nothing should be written before this
         self.append_header()
 
     def visit_doctest_block(self, node):
         self.body.append(self.defs['literal_block'][0])
         self._in_literal = True
 
     def depart_doctest_block(self, node):
         self._in_literal = False
         self.body.append(self.defs['literal_block'][1])
 
     def visit_document(self, node):
         # no blank line between comment and header.
         self.body.append(self.comment(self.document_start).rstrip()+'\n')
         # writing header is postboned
         self.header_written = 0
 
     def depart_document(self, node):
         if self._docinfo['author']:
             self.body.append('.SH AUTHOR\n%s\n'
                     % ', '.join(self._docinfo['author']))
         skip = ('author', 'copyright', 'date',
                 'manual_group', 'manual_section',
                 'subtitle',
                 'title', 'title_upper', 'version')
         for name in self._docinfo_keys:
             if name == 'address':
                 self.body.append("\n%s:\n%s%s.nf\n%s\n.fi\n%s%s" % (
                                     self.language.labels.get(name, name),
                                     self.defs['indent'][0] % 0,
                                     self.defs['indent'][0] % BLOCKQOUTE_INDENT,
                                     self._docinfo[name],
                                     self.defs['indent'][1],
                                     self.defs['indent'][1]))
             elif not name in skip:
                 if name in self._docinfo_names:
                     label = self._docinfo_names[name]
                 else:
                     label = self.language.labels.get(name, name)
                 self.body.append("\n%s: %s\n" % (label, self._docinfo[name]))
         if self._docinfo['copyright']:
             self.body.append('.SH COPYRIGHT\n%s\n'
                     % self._docinfo['copyright'])
         self.body.append(self.comment(
                         'Generated by docutils manpage writer.\n'))
 
     def visit_emphasis(self, node):
         self.body.append(self.defs['emphasis'][0])
 
     def depart_emphasis(self, node):
         self.body.append(self.defs['emphasis'][1])
 
     def visit_entry(self, node):
         # a cell in a table row
         if 'morerows' in node:
             self.document.reporter.warning('"table row spanning" not supported',
                     base_node=node)
         if 'morecols' in node:
             self.document.reporter.warning(
                     '"table cell spanning" not supported', base_node=node)
         self.context.append(len(self.body))
 
     def depart_entry(self, node):
         start = self.context.pop()
         self._active_table.append_cell(self.body[start:])
         del self.body[start:]
 
     def visit_enumerated_list(self, node):
         self.list_start(node)
 
     def depart_enumerated_list(self, node):
         self.list_end()
 
     def visit_error(self, node):
         self.visit_admonition(node, 'error')
 
     depart_error = depart_admonition
 
     def visit_field(self, node):
         pass
 
     def depart_field(self, node):
         pass
 
     def visit_field_body(self, node):
         if self._in_docinfo:
             name_normalized = self._field_name.lower().replace(" ","_")
             self._docinfo_names[name_normalized] = self._field_name
             self.visit_docinfo_item(node, name_normalized)
             raise nodes.SkipNode
 
     def depart_field_body(self, node):
         pass
 
     def visit_field_list(self, node):
         self.indent(FIELD_LIST_INDENT)
 
     def depart_field_list(self, node):
         self.dedent()
 
     def visit_field_name(self, node):
         if self._in_docinfo:
             self._field_name = node.astext()
             raise nodes.SkipNode
         else:
             self.body.append(self.defs['field_name'][0])
 
     def depart_field_name(self, node):
         self.body.append(self.defs['field_name'][1])
 
     def visit_figure(self, node):
         self.indent(2.5)
         self.indent(0)
 
     def depart_figure(self, node):
         self.dedent()
         self.dedent()
 
     def visit_footer(self, node):
         self.document.reporter.warning('"footer" not supported',
                 base_node=node)
 
     def depart_footer(self, node):
         pass
 
     def visit_footnote(self, node):
         num, text = node.astext().split(None, 1)
         num = num.strip()
         self.body.append('.IP [%s] 5\n' % self.deunicode(num))
 
     def depart_footnote(self, node):
         pass
 
     def footnote_backrefs(self, node):
         self.document.reporter.warning('"footnote_backrefs" not supported',
                 base_node=node)
 
     def visit_footnote_reference(self, node):
         self.body.append('['+self.deunicode(node.astext())+']')
         raise nodes.SkipNode
 
     def depart_footnote_reference(self, node):
         pass
 
     def visit_generated(self, node):
         pass
 
     def depart_generated(self, node):
         pass
 
     def visit_header(self, node):
         raise NotImplementedError, node.astext()
 
     def depart_header(self, node):
         pass
 
     def visit_hint(self, node):
         self.visit_admonition(node, 'hint')
 
     depart_hint = depart_admonition
 
     def visit_subscript(self, node):
         self.body.append('\\s-2\\d')
 
     def depart_subscript(self, node):
         self.body.append('\\u\\s0')
 
     def visit_superscript(self, node):
         self.body.append('\\s-2\\u')
 
     def depart_superscript(self, node):
         self.body.append('\\d\\s0')
 
     def visit_attribution(self, node):
         self.body.append('\\(em ')
 
     def depart_attribution(self, node):
         self.body.append('\n')
 
     def visit_image(self, node):
         self.document.reporter.warning('"image" not supported',
                 base_node=node)
         text = []
         if 'alt' in node.attributes:
             text.append(node.attributes['alt'])
         if 'uri' in node.attributes:
             text.append(node.attributes['uri'])
         self.body.append('[image: %s]\n' % ('/'.join(text)))
         raise nodes.SkipNode
 
     def visit_important(self, node):
         self.visit_admonition(node, 'important')
 
     depart_important = depart_admonition
 
     def visit_label(self, node):
         # footnote and citation
         if (isinstance(node.parent, nodes.footnote)
             or isinstance(node.parent, nodes.citation)):
             raise nodes.SkipNode
         self.document.reporter.warning('"unsupported "label"',
                 base_node=node)
         self.body.append('[')
 
     def depart_label(self, node):
         self.body.append(']\n')
 
     def visit_legend(self, node):
         pass
 
     def depart_legend(self, node):
         pass
 
     # WHAT should we use .INDENT, .UNINDENT ?
     def visit_line_block(self, node):
         self._line_block += 1
         if self._line_block == 1:
             self.body.append('.sp\n')
             self.body.append('.nf\n')
         else:
             self.body.append('.in +2\n')
 
     def depart_line_block(self, node):
         self._line_block -= 1
         if self._line_block == 0:
             self.body.append('.fi\n')
             self.body.append('.sp\n')
         else:
             self.body.append('.in -2\n')
 
     def visit_line(self, node):
         pass
 
     def depart_line(self, node):
         self.body.append('\n')
 
     def visit_list_item(self, node):
         # man 7 man argues to use ".IP" instead of ".TP"
         self.body.append('.IP %s %d\n' % (
                 self._list_char[-1].next(),
                 self._list_char[-1].get_width(),))
 
     def depart_list_item(self, node):
         pass
 
     def visit_literal(self, node):
         self.body.append(self.defs['literal'][0])
 
     def depart_literal(self, node):
         self.body.append(self.defs['literal'][1])
 
     def visit_literal_block(self, node):
         self.body.append(self.defs['literal_block'][0])
         self._in_literal = True
 
     def depart_literal_block(self, node):
         self._in_literal = False
         self.body.append(self.defs['literal_block'][1])
 
     def visit_meta(self, node):
         raise NotImplementedError, node.astext()
 
     def depart_meta(self, node):
         pass
 
     def visit_note(self, node):
         self.visit_admonition(node, 'note')
 
     depart_note = depart_admonition
 
     def indent(self, by=0.5):
         # if we are in a section ".SH" there already is a .RS
         step = self._indent[-1]
         self._indent.append(by)
         self.body.append(self.defs['indent'][0] % step)
 
     def dedent(self):
         self._indent.pop()
         self.body.append(self.defs['indent'][1])
 
     def visit_option_list(self, node):
         self.indent(OPTION_LIST_INDENT)
 
     def depart_option_list(self, node):
         self.dedent()
 
     def visit_option_list_item(self, node):
         # one item of the list
         self.body.append(self.defs['option_list_item'][0])
 
     def depart_option_list_item(self, node):
         self.body.append(self.defs['option_list_item'][1])
 
     def visit_option_group(self, node):
         # as one option could have several forms it is a group
         # options without parameter bold only, .B, -v
         # options with parameter bold italic, .BI, -f file
         #
         # we do not know if .B or .BI
         self.context.append('.B')           # blind guess
         self.context.append(len(self.body)) # to be able to insert later
         self.context.append(0)              # option counter
 
     def depart_option_group(self, node):
         self.context.pop()  # the counter
         start_position = self.context.pop()
         text = self.body[start_position:]
         del self.body[start_position:]
         self.body.append('%s%s\n' % (self.context.pop(), ''.join(text)))
 
     def visit_option(self, node):
         # each form of the option will be presented separately
         if self.context[-1] > 0:
             self.body.append(', ')
         if self.context[-3] == '.BI':
             self.body.append('\\')
         self.body.append(' ')
 
     def depart_option(self, node):
         self.context[-1] += 1
 
     def visit_option_string(self, node):
         # do not know if .B or .BI
         pass
 
     def depart_option_string(self, node):
         pass
 
     def visit_option_argument(self, node):
         self.context[-3] = '.BI' # bold/italic alternate
         if node['delimiter'] != ' ':
             self.body.append('\\fB%s ' % node['delimiter'])
         elif self.body[len(self.body)-1].endswith('='):
             # a blank only means no blank in output, just changing font
             self.body.append(' ')
         else:
             # blank backslash blank, switch font then a blank
             self.body.append(' \\ ')
 
     def depart_option_argument(self, node):
         pass
 
     def visit_organization(self, node):
         self.visit_docinfo_item(node, 'organization')
 
     def depart_organization(self, node):
         pass
 
     def visit_paragraph(self, node):
         # ``.PP`` : Start standard indented paragraph.
         # ``.LP`` : Start block paragraph, all except the first.
         # ``.P [type]``  : Start paragraph type.
         # NOTE dont use paragraph starts because they reset indentation.
         # ``.sp`` is only vertical space
         self.ensure_eol()
         self.body.append('.sp\n')
 
     def depart_paragraph(self, node):
         self.body.append('\n')
 
     def visit_problematic(self, node):
         self.body.append(self.defs['problematic'][0])
 
     def depart_problematic(self, node):
         self.body.append(self.defs['problematic'][1])
 
     def visit_raw(self, node):
         if node.get('format') == 'manpage':
             self.body.append(node.astext() + "\n")
         # Keep non-manpage raw text out of output:
         raise nodes.SkipNode
 
     def visit_reference(self, node):
         """E.g. link or email address."""
         self.body.append(self.defs['reference'][0])
 
     def depart_reference(self, node):
         self.body.append(self.defs['reference'][1])
 
     def visit_revision(self, node):
         self.visit_docinfo_item(node, 'revision')
 
     depart_revision = depart_docinfo_item
 
     def visit_row(self, node):
         self._active_table.new_row()
 
     def depart_row(self, node):
         pass
 
     def visit_section(self, node):
         self.section_level += 1
 
     def depart_section(self, node):
         self.section_level -= 1
 
     def visit_status(self, node):
         self.visit_docinfo_item(node, 'status')
 
     depart_status = depart_docinfo_item
 
     def visit_strong(self, node):
         self.body.append(self.defs['strong'][0])
 
     def depart_strong(self, node):
         self.body.append(self.defs['strong'][1])
 
     def visit_substitution_definition(self, node):
         """Internal only."""
         raise nodes.SkipNode
 
     def visit_substitution_reference(self, node):
         self.document.reporter.warning('"substitution_reference" not supported',
                 base_node=node)
 
     def visit_subtitle(self, node):
         if isinstance(node.parent, nodes.sidebar):
             self.body.append(self.defs['strong'][0])
         elif isinstance(node.parent, nodes.document):
             self.visit_docinfo_item(node, 'subtitle')
         elif isinstance(node.parent, nodes.section):
             self.body.append(self.defs['strong'][0])
 
     def depart_subtitle(self, node):
         # document subtitle calls SkipNode
         self.body.append(self.defs['strong'][1]+'\n.PP\n')
 
     def visit_system_message(self, node):
         # TODO add report_level
         #if node['level'] < self.document.reporter['writer'].report_level:
         #    Level is too low to display:
         #    raise nodes.SkipNode
         attr = {}
         backref_text = ''
         if node.hasattr('id'):
             attr['name'] = node['id']
         if node.hasattr('line'):
             line = ', line %s' % node['line']
         else:
             line = ''
         self.body.append('.IP "System Message: %s/%s (%s:%s)"\n'
                          % (node['type'], node['level'], node['source'], line))
 
     def depart_system_message(self, node):
         pass
 
     def visit_table(self, node):
         self._active_table = Table()
 
     def depart_table(self, node):
         self.ensure_eol()
         self.body.extend(self._active_table.as_list())
         self._active_table = None
 
     def visit_target(self, node):
         # targets are in-document hyper targets, without any use for man-pages.
         raise nodes.SkipNode
 
     def visit_tbody(self, node):
         pass
 
     def depart_tbody(self, node):
         pass
 
     def visit_term(self, node):
         self.body.append(self.defs['term'][0])
 
     def depart_term(self, node):
         self.body.append(self.defs['term'][1])
 
     def visit_tgroup(self, node):
         pass
 
     def depart_tgroup(self, node):
         pass
 
     def visit_thead(self, node):
         # MAYBE double line '='
         pass
 
     def depart_thead(self, node):
         # MAYBE double line '='
         pass
 
     def visit_tip(self, node):
         self.visit_admonition(node, 'tip')
 
     depart_tip = depart_admonition
 
     def visit_title(self, node):
         if isinstance(node.parent, nodes.topic):
             self.body.append(self.defs['topic-title'][0])
         elif isinstance(node.parent, nodes.sidebar):
             self.body.append(self.defs['sidebar-title'][0])
         elif isinstance(node.parent, nodes.admonition):
             self.body.append('.IP "')
         elif self.section_level == 0:
             self._docinfo['title'] = node.astext()
             # document title for .TH
             self._docinfo['title_upper'] = node.astext().upper()
             raise nodes.SkipNode
         elif self.section_level == 1:
             self.body.append('.SH ')
             for n in node.traverse(nodes.Text):
                 n.parent.replace(n, nodes.Text(n.astext().upper()))
         else:
             self.body.append('.SS ')
 
     def depart_title(self, node):
         if isinstance(node.parent, nodes.admonition):
             self.body.append('"')
         self.body.append('\n')
 
     def visit_title_reference(self, node):
         """inline citation reference"""
         self.body.append(self.defs['title_reference'][0])
 
     def depart_title_reference(self, node):
         self.body.append(self.defs['title_reference'][1])
 
     def visit_topic(self, node):
         pass
 
     def depart_topic(self, node):
         pass
 
     def visit_sidebar(self, node):
         pass
 
     def depart_sidebar(self, node):
         pass
 
     def visit_rubric(self, node):
         pass
 
     def depart_rubric(self, node):
         pass
 
     def visit_transition(self, node):
         # .PP      Begin a new paragraph and reset prevailing indent.
         # .sp N    leaves N lines of blank space.
         # .ce      centers the next line
         self.body.append('\n.sp\n.ce\n----\n')
 
     def depart_transition(self, node):
         self.body.append('\n.ce 0\n.sp\n')
 
     def visit_version(self, node):
         self.visit_docinfo_item(node, 'version')
 
     def visit_warning(self, node):
         self.visit_admonition(node, 'warning')
 
     depart_warning = depart_admonition
 
     def unimplemented_visit(self, node):
         raise NotImplementedError('visiting unimplemented node type: %s'
                                   % node.__class__.__name__)
 
 # vim: set fileencoding=utf-8 et ts=4 ai :

i18n/polib.py

@@ -1,1681 +1,1680 b''
-#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # no-check-code
 #
 # License: MIT (see LICENSE file provided)
 # vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4:
 
 """
 **polib** allows you to manipulate, create, modify gettext files (pot, po
 and mo files).  You can load existing files, iterate through it's entries,
 add, modify entries, comments or metadata, etc... or create new po files
 from scratch.
 
 **polib** provides a simple and pythonic API, exporting only three
 convenience functions (*pofile*, *mofile* and *detect_encoding*), and the
 four core classes, *POFile*, *MOFile*, *POEntry* and *MOEntry* for creating
 new files/entries.
 
 **Basic example**:
 
 >>> import polib
 >>> # load an existing po file
 >>> po = polib.pofile('tests/test_utf8.po')
 >>> for entry in po:
 ...     # do something with entry...
 ...     pass
 >>> # add an entry
 >>> entry = polib.POEntry(msgid='Welcome', msgstr='Bienvenue')
 >>> entry.occurrences = [('welcome.py', '12'), ('anotherfile.py', '34')]
 >>> po.append(entry)
 >>> # to save our modified po file:
 >>> # po.save()
 >>> # or you may want to compile the po file
 >>> # po.save_as_mofile('tests/test_utf8.mo')
 """
 
 __author__    = 'David JEAN LOUIS <[e-mail]>'
 __version__   = '0.5.2'
 __all__       = ['pofile', 'POFile', 'POEntry', 'mofile', 'MOFile', 'MOEntry',
                  'detect_encoding', 'escape', 'unescape', 'detect_encoding',]
 
 import codecs
 import struct
 import textwrap
 import types
 import re
 
 default_encoding = 'utf-8'
 
 # function pofile() {{{
 
 def pofile(fpath, **kwargs):
     """
     Convenience function that parse the po/pot file *fpath* and return
     a POFile instance.
 
     **Keyword arguments**:
       - *fpath*: string, full or relative path to the po/pot file to parse
       - *wrapwidth*: integer, the wrap width, only useful when -w option was
         passed to xgettext (optional, default to 78)
       - *autodetect_encoding*: boolean, if set to False the function will
         not try to detect the po file encoding (optional, default to True)
       - *encoding*: string, an encoding, only relevant if autodetect_encoding
         is set to False
       - *check_for_duplicates*: whether to check for duplicate entries when
         adding entries to the file, default: False (optional)
 
     **Example**:
 
     >>> import polib
     >>> po = polib.pofile('tests/test_weird_occurrences.po',
     ...     check_for_duplicates=True)
     >>> po #doctest: +ELLIPSIS
     <POFile instance at ...>
     >>> import os, tempfile
     >>> all_attrs = ('msgctxt', 'msgid', 'msgstr', 'msgid_plural', 
     ...              'msgstr_plural', 'obsolete', 'comment', 'tcomment', 
     ...              'occurrences', 'flags', 'previous_msgctxt', 
     ...              'previous_msgid', 'previous_msgid_plural')
     >>> for fname in ['test_iso-8859-15.po', 'test_utf8.po']:
     ...     orig_po = polib.pofile('tests/'+fname)
     ...     tmpf = tempfile.NamedTemporaryFile().name
     ...     orig_po.save(tmpf)
     ...     try:
     ...         new_po = polib.pofile(tmpf)
     ...         for old, new in zip(orig_po, new_po):
     ...             for attr in all_attrs:
     ...                 if getattr(old, attr) != getattr(new, attr):
     ...                     getattr(old, attr)
     ...                     getattr(new, attr)
     ...     finally:
     ...         os.unlink(tmpf)
     >>> po_file = polib.pofile('tests/test_save_as_mofile.po')
     >>> tmpf = tempfile.NamedTemporaryFile().name
     >>> po_file.save_as_mofile(tmpf)
     >>> try:
     ...     mo_file = polib.mofile(tmpf)
     ...     for old, new in zip(po_file, mo_file):
     ...         if po_file._encode(old.msgid) != mo_file._encode(new.msgid):
     ...             'OLD: ', po_file._encode(old.msgid)
     ...             'NEW: ', mo_file._encode(new.msgid)
     ...         if po_file._encode(old.msgstr) != mo_file._encode(new.msgstr):
     ...             'OLD: ', po_file._encode(old.msgstr)
     ...             'NEW: ', mo_file._encode(new.msgstr)
     ...             print new.msgstr
     ... finally:
     ...     os.unlink(tmpf)
     """
     if kwargs.get('autodetect_encoding', True) == True:
         enc = detect_encoding(fpath)
     else:
         enc = kwargs.get('encoding', default_encoding)
     check_for_duplicates = kwargs.get('check_for_duplicates', False)
     parser = _POFileParser(
         fpath,
         encoding=enc,
         check_for_duplicates=kwargs.get('check_for_duplicates', False)
     )
     instance = parser.parse()
     instance.wrapwidth = kwargs.get('wrapwidth', 78)
     return instance
 
 # }}}
 # function mofile() {{{
 
 def mofile(fpath, **kwargs):
     """
     Convenience function that parse the mo file *fpath* and return
     a MOFile instance.
 
     **Keyword arguments**:
       - *fpath*: string, full or relative path to the mo file to parse
       - *wrapwidth*: integer, the wrap width, only useful when -w option was
         passed to xgettext to generate the po file that was used to format
         the mo file (optional, default to 78)
       - *autodetect_encoding*: boolean, if set to False the function will
         not try to detect the po file encoding (optional, default to True)
       - *encoding*: string, an encoding, only relevant if autodetect_encoding
         is set to False
       - *check_for_duplicates*: whether to check for duplicate entries when
         adding entries to the file, default: False (optional)
 
     **Example**:
 
     >>> import polib
     >>> mo = polib.mofile('tests/test_utf8.mo', check_for_duplicates=True)
     >>> mo #doctest: +ELLIPSIS
     <MOFile instance at ...>
     >>> import os, tempfile
     >>> for fname in ['test_iso-8859-15.mo', 'test_utf8.mo']:
     ...     orig_mo = polib.mofile('tests/'+fname)
     ...     tmpf = tempfile.NamedTemporaryFile().name
     ...     orig_mo.save(tmpf)
     ...     try:
     ...         new_mo = polib.mofile(tmpf)
     ...         for old, new in zip(orig_mo, new_mo):
     ...             if old.msgid != new.msgid:
     ...                 old.msgstr
     ...                 new.msgstr
     ...     finally:
     ...         os.unlink(tmpf)
     """
     if kwargs.get('autodetect_encoding', True) == True:
         enc = detect_encoding(fpath, True)
     else:
         enc = kwargs.get('encoding', default_encoding)
     parser = _MOFileParser(
         fpath,
         encoding=enc,
         check_for_duplicates=kwargs.get('check_for_duplicates', False)
     )
     instance = parser.parse()
     instance.wrapwidth = kwargs.get('wrapwidth', 78)
     return instance
 
 # }}}
 # function detect_encoding() {{{
 
 def detect_encoding(fpath, binary_mode=False):
     """
     Try to detect the encoding used by the file *fpath*. The function will
     return polib default *encoding* if it's unable to detect it.
 
     **Keyword argument**:
       - *fpath*: string, full or relative path to the mo file to parse.
 
     **Examples**:
 
     >>> print(detect_encoding('tests/test_noencoding.po'))
     utf-8
     >>> print(detect_encoding('tests/test_utf8.po'))
     UTF-8
     >>> print(detect_encoding('tests/test_utf8.mo', True))
     UTF-8
     >>> print(detect_encoding('tests/test_iso-8859-15.po'))
     ISO_8859-15
     >>> print(detect_encoding('tests/test_iso-8859-15.mo', True))
     ISO_8859-15
     """
     import re
     rx = re.compile(r'"?Content-Type:.+? charset=([\w_\-:\.]+)')
     if binary_mode:
         mode = 'rb'
     else:
         mode = 'r'
     f = open(fpath, mode)
     for l in f.readlines():
         match = rx.search(l)
         if match:
             f.close()
             return match.group(1).strip()
     f.close()
     return default_encoding
 
 # }}}
 # function escape() {{{
 
 def escape(st):
     """
     Escape special chars and return the given string *st*.
 
     **Examples**:
 
     >>> escape('\\t and \\n and \\r and " and \\\\')
     '\\\\t and \\\\n and \\\\r and \\\\" and \\\\\\\\'
     """
     return st.replace('\\', r'\\')\
              .replace('\t', r'\t')\
              .replace('\r', r'\r')\
              .replace('\n', r'\n')\
              .replace('\"', r'\"')
 
 # }}}
 # function unescape() {{{
 
 def unescape(st):
     """
     Unescape special chars and return the given string *st*.
 
     **Examples**:
 
     >>> unescape('\\\\t and \\\\n and \\\\r and \\\\" and \\\\\\\\')
     '\\t and \\n and \\r and " and \\\\'
     >>> unescape(r'\\n')
     '\\n'
     >>> unescape(r'\\\\n')
     '\\\\n'
     >>> unescape(r'\\\\n\\n')
     '\\\\n\\n'
     """
     def unescape_repl(m):
         m = m.group(1)
         if m == 'n':
             return '\n'
         if m == 't':
             return '\t'
         if m == 'r':
             return '\r'
         if m == '\\':
             return '\\'
         return m # handles escaped double quote
     return re.sub(r'\\(\\|n|t|r|")', unescape_repl, st)
 
 # }}}
 # class _BaseFile {{{
 
 class _BaseFile(list):
     """
     Common parent class for POFile and MOFile classes.
     This class must **not** be instanciated directly.
     """
 
     def __init__(self, *args, **kwargs):
         """
         Constructor.
 
         **Keyword arguments**:
           - *fpath*: string, path to po or mo file
           - *wrapwidth*: integer, the wrap width, only useful when -w option
             was passed to xgettext to generate the po file that was used to
             format the mo file, default to 78 (optional),
           - *encoding*: string, the encoding to use, defaults to
             "default_encoding" global variable (optional),
           - *check_for_duplicates*: whether to check for duplicate entries
             when adding entries to the file, default: False (optional).
         """
         list.__init__(self)
         # the opened file handle
         self.fpath = kwargs.get('fpath')
         # the width at which lines should be wrapped
         self.wrapwidth = kwargs.get('wrapwidth', 78)
         # the file encoding
         self.encoding = kwargs.get('encoding', default_encoding)
         # whether to check for duplicate entries or not
         self.check_for_duplicates = kwargs.get('check_for_duplicates', False)
         # header
         self.header = ''
         # both po and mo files have metadata
         self.metadata = {}
         self.metadata_is_fuzzy = 0
 
     def __str__(self):
         """
         String representation of the file.
         """
         ret = []
         entries = [self.metadata_as_entry()] + \
                   [e for e in self if not e.obsolete]
         for entry in entries:
             ret.append(entry.__str__(self.wrapwidth))
         for entry in self.obsolete_entries():
             ret.append(entry.__str__(self.wrapwidth))
         return '\n'.join(ret)
 
     def __contains__(self, entry):
         """
         Overriden method to implement the membership test (in and not in).
         The method considers that an entry is in the file if it finds an 
         entry that has the same msgid (case sensitive).
 
         **Keyword argument**:
           - *entry*: an instance of polib._BaseEntry
 
         **Tests**:
         >>> po = POFile()
         >>> e1 = POEntry(msgid='foobar', msgstr='spam')
         >>> e2 = POEntry(msgid='barfoo', msgstr='spam')
         >>> e3 = POEntry(msgid='foobar', msgstr='eggs')
         >>> e4 = POEntry(msgid='spameggs', msgstr='eggs')
         >>> po.append(e1)
         >>> po.append(e2)
         >>> e1 in po
         True
         >>> e2 not in po
         False
         >>> e3 in po
         True
         >>> e4 in po
         False
         """
         return self.find(entry.msgid, by='msgid') is not None
 
     def append(self, entry):
         """
         Overriden method to check for duplicates entries, if a user tries to
         add an entry that already exists, the method will raise a ValueError
         exception.
 
         **Keyword argument**:
           - *entry*: an instance of polib._BaseEntry
 
         **Tests**:
         >>> e1 = POEntry(msgid='foobar', msgstr='spam')
         >>> e2 = POEntry(msgid='foobar', msgstr='eggs')
         >>> po = POFile(check_for_duplicates=True)
         >>> po.append(e1)
         >>> try:
         ...     po.append(e2)
         ... except ValueError, e:
         ...     unicode(e)
         u'Entry "foobar" already exists'
         """
         if self.check_for_duplicates and entry in self:
             raise ValueError('Entry "%s" already exists' % entry.msgid)
         super(_BaseFile, self).append(entry)
 
     def insert(self, index, entry):
         """
         Overriden method to check for duplicates entries, if a user tries to
         insert an entry that already exists, the method will raise a ValueError
         exception.
 
         **Keyword arguments**:
           - *index*: index at which the entry should be inserted
           - *entry*: an instance of polib._BaseEntry
 
         **Tests**:
         >>> import polib
         >>> polib.check_for_duplicates = True
         >>> e1 = POEntry(msgid='foobar', msgstr='spam')
         >>> e2 = POEntry(msgid='barfoo', msgstr='eggs')
         >>> e3 = POEntry(msgid='foobar', msgstr='eggs')
         >>> po = POFile(check_for_duplicates=True)
         >>> po.insert(0, e1)
         >>> po.insert(1, e2)
         >>> try:
         ...     po.insert(0, e3)
         ... except ValueError, e:
         ...     unicode(e)
         u'Entry "foobar" already exists'
         """
         if self.check_for_duplicates and entry in self:
             raise ValueError('Entry "%s" already exists' % entry.msgid)
         super(_BaseFile, self).insert(index, entry)
 
     def __repr__(self):
         """Return the official string representation of the object."""
         return '<%s instance at %x>' % (self.__class__.__name__, id(self))
 
     def metadata_as_entry(self):
         """
         Return the metadata as an entry:
 
         >>> import polib
         >>> po = polib.pofile('tests/test_fuzzy_header.po')
         >>> unicode(po) == unicode(open('tests/test_fuzzy_header.po').read())
         True
         """
         e = POEntry(msgid='')
         mdata = self.ordered_metadata()
         if mdata:
             strs = []
             e._multiline_str['msgstr'] = ''
             for name, value in mdata:
                 # Strip whitespace off each line in a multi-line entry
                 strs.append('%s: %s' % (name, value))
             e.msgstr = '\n'.join(strs) + '\n'
             e._multiline_str['msgstr'] = '__POLIB__NL__'.join(
                     [s + '\n' for s in strs])
         if self.metadata_is_fuzzy:
             e.flags.append('fuzzy')
         return e
 
     def save(self, fpath=None, repr_method='__str__'):
         """
         Save the po file to file *fpath* if no file handle exists for
         the object. If there's already an open file and no fpath is
         provided, then the existing file is rewritten with the modified
         data.
 
         **Keyword arguments**:
           - *fpath*: string, full or relative path to the file.
           - *repr_method*: string, the method to use for output.
         """
         if self.fpath is None and fpath is None:
             raise IOError('You must provide a file path to save() method')
         contents = getattr(self, repr_method)()
         if fpath is None:
             fpath = self.fpath
         if repr_method == 'to_binary':
             fhandle = open(fpath, 'wb')
         else:
             fhandle = codecs.open(fpath, 'w', self.encoding)
             if type(contents) != types.UnicodeType:
                 contents = contents.decode(self.encoding)
         fhandle.write(contents)
         fhandle.close()
 
     def find(self, st, by='msgid'):
         """
         Find entry which msgid (or property identified by the *by*
         attribute) matches the string *st*.
 
         **Keyword arguments**:
           - *st*: string, the string to search for
           - *by*: string, the comparison attribute
 
         **Examples**:
 
         >>> po = pofile('tests/test_utf8.po')
         >>> entry = po.find('Thursday')
         >>> entry.msgstr
         u'Jueves'
         >>> entry = po.find('Some unexistant msgid')
         >>> entry is None
         True
         >>> entry = po.find('Jueves', 'msgstr')
         >>> entry.msgid
         u'Thursday'
         """
         for e in self:
             if getattr(e, by) == st:
                 return e
         return None
 
     def ordered_metadata(self):
         """
         Convenience method that return the metadata ordered. The return
         value is list of tuples (metadata name, metadata_value).
         """
         # copy the dict first
         metadata = self.metadata.copy()
         data_order = [
             'Project-Id-Version',
             'Report-Msgid-Bugs-To',
             'POT-Creation-Date',
             'PO-Revision-Date',
             'Last-Translator',
             'Language-Team',
             'MIME-Version',
             'Content-Type',
             'Content-Transfer-Encoding'
         ]
         ordered_data = []
         for data in data_order:
             try:
                 value = metadata.pop(data)
                 ordered_data.append((data, value))
             except KeyError:
                 pass
         # the rest of the metadata won't be ordered there are no specs for this
         keys = metadata.keys()
         list(keys).sort()
         for data in keys:
             value = metadata[data]
             ordered_data.append((data, value))
         return ordered_data
 
     def to_binary(self):
         """
         Return the mofile binary representation.
         """
         import array
         import struct
         import types
         offsets = []
         entries = self.translated_entries()
         # the keys are sorted in the .mo file
         def cmp(_self, other):
             if _self.msgid > other.msgid:
                 return 1
             elif _self.msgid < other.msgid:
                 return -1
             else:
                 return 0
         # add metadata entry
         entries.sort(cmp)
         mentry = self.metadata_as_entry()
         mentry.msgstr = mentry.msgstr.replace('\\n', '').lstrip()
         entries = [mentry] + entries
         entries_len = len(entries)
         ids, strs = '', ''
         for e in entries:
             # For each string, we need size and file offset.  Each string is
             # NUL terminated; the NUL does not count into the size.
             if e.msgid_plural:
                 indexes = e.msgstr_plural.keys()
                 indexes.sort()
                 msgstr = []
                 for index in indexes:
                     msgstr.append(e.msgstr_plural[index])
                 msgid = self._encode(e.msgid + '\0' + e.msgid_plural)
                 msgstr = self._encode('\0'.join(msgstr))
             else:
                 msgid = self._encode(e.msgid)
                 msgstr = self._encode(e.msgstr)
             offsets.append((len(ids), len(msgid), len(strs), len(msgstr)))
             ids  += msgid  + '\0'
             strs += msgstr + '\0'
         # The header is 7 32-bit unsigned integers.
         keystart = 7*4+16*entries_len
         # and the values start after the keys
         valuestart = keystart + len(ids)
         koffsets = []
         voffsets = []
         # The string table first has the list of keys, then the list of values.
         # Each entry has first the size of the string, then the file offset.
         for o1, l1, o2, l2 in offsets:
             koffsets += [l1, o1+keystart]
             voffsets += [l2, o2+valuestart]
         offsets = koffsets + voffsets
         output  = struct.pack("IIIIIII",
                              0x950412de,        # Magic number
                              0,                 # Version
                              entries_len,       # # of entries
                              7*4,               # start of key index
                              7*4+entries_len*8, # start of value index
                              0, 0)              # size and offset of hash table
         output += array.array("I", offsets).tostring()
         output += ids
         output += strs
         return output
 
     def _encode(self, mixed):
         """
         Encode the given argument with the file encoding if the type is unicode
         and return the encoded string.
         """
         if type(mixed) == types.UnicodeType:
             return mixed.encode(self.encoding)
         return mixed
 
 # }}}
 # class POFile {{{
 
 class POFile(_BaseFile):
     '''
     Po (or Pot) file reader/writer.
     POFile objects inherit the list objects methods.
 
     **Example**:
 
     >>> po = POFile()
     >>> entry1 = POEntry(
     ...     msgid="Some english text",
     ...     msgstr="Un texte en anglais"
     ... )
     >>> entry1.occurrences = [('testfile', 12),('another_file', 1)]
     >>> entry1.comment = "Some useful comment"
     >>> entry2 = POEntry(
     ...     msgid="Peace in some languages",
     ...     msgstr="Pace سلام שלום Hasîtî 和平"
     ... )
     >>> entry2.occurrences = [('testfile', 15),('another_file', 5)]
     >>> entry2.comment = "Another useful comment"
     >>> entry3 = POEntry(
     ...     msgid='Some entry with quotes " \\"',
     ...     msgstr='Un message unicode avec des quotes " \\"'
     ... )
     >>> entry3.comment = "Test string quoting"
     >>> po.append(entry1)
     >>> po.append(entry2)
     >>> po.append(entry3)
     >>> po.header = "Some Header"
     >>> print(po)
     # Some Header
     msgid ""
     msgstr ""
     <BLANKLINE>
     #. Some useful comment
     #: testfile:12 another_file:1
     msgid "Some english text"
     msgstr "Un texte en anglais"
     <BLANKLINE>
     #. Another useful comment
     #: testfile:15 another_file:5
     msgid "Peace in some languages"
     msgstr "Pace سلام שלום Hasîtî 和平"
     <BLANKLINE>
     #. Test string quoting
     msgid "Some entry with quotes \\" \\""
     msgstr "Un message unicode avec des quotes \\" \\""
     <BLANKLINE>
     '''
 
     def __str__(self):
         """Return the string representation of the po file"""
         ret, headers = '', self.header.split('\n')
         for header in headers:
             if header[:1] in [',', ':']:
                 ret += '#%s\n' % header
             else:
                 ret += '# %s\n' % header
         return ret + _BaseFile.__str__(self)
 
     def save_as_mofile(self, fpath):
         """
         Save the binary representation of the file to *fpath*.
 
         **Keyword arguments**:
           - *fpath*: string, full or relative path to the file.
         """
         _BaseFile.save(self, fpath, 'to_binary')
 
     def percent_translated(self):
         """
         Convenience method that return the percentage of translated
         messages.
 
         **Example**:
 
         >>> import polib
         >>> po = polib.pofile('tests/test_pofile_helpers.po')
         >>> po.percent_translated()
         50
         >>> po = POFile()
         >>> po.percent_translated()
         100
         """
         total = len([e for e in self if not e.obsolete])
         if total == 0:
             return 100
         translated = len(self.translated_entries())
         return int((100.00 / float(total)) * translated)
 
     def translated_entries(self):
         """
         Convenience method that return a list of translated entries.
 
         **Example**:
 
         >>> import polib
         >>> po = polib.pofile('tests/test_pofile_helpers.po')
         >>> len(po.translated_entries())
         6
         """
         return [e for e in self if e.translated()]
 
     def untranslated_entries(self):
         """
         Convenience method that return a list of untranslated entries.
 
         **Example**:
 
         >>> import polib
         >>> po = polib.pofile('tests/test_pofile_helpers.po')
         >>> len(po.untranslated_entries())
         4
         """
         return [e for e in self if not e.translated() and not e.obsolete \
                 and not 'fuzzy' in e.flags]
 
     def fuzzy_entries(self):
         """
         Convenience method that return the list of 'fuzzy' entries.
 
         **Example**:
 
         >>> import polib
         >>> po = polib.pofile('tests/test_pofile_helpers.po')
         >>> len(po.fuzzy_entries())
         2
         """
         return [e for e in self if 'fuzzy' in e.flags]
 
     def obsolete_entries(self):
         """
         Convenience method that return the list of obsolete entries.
 
         **Example**:
 
         >>> import polib
         >>> po = polib.pofile('tests/test_pofile_helpers.po')
         >>> len(po.obsolete_entries())
         4
         """
         return [e for e in self if e.obsolete]
 
     def merge(self, refpot):
         """
         XXX this could not work if encodings are different, needs thinking
         and general refactoring of how polib handles encoding...
 
         Convenience method that merge the current pofile with the pot file
         provided. It behaves exactly as the gettext msgmerge utility:
 
           - comments of this file will be preserved, but extracted comments
             and occurrences will be discarded
           - any translations or comments in the file will be discarded,
             however dot comments and file positions will be preserved
 
         **Keyword argument**:
           - *refpot*: object POFile, the reference catalog.
 
         **Example**:
 
         >>> import polib
         >>> refpot = polib.pofile('tests/test_merge.pot')
         >>> po = polib.pofile('tests/test_merge_before.po')
         >>> po.merge(refpot)
         >>> expected_po = polib.pofile('tests/test_merge_after.po')
         >>> unicode(po) == unicode(expected_po)
         True
         """
         for entry in refpot:
             e = self.find(entry.msgid)
             if e is None:
                 e = POEntry()
                 self.append(e)
             e.merge(entry)
         # ok, now we must "obsolete" entries that are not in the refpot
         # anymore
         for entry in self:
             if refpot.find(entry.msgid) is None:
                 entry.obsolete = True
 
 # }}}
 # class MOFile {{{
 
 class MOFile(_BaseFile):
     '''
     Mo file reader/writer.
     MOFile objects inherit the list objects methods.
 
     **Example**:
 
     >>> mo = MOFile()
     >>> entry1 = POEntry(
     ...     msgid="Some english text",
     ...     msgstr="Un texte en anglais"
     ... )
     >>> entry2 = POEntry(
     ...     msgid="I need my dirty cheese",
     ...     msgstr="Je veux mon sale fromage"
     ... )
     >>> entry3 = MOEntry(
     ...     msgid='Some entry with quotes " \\"',
     ...     msgstr='Un message unicode avec des quotes " \\"'
     ... )
     >>> mo.append(entry1)
     >>> mo.append(entry2)
     >>> mo.append(entry3)
     >>> print(mo)
     msgid ""
     msgstr ""
     <BLANKLINE>
     msgid "Some english text"
     msgstr "Un texte en anglais"
     <BLANKLINE>
     msgid "I need my dirty cheese"
     msgstr "Je veux mon sale fromage"
     <BLANKLINE>
     msgid "Some entry with quotes \\" \\""
     msgstr "Un message unicode avec des quotes \\" \\""
     <BLANKLINE>
     '''
 
     def __init__(self, *args, **kwargs):
         """
         MOFile constructor. Mo files have two other properties:
             - magic_number: the magic_number of the binary file,
             - version: the version of the mo spec.
         """
         _BaseFile.__init__(self, *args, **kwargs)
         self.magic_number = None
         self.version = 0
 
     def save_as_pofile(self, fpath):
         """
         Save the string representation of the file to *fpath*.
 
         **Keyword argument**:
           - *fpath*: string, full or relative path to the file.
         """
         _BaseFile.save(self, fpath)
 
     def save(self, fpath):
         """
         Save the binary representation of the file to *fpath*.
 
         **Keyword argument**:
           - *fpath*: string, full or relative path to the file.
         """
         _BaseFile.save(self, fpath, 'to_binary')
 
     def percent_translated(self):
         """
         Convenience method to keep the same interface with POFile instances.
         """
         return 100
 
     def translated_entries(self):
         """
         Convenience method to keep the same interface with POFile instances.
         """
         return self
 
     def untranslated_entries(self):
         """
         Convenience method to keep the same interface with POFile instances.
         """
         return []
 
     def fuzzy_entries(self):
         """
         Convenience method to keep the same interface with POFile instances.
         """
         return []
 
     def obsolete_entries(self):
         """
         Convenience method to keep the same interface with POFile instances.
         """
         return []
 
 # }}}
 # class _BaseEntry {{{
 
 class _BaseEntry(object):
     """
     Base class for POEntry or MOEntry objects.
     This class must *not* be instanciated directly.
     """
 
     def __init__(self, *args, **kwargs):
         """Base Entry constructor."""
         self.msgid = kwargs.get('msgid', '')
         self.msgstr = kwargs.get('msgstr', '')
         self.msgid_plural = kwargs.get('msgid_plural', '')
         self.msgstr_plural = kwargs.get('msgstr_plural', {})
         self.obsolete = kwargs.get('obsolete', False)
         self.encoding = kwargs.get('encoding', default_encoding)
         self.msgctxt = kwargs.get('msgctxt', None)
         self._multiline_str = {}
 
     def __repr__(self):
         """Return the official string representation of the object."""
         return '<%s instance at %x>' % (self.__class__.__name__, id(self))
 
     def __str__(self, wrapwidth=78):
         """
         Common string representation of the POEntry and MOEntry
         objects.
         """
         if self.obsolete:
             delflag = '#~ '
         else:
             delflag = ''
         ret = []
         # write the msgctxt if any
         if self.msgctxt is not None:
             ret += self._str_field("msgctxt", delflag, "", self.msgctxt)
         # write the msgid
         ret += self._str_field("msgid", delflag, "", self.msgid)
         # write the msgid_plural if any
         if self.msgid_plural:
             ret += self._str_field("msgid_plural", delflag, "", self.msgid_plural)
         if self.msgstr_plural:
             # write the msgstr_plural if any
             msgstrs = self.msgstr_plural
             keys = list(msgstrs)
             keys.sort()
             for index in keys:
                 msgstr = msgstrs[index]
                 plural_index = '[%s]' % index
                 ret += self._str_field("msgstr", delflag, plural_index, msgstr)
         else:
             # otherwise write the msgstr
             ret += self._str_field("msgstr", delflag, "", self.msgstr)
         ret.append('')
         return '\n'.join(ret)
 
     def _str_field(self, fieldname, delflag, plural_index, field):
         if (fieldname + plural_index) in self._multiline_str:
             field = self._multiline_str[fieldname + plural_index]
             lines = [''] + field.split('__POLIB__NL__')
         else:
             lines = field.splitlines(True)
             if len(lines) > 1:
                 lines = ['']+lines # start with initial empty line
             else:
                 lines = [field] # needed for the empty string case
         if fieldname.startswith('previous_'):
             # quick and dirty trick to get the real field name
             fieldname = fieldname[9:]
 
         ret = ['%s%s%s "%s"' % (delflag, fieldname, plural_index,
                                 escape(lines.pop(0)))]
         for mstr in lines:
             ret.append('%s"%s"' % (delflag, escape(mstr)))
         return ret
 
 # }}}
 # class POEntry {{{
 
 class POEntry(_BaseEntry):
     """
     Represents a po file entry.
 
     **Examples**:
 
     >>> entry = POEntry(msgid='Welcome', msgstr='Bienvenue')
     >>> entry.occurrences = [('welcome.py', 12), ('anotherfile.py', 34)]
     >>> print(entry)
     #: welcome.py:12 anotherfile.py:34
     msgid "Welcome"
     msgstr "Bienvenue"
     <BLANKLINE>
     >>> entry = POEntry()
     >>> entry.occurrences = [('src/some-very-long-filename-that-should-not-be-wrapped-even-if-it-is-larger-than-the-wrap-limit.c', 32), ('src/eggs.c', 45)]
     >>> entry.comment = 'A plural translation. This is a very very very long line please do not wrap, this is just for testing comment wrapping...'
     >>> entry.tcomment = 'A plural translation. This is a very very very long line please do not wrap, this is just for testing comment wrapping...'
     >>> entry.flags.append('c-format')
     >>> entry.previous_msgctxt = '@somecontext'
     >>> entry.previous_msgid = 'I had eggs but no spam !'
     >>> entry.previous_msgid_plural = 'I had eggs and %d spam !'
     >>> entry.msgctxt = '@somenewcontext'
     >>> entry.msgid = 'I have spam but no egg !'
     >>> entry.msgid_plural = 'I have spam and %d eggs !'
     >>> entry.msgstr_plural[0] = "J'ai du jambon mais aucun oeuf !"
     >>> entry.msgstr_plural[1] = "J'ai du jambon et %d oeufs !"
     >>> print(entry)
     #. A plural translation. This is a very very very long line please do not
     #. wrap, this is just for testing comment wrapping...
     # A plural translation. This is a very very very long line please do not wrap,
     # this is just for testing comment wrapping...
     #: src/some-very-long-filename-that-should-not-be-wrapped-even-if-it-is-larger-than-the-wrap-limit.c:32
     #: src/eggs.c:45
     #, c-format
     #| msgctxt "@somecontext"
     #| msgid "I had eggs but no spam !"
     #| msgid_plural "I had eggs and %d spam !"
     msgctxt "@somenewcontext"
     msgid "I have spam but no egg !"
     msgid_plural "I have spam and %d eggs !"
     msgstr[0] "J'ai du jambon mais aucun oeuf !"
     msgstr[1] "J'ai du jambon et %d oeufs !"
     <BLANKLINE>
     """
 
     def __init__(self, *args, **kwargs):
         """POEntry constructor."""
         _BaseEntry.__init__(self, *args, **kwargs)
         self.comment = kwargs.get('comment', '')
         self.tcomment = kwargs.get('tcomment', '')
         self.occurrences = kwargs.get('occurrences', [])
         self.flags = kwargs.get('flags', [])
         self.previous_msgctxt = kwargs.get('previous_msgctxt', None)
         self.previous_msgid = kwargs.get('previous_msgid', None)
         self.previous_msgid_plural = kwargs.get('previous_msgid_plural', None)
 
     def __str__(self, wrapwidth=78):
         """
         Return the string representation of the entry.
         """
         if self.obsolete:
             return _BaseEntry.__str__(self)
         ret = []
         # comment first, if any (with text wrapping as xgettext does)
         if self.comment != '':
             for comment in self.comment.split('\n'):
                 if wrapwidth > 0 and len(comment) > wrapwidth-3:
                     ret += textwrap.wrap(comment, wrapwidth,
                                          initial_indent='#. ',
                                          subsequent_indent='#. ',
                                          break_long_words=False)
                 else:
                     ret.append('#. %s' % comment)
         # translator comment, if any (with text wrapping as xgettext does)
         if self.tcomment != '':
             for tcomment in self.tcomment.split('\n'):
                 if wrapwidth > 0 and len(tcomment) > wrapwidth-2:
                     ret += textwrap.wrap(tcomment, wrapwidth,
                                          initial_indent='# ',
                                          subsequent_indent='# ',
                                          break_long_words=False)
                 else:
                     ret.append('# %s' % tcomment)
         # occurrences (with text wrapping as xgettext does)
         if self.occurrences:
             filelist = []
             for fpath, lineno in self.occurrences:
                 if lineno:
                     filelist.append('%s:%s' % (fpath, lineno))
                 else:
                     filelist.append(fpath)
             filestr = ' '.join(filelist)
             if wrapwidth > 0 and len(filestr)+3 > wrapwidth:
                 # XXX textwrap split words that contain hyphen, this is not 
                 # what we want for filenames, so the dirty hack is to 
                 # temporally replace hyphens with a char that a file cannot 
                 # contain, like "*"
                 lines = textwrap.wrap(filestr.replace('-', '*'),
                                       wrapwidth,
                                       initial_indent='#: ',
                                       subsequent_indent='#: ',
                                       break_long_words=False)
                 # end of the replace hack
                 for line in lines:
                     ret.append(line.replace('*', '-'))
             else:
                 ret.append('#: '+filestr)
         # flags
         if self.flags:
             flags = []
             for flag in self.flags:
                 flags.append(flag)
             ret.append('#, %s' % ', '.join(flags))
 
         # previous context and previous msgid/msgid_plural
         if self.previous_msgctxt:
             ret += self._str_field("previous_msgctxt", "#| ", "",
                                    self.previous_msgctxt)
         if self.previous_msgid:
             ret += self._str_field("previous_msgid", "#| ", "", 
                                    self.previous_msgid)
         if self.previous_msgid_plural:
             ret += self._str_field("previous_msgid_plural", "#| ", "", 
                                    self.previous_msgid_plural)
 
         ret.append(_BaseEntry.__str__(self))
         return '\n'.join(ret)
 
     def __cmp__(self, other):
         '''
         Called by comparison operations if rich comparison is not defined.
 
         **Tests**:
         >>> a  = POEntry(msgid='a', occurrences=[('b.py', 1), ('b.py', 3)])
         >>> b  = POEntry(msgid='b', occurrences=[('b.py', 1), ('b.py', 3)])
         >>> c1 = POEntry(msgid='c1', occurrences=[('a.py', 1), ('b.py', 1)])
         >>> c2 = POEntry(msgid='c2', occurrences=[('a.py', 1), ('a.py', 3)])
         >>> po = POFile()
         >>> po.append(a)
         >>> po.append(b)
         >>> po.append(c1)
         >>> po.append(c2)
         >>> po.sort()
         >>> print(po)
         # 
         msgid ""
         msgstr ""
         <BLANKLINE>
         #: a.py:1 a.py:3
         msgid "c2"
         msgstr ""
         <BLANKLINE>
         #: a.py:1 b.py:1
         msgid "c1"
         msgstr ""
         <BLANKLINE>
         #: b.py:1 b.py:3
         msgid "a"
         msgstr ""
         <BLANKLINE>
         #: b.py:1 b.py:3
         msgid "b"
         msgstr ""
         <BLANKLINE>
         '''
         def compare_occurrences(a, b):
             """
             Compare an entry occurrence with another one.
             """
             if a[0] != b[0]:
                 return a[0] < b[0]
             if a[1] != b[1]:
                 return a[1] < b[1]
             return 0
 
         # First: Obsolete test
         if self.obsolete != other.obsolete:
             if self.obsolete:
                 return -1
             else:
                 return 1
         # Work on a copy to protect original
         occ1 = self.occurrences[:]
         occ2 = other.occurrences[:]
         # Sorting using compare method
         occ1.sort(compare_occurrences)
         occ2.sort(compare_occurrences)
         # Comparing sorted occurrences
         pos = 0
         for entry1 in occ1:
             try:
                 entry2 = occ2[pos]
             except IndexError:
                 return 1
             pos = pos + 1
             if entry1[0] != entry2[0]:
                 if entry1[0] > entry2[0]:
                     return 1
                 else:
                     return -1
             if entry1[1] != entry2[1]:
                 if entry1[1] > entry2[1]:
                     return 1
                 else:
                     return -1
         # Finally: Compare message ID
         if self.msgid > other.msgid: return 1
         else: return -1
 
     def translated(self):
         """
         Return True if the entry has been translated or False.
         """
         if self.obsolete or 'fuzzy' in self.flags:
             return False
         if self.msgstr != '':
             return True
         if self.msgstr_plural:
             for pos in self.msgstr_plural:
                 if self.msgstr_plural[pos] == '':
                     return False
             return True
         return False
 
     def merge(self, other):
         """
         Merge the current entry with the given pot entry.
         """
         self.msgid        = other.msgid
         self.occurrences  = other.occurrences
         self.comment      = other.comment
         self.flags        = other.flags
         self.msgid_plural = other.msgid_plural
         if other.msgstr_plural:
             for pos in other.msgstr_plural:
                 try:
                     # keep existing translation at pos if any
                     self.msgstr_plural[pos]
                 except KeyError:
                     self.msgstr_plural[pos] = ''
 
 # }}}
 # class MOEntry {{{
 
 class MOEntry(_BaseEntry):
     """
     Represents a mo file entry.
 
     **Examples**:
 
     >>> entry = MOEntry()
     >>> entry.msgid  = 'translate me !'
     >>> entry.msgstr = 'traduisez moi !'
     >>> print(entry)
     msgid "translate me !"
     msgstr "traduisez moi !"
     <BLANKLINE>
     """
 
     def __str__(self, wrapwidth=78):
         """
         Return the string representation of the entry.
         """
         return _BaseEntry.__str__(self, wrapwidth)
 
 # }}}
 # class _POFileParser {{{
 
 class _POFileParser(object):
     """
     A finite state machine to parse efficiently and correctly po
     file format.
     """
 
     def __init__(self, fpath, *args, **kwargs):
         """
         Constructor.
 
         **Arguments**:
           - *fpath*: string, path to the po file
           - *encoding*: string, the encoding to use, defaults to
             "default_encoding" global variable (optional),
           - *check_for_duplicates*: whether to check for duplicate entries
             when adding entries to the file, default: False (optional).
         """
         enc = kwargs.get('encoding', default_encoding)
         check_dup = kwargs.get('check_for_duplicates', False)
         try:
             self.fhandle = codecs.open(fpath, 'rU', enc)
         except LookupError:
             enc = default_encoding
             self.fhandle = codecs.open(fpath, 'rU', enc)
         self.instance = POFile(
             fpath=fpath,
             encoding=enc,
             check_for_duplicates=check_dup
         )
         self.transitions = {}
         self.current_entry = POEntry()
         self.current_state = 'ST'
         self.current_token = None
         # two memo flags used in handlers
         self.msgstr_index = 0
         self.entry_obsolete = 0
         # Configure the state machine, by adding transitions.
         # Signification of symbols:
         #     * ST: Beginning of the file (start)
         #     * HE: Header
         #     * TC: a translation comment
         #     * GC: a generated comment
         #     * OC: a file/line occurence
         #     * FL: a flags line
         #     * CT: a message context
         #     * PC: a previous msgctxt
         #     * PM: a previous msgid
         #     * PP: a previous msgid_plural
         #     * MI: a msgid
         #     * MP: a msgid plural
         #     * MS: a msgstr
         #     * MX: a msgstr plural
         #     * MC: a msgid or msgstr continuation line
         all = ['ST', 'HE', 'GC', 'OC', 'FL', 'CT', 'PC', 'PM', 'PP', 'TC',
                'MS', 'MP', 'MX', 'MI']
 
         self.add('TC', ['ST', 'HE'],                                     'HE')
         self.add('TC', ['GC', 'OC', 'FL', 'TC', 'PC', 'PM', 'PP', 'MS',
                         'MP', 'MX', 'MI'],                               'TC')
         self.add('GC', all,                                              'GC')
         self.add('OC', all,                                              'OC')
         self.add('FL', all,                                              'FL')
         self.add('PC', all,                                              'PC')
         self.add('PM', all,                                              'PM')
         self.add('PP', all,                                              'PP')
         self.add('CT', ['ST', 'HE', 'GC', 'OC', 'FL', 'TC', 'PC', 'PM',
                         'PP', 'MS', 'MX'],                               'CT')
         self.add('MI', ['ST', 'HE', 'GC', 'OC', 'FL', 'CT', 'TC', 'PC', 
                  'PM', 'PP', 'MS', 'MX'],                                'MI')
         self.add('MP', ['TC', 'GC', 'PC', 'PM', 'PP', 'MI'],             'MP')
         self.add('MS', ['MI', 'MP', 'TC'],                               'MS')
         self.add('MX', ['MI', 'MX', 'MP', 'TC'],                         'MX')
         self.add('MC', ['CT', 'MI', 'MP', 'MS', 'MX', 'PM', 'PP', 'PC'], 'MC')
 
     def parse(self):
         """
         Run the state machine, parse the file line by line and call process()
         with the current matched symbol.
         """
         i, lastlen = 1, 0
         for line in self.fhandle:
             line = line.strip()
             if line == '':
                 i = i+1
                 continue
             if line[:3] == '#~ ':
                 line = line[3:]
                 self.entry_obsolete = 1
             else:
                 self.entry_obsolete = 0
             self.current_token = line
             if line[:2] == '#:':
                 # we are on a occurrences line
                 self.process('OC', i)
             elif line[:9] == 'msgctxt "':
                 # we are on a msgctxt
                 self.process('CT', i)
             elif line[:7] == 'msgid "':
                 # we are on a msgid
                 self.process('MI', i)
             elif line[:8] == 'msgstr "':
                 # we are on a msgstr
                 self.process('MS', i)
             elif line[:1] == '"' or line[:4] == '#| "':
                 # we are on a continuation line or some metadata
                 self.process('MC', i)
             elif line[:14] == 'msgid_plural "':
                 # we are on a msgid plural
                 self.process('MP', i)
             elif line[:7] == 'msgstr[':
                 # we are on a msgstr plural
                 self.process('MX', i)
             elif line[:3] == '#, ':
                 # we are on a flags line
                 self.process('FL', i)
             elif line[:2] == '# ' or line == '#':
                 if line == '#': line = line + ' '
                 # we are on a translator comment line
                 self.process('TC', i)
             elif line[:2] == '#.':
                 # we are on a generated comment line
                 self.process('GC', i)
             elif line[:15] == '#| msgid_plural':
                 # we are on a previous msgid_plural
                 self.process('PP', i)
             elif line[:8] == '#| msgid':
                 self.process('PM', i)
                 # we are on a previous msgid
             elif line[:10] == '#| msgctxt':
                 # we are on a previous msgctxt
                 self.process('PC', i)
             i = i+1
 
         if self.current_entry:
             # since entries are added when another entry is found, we must add
             # the last entry here (only if there are lines)
             self.instance.append(self.current_entry)
         # before returning the instance, check if there's metadata and if 
         # so extract it in a dict
         firstentry = self.instance[0]
         if firstentry.msgid == '': # metadata found
             # remove the entry
             firstentry = self.instance.pop(0)
             self.instance.metadata_is_fuzzy = firstentry.flags
             key = None
             for msg in firstentry.msgstr.splitlines():
                 try:
                     key, val = msg.split(':', 1)
                     self.instance.metadata[key] = val.strip()
                 except:
                     if key is not None:
                         self.instance.metadata[key] += '\n'+ msg.strip()
         # close opened file
         self.fhandle.close()
         return self.instance
 
     def add(self, symbol, states, next_state):
         """
         Add a transition to the state machine.
         Keywords arguments:
 
         symbol     -- string, the matched token (two chars symbol)
         states     -- list, a list of states (two chars symbols)
         next_state -- the next state the fsm will have after the action
         """
         for state in states:
             action = getattr(self, 'handle_%s' % next_state.lower())
             self.transitions[(symbol, state)] = (action, next_state)
 
     def process(self, symbol, linenum):
         """
         Process the transition corresponding to the current state and the
         symbol provided.
 
         Keywords arguments:
         symbol  -- string, the matched token (two chars symbol)
         linenum -- integer, the current line number of the parsed file
         """
         try:
             (action, state) = self.transitions[(symbol, self.current_state)]
             if action():
                 self.current_state = state
         except Exception, exc:
             raise IOError('Syntax error in po file (line %s)' % linenum)
 
     # state handlers
 
     def handle_he(self):
         """Handle a header comment."""
         if self.instance.header != '':
             self.instance.header += '\n'
         self.instance.header += self.current_token[2:]
         return 1
 
     def handle_tc(self):
         """Handle a translator comment."""
         if self.current_state in ['MC', 'MS', 'MX']:
             self.instance.append(self.current_entry)
             self.current_entry = POEntry()
         if self.current_entry.tcomment != '':
             self.current_entry.tcomment += '\n'
         self.current_entry.tcomment += self.current_token[2:]
         return True
 
     def handle_gc(self):
         """Handle a generated comment."""
         if self.current_state in ['MC', 'MS', 'MX']:
             self.instance.append(self.current_entry)
             self.current_entry = POEntry()
         if self.current_entry.comment != '':
             self.current_entry.comment += '\n'
         self.current_entry.comment += self.current_token[3:]
         return True
 
     def handle_oc(self):
         """Handle a file:num occurence."""
         if self.current_state in ['MC', 'MS', 'MX']:
             self.instance.append(self.current_entry)
             self.current_entry = POEntry()
         occurrences = self.current_token[3:].split()
         for occurrence in occurrences:
             if occurrence != '':
                 try:
                     fil, line = occurrence.split(':')
                     if not line.isdigit():
                         fil  = fil + line
                         line = ''
                     self.current_entry.occurrences.append((fil, line))
                 except:
                     self.current_entry.occurrences.append((occurrence, ''))
         return True
 
     def handle_fl(self):
         """Handle a flags line."""
         if self.current_state in ['MC', 'MS', 'MX']:
             self.instance.append(self.current_entry)
             self.current_entry = POEntry()
         self.current_entry.flags += self.current_token[3:].split(', ')
         return True
 
     def handle_pp(self):
         """Handle a previous msgid_plural line."""
         if self.current_state in ['MC', 'MS', 'MX']:
             self.instance.append(self.current_entry)
             self.current_entry = POEntry()
         self.current_entry.previous_msgid_plural = \
             unescape(self.current_token[17:-1])
         return True
 
     def handle_pm(self):
         """Handle a previous msgid line."""
         if self.current_state in ['MC', 'MS', 'MX']:
             self.instance.append(self.current_entry)
             self.current_entry = POEntry()
         self.current_entry.previous_msgid = \
             unescape(self.current_token[10:-1])
         return True
 
     def handle_pc(self):
         """Handle a previous msgctxt line."""
         if self.current_state in ['MC', 'MS', 'MX']:
             self.instance.append(self.current_entry)
             self.current_entry = POEntry()
         self.current_entry.previous_msgctxt = \
             unescape(self.current_token[12:-1])
         return True
 
     def handle_ct(self):
         """Handle a msgctxt."""
         if self.current_state in ['MC', 'MS', 'MX']:
             self.instance.append(self.current_entry)
             self.current_entry = POEntry()
         self.current_entry.msgctxt = unescape(self.current_token[9:-1])
         return True
 
     def handle_mi(self):
         """Handle a msgid."""
         if self.current_state in ['MC', 'MS', 'MX']:
             self.instance.append(self.current_entry)
             self.current_entry = POEntry()
         self.current_entry.obsolete = self.entry_obsolete
         self.current_entry.msgid = unescape(self.current_token[7:-1])
         return True
 
     def handle_mp(self):
         """Handle a msgid plural."""
         self.current_entry.msgid_plural = unescape(self.current_token[14:-1])
         return True
 
     def handle_ms(self):
         """Handle a msgstr."""
         self.current_entry.msgstr = unescape(self.current_token[8:-1])
         return True
 
     def handle_mx(self):
         """Handle a msgstr plural."""
         index, value = self.current_token[7], self.current_token[11:-1]
         self.current_entry.msgstr_plural[index] = unescape(value)
         self.msgstr_index = index
         return True
 
     def handle_mc(self):
         """Handle a msgid or msgstr continuation line."""
         token = unescape(self.current_token[1:-1])
         if self.current_state == 'CT':
             typ = 'msgctxt'
             self.current_entry.msgctxt += token
         elif self.current_state == 'MI':
             typ = 'msgid'
             self.current_entry.msgid += token
         elif self.current_state == 'MP':
             typ = 'msgid_plural'
             self.current_entry.msgid_plural += token
         elif self.current_state == 'MS':
             typ = 'msgstr'
             self.current_entry.msgstr += token
         elif self.current_state == 'MX':
             typ = 'msgstr[%s]' % self.msgstr_index
             self.current_entry.msgstr_plural[self.msgstr_index] += token
         elif self.current_state == 'PP':
             typ = 'previous_msgid_plural'
             token = token[3:]
             self.current_entry.previous_msgid_plural += token
         elif self.current_state == 'PM':
             typ = 'previous_msgid'
             token = token[3:]
             self.current_entry.previous_msgid += token
         elif self.current_state == 'PC':
             typ = 'previous_msgctxt'
             token = token[3:]
             self.current_entry.previous_msgctxt += token
         if typ not in self.current_entry._multiline_str:
             self.current_entry._multiline_str[typ] = token
         else:
             self.current_entry._multiline_str[typ] += "__POLIB__NL__" + token
         # don't change the current state
         return False
 
 # }}}
 # class _MOFileParser {{{
 
 class _MOFileParser(object):
     """
     A class to parse binary mo files.
     """
     BIG_ENDIAN    = 0xde120495
     LITTLE_ENDIAN = 0x950412de
 
     def __init__(self, fpath, *args, **kwargs):
         """
         Constructor.
 
         **Arguments**:
           - *fpath*: string, path to the po file
           - *encoding*: string, the encoding to use, defaults to
             "default_encoding" global variable (optional),
           - *check_for_duplicates*: whether to check for duplicate entries
             when adding entries to the file, default: False (optional).
         """
         enc = kwargs.get('encoding', default_encoding)
         check_dup = kwargs.get('check_for_duplicates', False)
         self.fhandle = open(fpath, 'rb')
         self.instance = MOFile(
             fpath=fpath,
             encoding=enc,
             check_for_duplicates=check_dup
         )
 
     def parse_magicnumber(self):
         """
         Parse the magic number and raise an exception if not valid.
         """
 
     def parse(self):
         """
         Build the instance with the file handle provided in the
         constructor.
         """
         magic_number = self._readbinary('<I', 4)
         if magic_number == self.LITTLE_ENDIAN:
             ii = '<II'
         elif magic_number == self.BIG_ENDIAN:
             ii = '>II'
         else:
             raise IOError('Invalid mo file, magic number is incorrect !')
         self.instance.magic_number = magic_number
         # parse the version number and the number of strings
         self.instance.version, numofstrings = self._readbinary(ii, 8)
         # original strings and translation strings hash table offset
         msgids_hash_offset, msgstrs_hash_offset = self._readbinary(ii, 8)
         # move to msgid hash table and read length and offset of msgids
         self.fhandle.seek(msgids_hash_offset)
         msgids_index = []
         for i in range(numofstrings):
             msgids_index.append(self._readbinary(ii, 8))
         # move to msgstr hash table and read length and offset of msgstrs
         self.fhandle.seek(msgstrs_hash_offset)
         msgstrs_index = []
         for i in range(numofstrings):
             msgstrs_index.append(self._readbinary(ii, 8))
         # build entries
         for i in range(numofstrings):
             self.fhandle.seek(msgids_index[i][1])
             msgid = self.fhandle.read(msgids_index[i][0])
             self.fhandle.seek(msgstrs_index[i][1])
             msgstr = self.fhandle.read(msgstrs_index[i][0])
             if i == 0: # metadata
                 raw_metadata, metadata = msgstr.split('\n'), {}
                 for line in raw_metadata:
                     tokens = line.split(':', 1)
                     if tokens[0] != '':
                         try:
                             metadata[tokens[0]] = tokens[1].strip()
                         except IndexError:
                             metadata[tokens[0]] = ''
                 self.instance.metadata = metadata
                 continue
             # test if we have a plural entry
             msgid_tokens = msgid.split('\0')
             if len(msgid_tokens) > 1:
                 entry = MOEntry(
                     msgid=msgid_tokens[0],
                     msgid_plural=msgid_tokens[1],
                     msgstr_plural=dict((k,v) for k,v in \
                         enumerate(msgstr.split('\0')))
                 )
             else:
                 entry = MOEntry(msgid=msgid, msgstr=msgstr)
             self.instance.append(entry)
         # close opened file
         self.fhandle.close()
         return self.instance
 
     def _readbinary(self, fmt, numbytes):
         """
         Private method that unpack n bytes of data using format <fmt>.
         It returns a tuple or a mixed value if the tuple length is 1.
         """
         bytes = self.fhandle.read(numbytes)
         tup = struct.unpack(fmt, bytes)
         if len(tup) == 1:
             return tup[0]
         return tup
 
 # }}}
 # __main__ {{{
 
 if __name__ == '__main__':
     """
     **Main function**::
       - to **test** the module just run: *python polib.py [-v]*
       - to **profile** the module: *python polib.py -p <some_pofile.po>*
     """
     import sys
     if len(sys.argv) > 2 and sys.argv[1] == '-p':
         def test(f):
             if f.endswith('po'):
                 p = pofile(f)
             else:
                 p = mofile(f)
             s = unicode(p)
         import profile
         profile.run('test("'+sys.argv[2]+'")')
     else:
         import doctest
         doctest.testmod()
 
 # }}}

setup.py

@@ -1,392 +1,391 b''
-#!/usr/bin/env python
 #
 # This is the mercurial setup script.
 #
 # 'python setup.py install', or
 # 'python setup.py --help' for more options
 
 import sys
 if not hasattr(sys, 'version_info') or sys.version_info < (2, 4, 0, 'final'):
     raise SystemExit("Mercurial requires Python 2.4 or later.")
 
 if sys.version_info[0] >= 3:
     def b(s):
         '''A helper function to emulate 2.6+ bytes literals using string
         literals.'''
         return s.encode('latin1')
 else:
     def b(s):
         '''A helper function to emulate 2.6+ bytes literals using string
         literals.'''
         return s
 
 # Solaris Python packaging brain damage
 try:
     import hashlib
     sha = hashlib.sha1()
 except:
     try:
         import sha
     except:
         raise SystemExit(
             "Couldn't import standard hashlib (incomplete Python install).")
 
 try:
     import zlib
 except:
     raise SystemExit(
         "Couldn't import standard zlib (incomplete Python install).")
 
 try:
     import bz2
 except:
     raise SystemExit(
         "Couldn't import standard bz2 (incomplete Python install).")
 
 import os, subprocess, time
 import shutil
 import tempfile
 from distutils import log
 from distutils.core import setup, Extension
 from distutils.dist import Distribution
 from distutils.command.build import build
 from distutils.command.build_ext import build_ext
 from distutils.command.build_py import build_py
 from distutils.command.install_scripts import install_scripts
 from distutils.spawn import spawn, find_executable
 from distutils.ccompiler import new_compiler
 from distutils.errors import CCompilerError
 from distutils.sysconfig import get_python_inc
 
 scripts = ['hg']
 if os.name == 'nt':
     scripts.append('contrib/win32/hg.bat')
 
 # simplified version of distutils.ccompiler.CCompiler.has_function
 # that actually removes its temporary files.
 def hasfunction(cc, funcname):
     tmpdir = tempfile.mkdtemp(prefix='hg-install-')
     devnull = oldstderr = None
     try:
         try:
             fname = os.path.join(tmpdir, 'funcname.c')
             f = open(fname, 'w')
             f.write('int main(void) {\n')
             f.write('    %s();\n' % funcname)
             f.write('}\n')
             f.close()
             # Redirect stderr to /dev/null to hide any error messages
             # from the compiler.
             # This will have to be changed if we ever have to check
             # for a function on Windows.
             devnull = open('/dev/null', 'w')
             oldstderr = os.dup(sys.stderr.fileno())
             os.dup2(devnull.fileno(), sys.stderr.fileno())
             objects = cc.compile([fname], output_dir=tmpdir)
             cc.link_executable(objects, os.path.join(tmpdir, "a.out"))
         except:
             return False
         return True
     finally:
         if oldstderr is not None:
             os.dup2(oldstderr, sys.stderr.fileno())
         if devnull is not None:
             devnull.close()
         shutil.rmtree(tmpdir)
 
 # py2exe needs to be installed to work
 try:
     import py2exe
     py2exeloaded = True
 
     # Help py2exe to find win32com.shell
     try:
         import modulefinder
         import win32com
         for p in win32com.__path__[1:]: # Take the path to win32comext
             modulefinder.AddPackagePath("win32com", p)
         pn = "win32com.shell"
         __import__(pn)
         m = sys.modules[pn]
         for p in m.__path__[1:]:
             modulefinder.AddPackagePath(pn, p)
     except ImportError:
         pass
 
 except ImportError:
     py2exeloaded = False
     pass
 
 def runcmd(cmd, env):
     p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE, env=env)
     out, err = p.communicate()
     # If root is executing setup.py, but the repository is owned by
     # another user (as in "sudo python setup.py install") we will get
     # trust warnings since the .hg/hgrc file is untrusted. That is
     # fine, we don't want to load it anyway.  Python may warn about
     # a missing __init__.py in mercurial/locale, we also ignore that.
     err = [e for e in err.splitlines()
            if not e.startswith(b('Not trusting file')) \
               and not e.startswith(b('warning: Not importing'))]
     if err:
         return ''
     return out
 
 version = ''
 
 if os.path.isdir('.hg'):
     # Execute hg out of this directory with a custom environment which
     # includes the pure Python modules in mercurial/pure. We also take
     # care to not use any hgrc files and do no localization.
     pypath = ['mercurial', os.path.join('mercurial', 'pure')]
     env = {'PYTHONPATH': os.pathsep.join(pypath),
            'HGRCPATH': '',
            'LANGUAGE': 'C'}
     if 'LD_LIBRARY_PATH' in os.environ:
         env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']
     if 'SystemRoot' in os.environ:
         # Copy SystemRoot into the custom environment for Python 2.6
         # under Windows. Otherwise, the subprocess will fail with
         # error 0xc0150004. See: http://bugs.python.org/issue3440
         env['SystemRoot'] = os.environ['SystemRoot']
     cmd = [sys.executable, 'hg', 'id', '-i', '-t']
     l = runcmd(cmd, env).split()
     while len(l) > 1 and l[-1][0].isalpha(): # remove non-numbered tags
         l.pop()
     if len(l) > 1: # tag found
         version = l[-1]
         if l[0].endswith('+'): # propagate the dirty status to the tag
             version += '+'
     elif len(l) == 1: # no tag found
         cmd = [sys.executable, 'hg', 'parents', '--template',
                '{latesttag}+{latesttagdistance}-']
         version = runcmd(cmd, env) + l[0]
     if version.endswith('+'):
         version += time.strftime('%Y%m%d')
 elif os.path.exists('.hg_archival.txt'):
     kw = dict([[t.strip() for t in l.split(':', 1)]
                for l in open('.hg_archival.txt')])
     if 'tag' in kw:
         version =  kw['tag']
     elif 'latesttag' in kw:
         version = '%(latesttag)s+%(latesttagdistance)s-%(node).12s' % kw
     else:
         version = kw.get('node', '')[:12]
 
 if version:
     f = open("mercurial/__version__.py", "w")
     f.write('# this file is autogenerated by setup.py\n')
     f.write('version = "%s"\n' % version)
     f.close()
 
 
 try:
     from mercurial import __version__
     version = __version__.version
 except ImportError:
     version = 'unknown'
 
 class hgbuildmo(build):
 
     description = "build translations (.mo files)"
 
     def run(self):
         if not find_executable('msgfmt'):
             self.warn("could not find msgfmt executable, no translations "
                      "will be built")
             return
 
         podir = 'i18n'
         if not os.path.isdir(podir):
             self.warn("could not find %s/ directory" % podir)
             return
 
         join = os.path.join
         for po in os.listdir(podir):
             if not po.endswith('.po'):
                 continue
             pofile = join(podir, po)
             modir = join('locale', po[:-3], 'LC_MESSAGES')
             mofile = join(modir, 'hg.mo')
             mobuildfile = join('mercurial', mofile)
             cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]
             if sys.platform != 'sunos5':
                 # msgfmt on Solaris does not know about -c
                 cmd.append('-c')
             self.mkpath(join('mercurial', modir))
             self.make_file([pofile], mobuildfile, spawn, (cmd,))
 
 
 # Insert hgbuildmo first so that files in mercurial/locale/ are found
 # when build_py is run next.
 build.sub_commands.insert(0, ('build_mo', None))
 
 Distribution.pure = 0
 Distribution.global_options.append(('pure', None, "use pure (slow) Python "
                                     "code instead of C extensions"))
 
 class hgbuildext(build_ext):
 
     def build_extension(self, ext):
         try:
             build_ext.build_extension(self, ext)
         except CCompilerError:
             if not getattr(ext, 'optional', False):
                 raise
             log.warn("Failed to build optional extension '%s' (skipping)",
                      ext.name)
 
 class hgbuildpy(build_py):
 
     def finalize_options(self):
         build_py.finalize_options(self)
 
         if self.distribution.pure:
             if self.py_modules is None:
                 self.py_modules = []
             for ext in self.distribution.ext_modules:
                 if ext.name.startswith("mercurial."):
                     self.py_modules.append("mercurial.pure.%s" % ext.name[10:])
             self.distribution.ext_modules = []
         else:
             if not os.path.exists(os.path.join(get_python_inc(), 'Python.h')):
                 raise SystemExit("Python headers are required to build Mercurial")
 
     def find_modules(self):
         modules = build_py.find_modules(self)
         for module in modules:
             if module[0] == "mercurial.pure":
                 if module[1] != "__init__":
                     yield ("mercurial", module[1], module[2])
             else:
                 yield module
 
 class hginstallscripts(install_scripts):
     '''
     This is a specialization of install_scripts that replaces the @LIBDIR@ with
     the configured directory for modules. If possible, the path is made relative
     to the directory for scripts.
     '''
 
     def initialize_options(self):
         install_scripts.initialize_options(self)
 
         self.install_lib = None
 
     def finalize_options(self):
         install_scripts.finalize_options(self)
         self.set_undefined_options('install',
                                    ('install_lib', 'install_lib'))
 
     def run(self):
         install_scripts.run(self)
 
         if (os.path.splitdrive(self.install_dir)[0] !=
             os.path.splitdrive(self.install_lib)[0]):
             # can't make relative paths from one drive to another, so use an
             # absolute path instead
             libdir = self.install_lib
         else:
             common = os.path.commonprefix((self.install_dir, self.install_lib))
             rest = self.install_dir[len(common):]
             uplevel = len([n for n in os.path.split(rest) if n])
 
             libdir =  uplevel * ('..' + os.sep) + self.install_lib[len(common):]
 
         for outfile in self.outfiles:
             data = open(outfile, 'rb').read()
 
             # skip binary files
             if '\0' in data:
                 continue
 
             data = data.replace('@LIBDIR@', libdir.encode('string_escape'))
             open(outfile, 'wb').write(data)
 
 cmdclass = {'build_mo': hgbuildmo,
             'build_ext': hgbuildext,
             'build_py': hgbuildpy,
             'install_scripts': hginstallscripts}
 
 packages = ['mercurial', 'mercurial.hgweb', 'hgext', 'hgext.convert',
             'hgext.highlight', 'hgext.zeroconf']
 
 pymodules = []
 
 extmodules = [
     Extension('mercurial.base85', ['mercurial/base85.c']),
     Extension('mercurial.bdiff', ['mercurial/bdiff.c']),
     Extension('mercurial.diffhelpers', ['mercurial/diffhelpers.c']),
     Extension('mercurial.mpatch', ['mercurial/mpatch.c']),
     Extension('mercurial.parsers', ['mercurial/parsers.c']),
     ]
 
 # disable osutil.c under windows + python 2.4 (issue1364)
 if sys.platform == 'win32' and sys.version_info < (2, 5, 0, 'final'):
     pymodules.append('mercurial.pure.osutil')
 else:
     extmodules.append(Extension('mercurial.osutil', ['mercurial/osutil.c']))
 
 if sys.platform == 'linux2' and os.uname()[2] > '2.6':
     # The inotify extension is only usable with Linux 2.6 kernels.
     # You also need a reasonably recent C library.
     # In any case, if it fails to build the error will be skipped ('optional').
     cc = new_compiler()
     if hasfunction(cc, 'inotify_add_watch'):
         inotify = Extension('hgext.inotify.linux._inotify',
                             ['hgext/inotify/linux/_inotify.c'],
                             ['mercurial'])
         inotify.optional = True
         extmodules.append(inotify)
         packages.extend(['hgext.inotify', 'hgext.inotify.linux'])
 
 packagedata = {'mercurial': ['locale/*/LC_MESSAGES/hg.mo',
                              'help/*.txt']}
 
 def ordinarypath(p):
     return p and p[0] != '.' and p[-1] != '~'
 
 for root in ('templates',):
     for curdir, dirs, files in os.walk(os.path.join('mercurial', root)):
         curdir = curdir.split(os.sep, 1)[1]
         dirs[:] = filter(ordinarypath, dirs)
         for f in filter(ordinarypath, files):
             f = os.path.join(curdir, f)
             packagedata['mercurial'].append(f)
 
 datafiles = []
 setupversion = version
 extra = {}
 
 if py2exeloaded:
     extra['console'] = [
         {'script':'hg',
          'copyright':'Copyright (C) 2005-2010 Matt Mackall and others',
          'product_version':version}]
 
 if os.name == 'nt':
     # Windows binary file versions for exe/dll files must have the
     # form W.X.Y.Z, where W,X,Y,Z are numbers in the range 0..65535
     setupversion = version.split('+', 1)[0]
 
 setup(name='mercurial',
       version=setupversion,
       author='Matt Mackall',
       author_email='[e-mail]',
       url='http://mercurial.selenic.com/',
       description='Scalable distributed SCM',
       license='GNU GPLv2+',
       scripts=scripts,
       packages=packages,
       py_modules=pymodules,
       ext_modules=extmodules,
       data_files=datafiles,
       package_data=packagedata,
       cmdclass=cmdclass,
       options=dict(py2exe=dict(packages=['hgext', 'email']),
                    bdist_mpkg=dict(zipdist=True,
                                    license='COPYING',
                                    readme='contrib/macosx/Readme.html',
                                    welcome='contrib/macosx/Welcome.html')),
       **extra)

tests/test-bdiff.py

@@ -1,54 +1,52 b''
-#!/usr/bin/env python
-
 import struct
 from mercurial import bdiff, mpatch
 
 def test1(a, b):
     d = bdiff.bdiff(a, b)
     c = a
     if d:
         c = mpatch.patches(a, [d])
     if c != b:
         print "***", repr(a), repr(b)
         print "bad:"
         print repr(c)[:200]
         print repr(d)
 
 def test(a, b):
     print "***", repr(a), repr(b)
     test1(a, b)
     test1(b, a)
 
 test("a\nc\n\n\n\n", "a\nb\n\n\n")
 test("a\nb\nc\n", "a\nc\n")
 test("", "")
 test("a\nb\nc", "a\nb\nc")
 test("a\nb\nc\nd\n", "a\nd\n")
 test("a\nb\nc\nd\n", "a\nc\ne\n")
 test("a\nb\nc\n", "a\nc\n")
 test("a\n", "c\na\nb\n")
 test("a\n", "")
 test("a\n", "b\nc\n")
 test("a\n", "c\na\n")
 test("", "adjfkjdjksdhfksj")
 test("", "ab")
 test("", "abc")
 test("a", "a")
 test("ab", "ab")
 test("abc", "abc")
 test("a\n", "a\n")
 test("a\nb", "a\nb")
 
 #issue1295
 def showdiff(a, b):
     bin = bdiff.bdiff(a, b)
     pos = 0
     while pos < len(bin):
         p1, p2, l = struct.unpack(">lll", bin[pos:pos + 12])
         pos += 12
         print p1, p2, repr(bin[pos:pos + l])
         pos += l
 showdiff("x\n\nx\n\nx\n\nx\n\nz\n", "x\n\nx\n\ny\n\nx\n\nx\n\nz\n")
 showdiff("x\n\nx\n\nx\n\nx\n\nz\n", "x\n\nx\n\ny\n\nx\n\ny\n\nx\n\nz\n")
 
 print "done"

tests/test-demandimport.py

@@ -1,40 +1,38 b''
-#!/usr/bin/env python
-
 from mercurial import demandimport
 demandimport.enable()
 
 import re
 
 rsub = re.sub
 def f(obj):
     l = repr(obj)
     l = rsub("0x[0-9a-fA-F]+", "0x?", l)
     l = rsub("from '.*'", "from '?'", l)
     return l
 
 import os
 
 print "os =", f(os)
 print "os.system =", f(os.system)
 print "os =", f(os)
 
 from mercurial import util
 
 print "util =", f(util)
 print "util.system =", f(util.system)
 print "util =", f(util)
 print "util.system =", f(util.system)
 
 import re as fred
 print "fred =", f(fred)
 
 import sys as re
 print "re =", f(re)
 
 print "fred =", f(fred)
 print "fred.sub =", f(fred.sub)
 print "fred =", f(fred)
 
 print "re =", f(re)
 print "re.stderr =", f(re.stderr)
 print "re =", f(re)

tests/test-hg-parseurl.py

@@ -1,12 +1,10 b''
-#!/usr/bin/env python
-
 from mercurial.hg import parseurl
 
 def testparse(url, branch=[]):
     print '%s, branches: %r' % parseurl(url, branch)
 
 testparse('http://example.com/no/anchor')
 testparse('http://example.com/an/anchor#foo')
 testparse('http://example.com/no/anchor/branches', branch=['foo'])
 testparse('http://example.com/an/anchor/branches#bar', branch=['foo'])
 testparse('http://example.com/an/anchor/branches-None#foo', branch=None)

tests/test-hybridencode.py

@@ -1,29 +1,27 b''
-#!/usr/bin/env python
-
 from mercurial import store
 
 auxencode = lambda f: store._auxencode(f, True)
 hybridencode = lambda f: store._hybridencode(f, auxencode)
 
 enc = hybridencode # used for 'dotencode' repo format
 
 def show(s):
     print "A = '%s'" % s
     print "B = '%s'" % enc(s)
     print
 
 show('data/aux.bla/bla.aux/prn/PRN/lpt/com3/nul/coma/foo.NUL/normal.c.i')
 
 show('data/AUX/SECOND/X.PRN/FOURTH/FI:FTH/SIXTH/SEVENTH/EIGHTH/NINETH/'
      'TENTH/ELEVENTH/LOREMIPSUM.TXT.i')
 show('data/enterprise/openesbaddons/contrib-imola/corba-bc/netbeansplugin/'
      'wsdlExtension/src/main/java/META-INF/services/org.netbeans.modules'
      '.xml.wsdl.bindingsupport.spi.ExtensibilityElementTemplateProvider.i')
 show('data/AUX.THE-QUICK-BROWN-FOX-JU:MPS-OVER-THE-LAZY-DOG-THE-QUICK-'
      'BROWN-FOX-JUMPS-OVER-THE-LAZY-DOG.TXT.i')
 show('data/Project Planning/Resources/AnotherLongDirectoryName/'
      'Followedbyanother/AndAnother/AndThenAnExtremelyLongFileName.txt')
 show('data/Project.Planning/Resources/AnotherLongDirectoryName/'
      'Followedbyanother/AndAnother/AndThenAnExtremelyLongFileName.txt')
 show('data/foo.../foo   / /a./_. /__/.x../    bla/.FOO/something.i')
 

tests/test-minirst.py

@@ -1,228 +1,226 b''
-#!/usr/bin/env python
-
 from pprint import pprint
 from mercurial import minirst
 
 def debugformat(title, text, width, **kwargs):
     print "%s formatted to fit within %d characters:" % (title, width)
     print "-" * 70
     formatted = minirst.format(text, width, **kwargs)
     if type(formatted) == tuple:
         print formatted[0]
         print "-" * 70
         pprint(formatted[1])
     else:
         print formatted
     print "-" * 70
     print
 
 paragraphs = """
 This is some text in the first paragraph.
 
   A small indented paragraph.
   It is followed by some lines
   containing random whitespace.
  \n  \n   \nThe third and final paragraph.
 """
 
 debugformat('paragraphs', paragraphs, 60)
 debugformat('paragraphs', paragraphs, 30)
 
 
 definitions = """
 A Term
   Definition. The indented
   lines make up the definition.
 Another Term
   Another definition. The final line in the
    definition determines the indentation, so
     this will be indented with four spaces.
 
   A Nested/Indented Term
     Definition.
 """
 
 debugformat('definitions', definitions, 60)
 debugformat('definitions', definitions, 30)
 
 
 literals = r"""
 The fully minimized form is the most
 convenient form::
 
   Hello
     literal
       world
 
 In the partially minimized form a paragraph
 simply ends with space-double-colon. ::
 
   ////////////////////////////////////////
   long un-wrapped line in a literal block
   \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 
 ::
 
   This literal block is started with '::',
     the so-called expanded form. The paragraph
       with '::' disappears in the final output.
 """
 
 debugformat('literals', literals, 60)
 debugformat('literals', literals, 30)
 
 
 lists = """
 - This is the first list item.
 
   Second paragraph in the first list item.
 
 - List items need not be separated
   by a blank line.
 - And will be rendered without
   one in any case.
 
 We can have indented lists:
 
   - This is an indented list item
 
   - Another indented list item::
 
       - A literal block in the middle
             of an indented list.
 
       (The above is not a list item since we are in the literal block.)
 
 ::
 
   Literal block with no indentation (apart from
   the two spaces added to all literal blocks).
 
 1. This is an enumerated list (first item).
 2. Continuing with the second item.
 
 (1) foo
 (2) bar
 
 1) Another
 2) List
 
 Line blocks are also a form of list:
 
 | This is the first line.
   The line continues here.
 | This is the second line.
 """
 
 debugformat('lists', lists, 60)
 debugformat('lists', lists, 30)
 
 
 options = """
 There is support for simple option lists,
 but only with long options:
 
 --all      Output all.
 --both     Output both (this description is
            quite long).
 --long     Output all day long.
 
 --par      This option has two paragraphs in its description.
            This is the first.
 
            This is the second.  Blank lines may be omitted between
            options (as above) or left in (as here).
 
 The next paragraph looks like an option list, but lacks the two-space
 marker after the option. It is treated as a normal paragraph:
 
 --foo bar baz
 """
 
 debugformat('options', options, 60)
 debugformat('options', options, 30)
 
 
 fields = """
 :a: First item.
 :ab: Second item. Indentation and wrapping
      is handled automatically.
 
 Next list:
 
 :small: The larger key below triggers full indentation here.
 :much too large: This key is big enough to get its own line.
 """
 
 debugformat('fields', fields, 60)
 debugformat('fields', fields, 30)
 
 containers = """
 Normal output.
 
 .. container:: debug
 
    Initial debug output.
 
 .. container:: verbose
 
    Verbose output.
 
    .. container:: debug
 
       Debug output.
 """
 
 debugformat('containers (normal)', containers, 60)
 debugformat('containers (verbose)', containers, 60, keep=['verbose'])
 debugformat('containers (debug)', containers, 60, keep=['debug'])
 debugformat('containers (verbose debug)', containers, 60,
             keep=['verbose', 'debug'])
 
 roles = """Please see :hg:`add`."""
 debugformat('roles', roles, 60)
 
 
 sections = """
 Title
 =====
 
 Section
 -------
 
 Subsection
 ''''''''''
 
 Markup: ``foo`` and :hg:`help`
 ------------------------------
 """
 debugformat('sections', sections, 20)
 
 
 admonitions = """
 .. note::
    This is a note
 
    - Bullet 1
    - Bullet 2
 
    .. warning:: This is a warning Second
       input line of warning
 
 .. danger::
    This is danger
 """
 
 debugformat('admonitions', admonitions, 30)
 
 comments = """
 Some text.
 
 .. A comment
 
    .. An indented comment
 
    Some indented text.
 """
 
 debugformat('comments', comments, 30)

tests/test-ui-color.py

@@ -1,11 +1,9 b''
-#!/usr/bin/env python
-
 from hgext import color
 
 # ensure errors aren't buffered
 testui = color.colorui()
 testui.pushbuffer()
 testui.write('buffered\n')
 testui.warn('warning\n')
 testui.write_err('error\n')
 print repr(testui.popbuffer())

tests/test-ui-config.py

@@ -1,83 +1,81 b''
-#!/usr/bin/env python
-
 from mercurial import ui, dispatch, error
 
 testui = ui.ui()
 parsed = dispatch._parseconfig(testui, [
     'values.string=string value',
     'values.bool1=true',
     'values.bool2=false',
     'lists.list1=foo',
     'lists.list2=foo bar baz',
     'lists.list3=alice, bob',
     'lists.list4=foo bar baz alice, bob',
     'lists.list5=abc d"ef"g "hij def"',
     'lists.list6="hello world", "how are you?"',
     'lists.list7=Do"Not"Separate',
     'lists.list8="Do"Separate',
     'lists.list9="Do\\"NotSeparate"',
     'lists.list10=string "with extraneous" quotation mark"',
     'lists.list11=x, y',
     'lists.list12="x", "y"',
     'lists.list13=""" key = "x", "y" """',
     'lists.list14=,,,,     ',
     'lists.list15=" just with starting quotation',
     'lists.list16="longer quotation" with "no ending quotation',
     'lists.list17=this is \\" "not a quotation mark"',
     'lists.list18=\n \n\nding\ndong',
 ])
 
 print repr(testui.configitems('values'))
 print repr(testui.configitems('lists'))
 print "---"
 print repr(testui.config('values', 'string'))
 print repr(testui.config('values', 'bool1'))
 print repr(testui.config('values', 'bool2'))
 print repr(testui.config('values', 'unknown'))
 print "---"
 try:
     print repr(testui.configbool('values', 'string'))
 except error.ConfigError, inst:
     print inst
 print repr(testui.configbool('values', 'bool1'))
 print repr(testui.configbool('values', 'bool2'))
 print repr(testui.configbool('values', 'bool2', True))
 print repr(testui.configbool('values', 'unknown'))
 print repr(testui.configbool('values', 'unknown', True))
 print "---"
 print repr(testui.configlist('lists', 'list1'))
 print repr(testui.configlist('lists', 'list2'))
 print repr(testui.configlist('lists', 'list3'))
 print repr(testui.configlist('lists', 'list4'))
 print repr(testui.configlist('lists', 'list4', ['foo']))
 print repr(testui.configlist('lists', 'list5'))
 print repr(testui.configlist('lists', 'list6'))
 print repr(testui.configlist('lists', 'list7'))
 print repr(testui.configlist('lists', 'list8'))
 print repr(testui.configlist('lists', 'list9'))
 print repr(testui.configlist('lists', 'list10'))
 print repr(testui.configlist('lists', 'list11'))
 print repr(testui.configlist('lists', 'list12'))
 print repr(testui.configlist('lists', 'list13'))
 print repr(testui.configlist('lists', 'list14'))
 print repr(testui.configlist('lists', 'list15'))
 print repr(testui.configlist('lists', 'list16'))
 print repr(testui.configlist('lists', 'list17'))
 print repr(testui.configlist('lists', 'list18'))
 print repr(testui.configlist('lists', 'unknown'))
 print repr(testui.configlist('lists', 'unknown', ''))
 print repr(testui.configlist('lists', 'unknown', 'foo'))
 print repr(testui.configlist('lists', 'unknown', ['foo']))
 print repr(testui.configlist('lists', 'unknown', 'foo bar'))
 print repr(testui.configlist('lists', 'unknown', 'foo, bar'))
 print repr(testui.configlist('lists', 'unknown', ['foo bar']))
 print repr(testui.configlist('lists', 'unknown', ['foo', 'bar']))
 
 print repr(testui.config('values', 'String'))
 
 def function():
     pass
 
 # values that aren't strings should work
 testui.setconfig('hook', 'commit', function)
 print function == testui.config('hook', 'commit')

tests/test-ui-verbosity.py

@@ -1,49 +1,47 b''
-#!/usr/bin/env python
-
 import os
 from mercurial import ui
 
 hgrc = os.environ['HGRCPATH']
 f = open(hgrc)
 basehgrc = f.read()
 f.close()
 
 print '      hgrc settings    command line options      final result   '
 print '    quiet verbo debug   quiet verbo debug      quiet verbo debug'
 
 for i in xrange(64):
     hgrc_quiet   = bool(i & 1<<0)
     hgrc_verbose = bool(i & 1<<1)
     hgrc_debug   = bool(i & 1<<2)
     cmd_quiet    = bool(i & 1<<3)
     cmd_verbose  = bool(i & 1<<4)
     cmd_debug    = bool(i & 1<<5)
 
     f = open(hgrc, 'w')
     f.write(basehgrc)
     f.write('\n[ui]\n')
     if hgrc_quiet:
         f.write('quiet = True\n')
     if hgrc_verbose:
         f.write('verbose = True\n')
     if hgrc_debug:
         f.write('debug = True\n')
     f.close()
 
     u = ui.ui()
     if cmd_quiet or cmd_debug or cmd_verbose:
         u.setconfig('ui', 'quiet', str(bool(cmd_quiet)))
         u.setconfig('ui', 'verbose', str(bool(cmd_verbose)))
         u.setconfig('ui', 'debug', str(bool(cmd_debug)))
 
     check = ''
     if u.debugflag:
         if not u.verbose or u.quiet:
             check = ' *'
     elif u.verbose and u.quiet:
         check = ' +'
 
     print ('%2d  %5s %5s %5s   %5s %5s %5s  ->  %5s %5s %5s%s'
            % (i, hgrc_quiet, hgrc_verbose, hgrc_debug,
               cmd_quiet, cmd_verbose, cmd_debug,
               u.quiet, u.verbose, u.debugflag, check))

tests/test-url.py

@@ -1,39 +1,38 b''
-#!/usr/bin/env python
 import sys
 
 def check(a, b):
     if a != b:
         print (a, b)
 
 def cert(cn):
     return dict(subject=((('commonName', cn),),))
 
 from mercurial.url import _verifycert
 
 # Test non-wildcard certificates
 check(_verifycert(cert('example.com'), 'example.com'),
       None)
 check(_verifycert(cert('example.com'), 'www.example.com'),
       'certificate is for example.com')
 check(_verifycert(cert('www.example.com'), 'example.com'),
       'certificate is for www.example.com')
 
 # Test wildcard certificates
 check(_verifycert(cert('*.example.com'), 'www.example.com'),
       None)
 check(_verifycert(cert('*.example.com'), 'example.com'),
       'certificate is for *.example.com')
 check(_verifycert(cert('*.example.com'), 'w.w.example.com'),
       'certificate is for *.example.com')
 
 # Avoid some pitfalls
 check(_verifycert(cert('*.foo'), 'foo'),
       'certificate is for *.foo')
 check(_verifycert(cert('*o'), 'foo'),
       'certificate is for *o')
 
 check(_verifycert({'subject': ()},
                   'example.com'),
       'no commonName found in certificate')
 check(_verifycert(None, 'example.com'),
       'no certificate received')