~mailman-coders/mailman/2.1

#! @PYTHON@

#

# transcheck - (c) 2002 by Simone Piunno <pioppo@ferrara.linux.it>

# Copyright (C) 2002-2007 by the Free Software Foundation, Inc.

#

# This program is free software; you can redistribute it and/or modify it

# under the terms of the version 2.0 of the GNU General Public License as

# published by the Free Software Foundation.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

# for more details.

#

# You should have received a copy of the GNU General Public License along

# with this program; if not, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

"""

Check a given Mailman translation, making sure that variables and

tags referenced in translation are the same variables and tags in

the original templates and catalog.

Usage:

cd $MAILMAN_DIR

%(program)s [-q] <lang>

Where <lang> is your country code (e.g. 'it' for Italy) and -q is

to ask for a brief summary.

"""

import sys

import re

import os

import getopt

import paths

from Mailman.i18n import _

program = sys.argv[0]

def usage(code, msg=''):

    if code:

        fd = sys.stderr

    else:

        fd = sys.stdout

    print >> fd, _(__doc__)

    if msg:

        print >> fd, msg

    sys.exit(code)

class TransChecker:

    "check a translation comparing with the original string"

    def __init__(self, regexp, escaped=None):

        self.dict = {}

        self.errs = []

        self.regexp = re.compile(regexp)

        self.escaped = None

        if escaped:

            self.escaped = re.compile(escaped)

    def checkin(self, string):

        "scan a string from the original file"

        for key in self.regexp.findall(string):

            if self.escaped and self.escaped.match(key):

                continue

            if self.dict.has_key(key):

                self.dict[key] += 1

            else:

                self.dict[key] = 1

    def checkout(self, string):

        "scan a translated string"

        for key in self.regexp.findall(string):

            if self.escaped and self.escaped.match(key):

                continue

            if self.dict.has_key(key):

                self.dict[key] -= 1

            else:

                self.errs.append(

                    "%(key)s was not found" %

                    { 'key' : key }

                )

    def computeErrors(self):

        "check for differences between checked in and checked out"

        for key in self.dict.keys():

            if self.dict[key] < 0:

                self.errs.append(

                    "Too much %(key)s" %

                    { 'key'  : key }

                )

            if self.dict[key] > 0:

                self.errs.append(

                    "Too few %(key)s" %

                    { 'key'  : key }

                )

        return self.errs

    def status(self):

        if self.errs:

            return "FAILED"

        else:

            return "OK"

    def errorsAsString(self):

        msg = ""

        for err in self.errs:

            msg += " - %(err)s" % { 'err': err }

        return msg

    def reset(self):

        self.dict = {}

        self.errs = []

class POParser:

    "parse a .po file extracting msgids and msgstrs"

    def __init__(self, filename=""):

        self.status = 0

        self.files = []

        self.msgid = ""

        self.msgstr = ""

        self.line = 1

        self.f = None

        self.esc = { "n": "\n", "r": "\r", "t": "\t" }

        if filename:

            self.f = open(filename)

    def open(self, filename):

        self.f = open(filename)

    def close(self):

        self.f.close()

    def parse(self):

        """States table for the finite-states-machine parser:

            0  idle

            1  filename-or-comment

            2  msgid

            3  msgstr

            4  end

        """

        # each time we can safely re-initialize those vars

        self.files = []

        self.msgid = ""

        self.msgstr = ""

        # can't continue if status == 4, this is a dead status

        if self.status == 4:

            return 0

        while 1:

            # continue scanning, char-by-char

            c = self.f.read(1)

            if not c:

                # EOF -> maybe we have a msgstr to save?

                self.status = 4

                if self.msgstr:

                    return 1

                else:

                    return 0

            # keep the line count up-to-date

            if c == "\n":

                self.line += 1

            # a pound was detected the previous char...

            if self.status == 1:

                if c == ":":

                    # was a line of filenames

                    row = self.f.readline()

                    self.files += row.split()

                    self.line += 1

                elif c == "\n":

                    # was a single pount on the line

                    pass

                else:

                    # was a comment... discard

                    self.f.readline()

                    self.line += 1

                # in every case, we switch to idle status

                self.status = 0;

                continue

            # in idle status we search for a '#' or for a 'm'

            if self.status == 0:

                if   c == "#":

                    # this could be a comment or a filename

                    self.status = 1;

                    continue

                elif c == "m":

                    # this should be a msgid start...

                    s = self.f.read(4)

                    assert s == "sgid"

                    # so now we search for a '"'

                    self.status = 2

                    continue

                # in idle only those other chars are possibile

                assert c in [ "\n", " ", "\t" ]

            # searching for the msgid string

            if self.status == 2:

                if c == "\n":

                    # a double LF is not possible here

                    c = self.f.read(1)

                    assert c != "\n"

                if c == "\"":

                    # ok, this is the start of the string,

                    # now search for the end

                    while 1:

                        c = self.f.read(1)

                        if not c:

                            # EOF, bailout

                            self.status = 4

                            return 0

                        if c == "\\":

                            # a quoted char...

                            c = self.f.read(1)

                            if self.esc.has_key(c):

                                self.msgid += self.esc[c]

                            else:

                                self.msgid += c

                            continue

                        if c == "\"":

                            # end of string found

                            break

                        # a normal char, add it

                        self.msgid += c

                if c == "m":

                    # this should be a msgstr identifier

                    s = self.f.read(5)

                    assert s == "sgstr"

                    # ok, now search for the msgstr string

                    self.status = 3

            # searching for the msgstr string

            if self.status == 3:

                if c == "\n":

                    # a double LF is the end of the msgstr!

                    c = self.f.read(1)

                    if c == "\n":

                        # ok, time to go idle and return

                        self.status = 0

                        self.line += 1

                        return 1

                if c == "\"":

                    # start of string found

                    while 1:

                        c = self.f.read(1)

                        if not c:

                            # EOF, bail out

                            self.status = 4

                            return 1

                        if c == "\\":

                            # a quoted char...

                            c = self.f.read(1)

                            if self.esc.has_key(c):

                                self.msgstr += self.esc[c]

                            else:

                                self.msgstr += c

                            continue

                        if c == "\"":

                            # end of string

                            break

                        # a normal char, add it

                        self.msgstr += c

def check_file(translatedFile, originalFile, html=0, quiet=0):

    """check a translated template against the original one

       search also <MM-*> tags if html is not zero"""

    if html:

        c = TransChecker("(%%|%\([^)]+\)[0-9]*[sd]|</?MM-[^>]+>)", "^%%$")

    else:

        c = TransChecker("(%%|%\([^)]+\)[0-9]*[sd])", "^%%$")

    try:

        f = open(originalFile)

    except IOError:

        if not quiet:

            print " - Can'open original file " + originalFile

        return 1

    while 1:

        line = f.readline()

        if not line: break

        c.checkin(line)

    f.close()

    try:

        f = open(translatedFile)

    except IOError:

        if not quiet:

            print " - Can'open translated file " + translatedFile

        return 1

    while 1:

        line = f.readline()

        if not line: break

        c.checkout(line)

    f.close()

    n = 0

    msg = ""

    for desc in c.computeErrors():

        n +=1

        if not quiet:

            print " - %(desc)s" % { 'desc': desc }

    return n

def check_po(file, quiet=0):

    "scan the po file comparing msgids with msgstrs"

    n = 0

    p = POParser(file)

    c = TransChecker("(%%|%\([^)]+\)[0-9]*[sdu]|%[0-9]*[sdu])", "^%%$")

    while p.parse():

        if p.msgstr:

            c.reset()

            c.checkin(p.msgid)

            c.checkout(p.msgstr)

            for desc in c.computeErrors():

                n += 1

                if not quiet:

                    print " - near line %(line)d %(file)s: %(desc)s" % {

                        'line': p.line,

                        'file': p.files,

                        'desc': desc

                    }

    p.close()

    return n

def main():

    try:

        opts, args = getopt.getopt(sys.argv[1:], 'qh', ['quiet', 'help'])

    except getopt.error, msg:

        usage(1, msg)

    quiet = 0

    for opt, arg in opts:

        if opt in ('-h', '--help'):

            usage(0)

        elif opt in ('-q', '--quiet'):

            quiet = 1

    if len(args) <> 1:

        usage(1)

    lang = args[0]

    isHtml = re.compile("\.html$");

    isTxt = re.compile("\.txt$");

    numerrors = 0

    numfiles = 0

    try:

        files = os.listdir("templates/" + lang + "/")

    except:

        print "can't open templates/%s/" % lang

    for file in files:

        fileEN = "templates/en/" + file

        fileIT = "templates/" + lang + "/" + file

        errlist = []

        if isHtml.search(file):

            if not quiet:

                print "HTML checking " + fileIT + "... "

            n = check_file(fileIT, fileEN, html=1, quiet=quiet)

            if n:

                numerrors += n

                numfiles += 1

        elif isTxt.search(file):

            if not quiet:

                print "TXT  checking " + fileIT + "... "

            n = check_file(fileIT, fileEN, html=0, quiet=quiet)

            if n:

                numerrors += n

                numfiles += 1

        else:

            continue

    file = "messages/" + lang + "/LC_MESSAGES/mailman.po"

    if not quiet:

        print "PO   checking " + file + "... "

    n = check_po(file, quiet=quiet)

    if n:

        numerrors += n

        numfiles += 1

    if quiet:

        print "%(errs)u warnings in %(files)u files" % {

            'errs':  numerrors,

            'files': numfiles

        }

if __name__ == '__main__':

    main()