pygments-main / scripts /

Full commit
#!/usr/bin/env python
# -*- coding: utf-8 -*-
    Checker for file headers

    Make sure each Python file has a correct file header
    including copyright and license information.

    :copyright: 2006 by Georg Brandl.
    :license: GNU GPL, see LICENSE for more details.

import sys, os, re
import getopt
import cStringIO
from os.path import join, splitext, abspath

checkers = {}

def checker(*suffixes, **kwds):
    only_pkg = kwds.pop('only_pkg', False)
    def deco(func):
        for suffix in suffixes:
            checkers.setdefault(suffix, []).append(func)
        func.only_pkg = only_pkg
        return func
    return deco

name_mail_re = r'[\w ]+(<.*?>)?'
copyright_re = re.compile(r'^    :copyright: 200\d(-200\d)? by %s(, %s)*\.$' %
                          (name_mail_re, name_mail_re))
coding_re    = re.compile(r'coding[:=]\s*([-\w.]+)')
not_ix_re    = re.compile(r'\bnot\s+\S+?\s+i[sn]\s\S+')
is_const_re  = re.compile(r'if.*?==\s+(None|False|True)\b')

misspellings = ["developement", "adress", "verificate",  # ALLOW-MISSPELLING
                "informations"]                          # ALLOW-MISSPELLING

def check_syntax(fn, lines):
        compile(''.join(lines), fn, "exec")
    except SyntaxError, err:
        yield 0, "not compilable: %s" % err

def check_style_and_encoding(fn, lines):
    encoding = 'ascii'
    for lno, line in enumerate(lines):
        if len(line) > 90:
            yield lno+1, "line too long"
        m =
        if m:
            yield lno+1, '"' + + '"'
            yield lno+1, 'using == None/True/False'
        if lno < 2:
            co =
            if co:
                encoding =
        except UnicodeDecodeError, err:
            yield lno+1, "not decodable: %s\n   Line: %r" % (err, line)
        except LookupError, err:
            yield 0, "unknown encoding: %s" % encoding
            encoding = 'latin1'

@checker('.py', only_pkg=True)
def check_fileheader(fn, lines):
    # line number correction
    c = 1
    if lines[0:1] == ['#!/usr/bin/env python\n']:
        lines = lines[1:]
        c = 2

    llist = []
    docopen = False
    for lno, l in enumerate(lines):
        if lno == 0:
            if l == '# -*- coding: rot13 -*-\n':
                # special-case pony package
            elif l != '# -*- coding: utf-8 -*-\n':
                yield 1, "missing coding declaration"
        elif lno == 1:
            if l != '"""\n' and l != 'r"""\n':
                yield 2, 'missing docstring begin (""")'
                docopen = True
        elif docopen:
            if l == '"""\n':
                # end of docstring
                if lno <= 4:
                    yield lno+c, "missing module name in docstring"

            if l != "\n" and l[:4] != '    ' and docopen:
                yield lno+c, "missing correct docstring indentation"

            if lno == 2:
                # if not in package, don't check the module name
                modname = fn[:-3].replace('/', '.').replace('.__init__', '')
                while modname:
                    if l.lower()[4:-1] == modname:
                    modname = '.'.join(modname.split('.')[1:])
                    yield 3, "wrong module name in docstring heading"
                modnamelen = len(l.strip())
            elif lno == 3:
                if l.strip() != modnamelen * "~":
                    yield 4, "wrong module name underline, should be ~~~...~"

        yield 0, "missing end and/or start of docstring..."

    # check for copyright and license fields
    license = llist[-2:-1]
    if license != ["    :license: GNU LGPL, see LICENSE for more details.\n"]:
        yield 0, "no correct license info"

    copyright = llist[-3:-2]
    if not copyright or not copyright_re.match(copyright[0]):
        yield 0, "no correct copyright info"

@checker('.py', '.html', '.js')
def check_whitespace_and_spelling(fn, lines):
    for lno, line in enumerate(lines):
        if "\t" in line:
            yield lno+1, "OMG TABS!!!1 "
        if line[:-1].rstrip(' \t') != line[:-1]:
            yield lno+1, "trailing whitespace"
        for word in misspellings:
            if word in line and 'ALLOW-MISSPELLING' not in line:
                yield lno+1, '"%s" used' % word

bad_tags = ('<b>', '<i>', '<u>', '<s>', '<strike>'
            '<center>', '<big>', '<small>', '<font')

def check_xhtml(fn, lines):
    for lno, line in enumerate(lines):
        for bad_tag in bad_tags:
            if bad_tag in line:
                yield lno+1, "used " + bad_tag

def main(argv):
        gopts, args = getopt.getopt(argv[1:], "vi:")
    except getopt.GetoptError:
        print "Usage: %s [-v] [-i ignorepath]* [path]" % argv[0]
        return 2
    opts = {}
    for opt, val in gopts:
        if opt == '-i':
            val = abspath(val)
        opts.setdefault(opt, []).append(val)

    if len(args) == 0:
        path = '.'
    elif len(args) == 1:
        path = args[0]
        print "Usage: %s [-v] [-i ignorepath]* [path]" % argv[0]
        return 2

    verbose = '-v' in opts

    num = 0
    out = cStringIO.StringIO()

    for root, dirs, files in os.walk(path):
        if '.svn' in dirs:
        if '-i' in opts and abspath(root) in opts['-i']:
            del dirs[:]
        # XXX: awkward: for the Makefile call: don't check non-package
        #      files for file headers
        in_pocoo_pkg = root.startswith('./pygments')
        for fn in files:

            fn = join(root, fn)
            if fn[:2] == './': fn = fn[2:]

            if '-i' in opts and abspath(fn) in opts['-i']:

            ext = splitext(fn)[1]
            checkerlist = checkers.get(ext, None)
            if not checkerlist:

            if verbose:
                print "Checking %s..." % fn

                f = open(fn, 'r')
                lines = list(f)
            except (IOError, OSError), err:
                print "%s: cannot open: %s" % (fn, err)
                num += 1

            for checker in checkerlist:
                if not in_pocoo_pkg and checker.only_pkg:
                for lno, msg in checker(fn, lines):
                    print >>out, "%s:%d: %s" % (fn, lno, msg)
                    num += 1
    if verbose:
    if num == 0:
        print "No errors found."
        print out.getvalue().rstrip('\n')
        print "%d error%s found." % (num, num > 1 and "s" or "")
    return int(num > 0)

if __name__ == '__main__':