ams

#!/usr/bin/env python
import re
import os
import sys
import getopt
from fpdf import FPDF

PATTERN=re.compile(r'<string name="(.*?)".*>(.*?)</string>', re.I | re.MULTILINE)

class MissingStringsReport:
    filePath = None
    originalStringsDict = None
    myStringsDict = None
    missingKeys = None

    def __init__(self, stringsFilePath, originalStringsDict):
        '''stringsFilePath - The path to the strings.xml file we want to check.
        originalStringsDict - A dictionary containing all the string-keys and original language values (usually inside res/values/strings.xml)
        '''
        self.stringsFilePath = stringsFilePath
        self.originalStringsDict = originalStringsDict
        self.myStringsDict = MissingStringsReport.readXML(self.stringsFilePath)
        self.missingKeys = MissingStringsReport.findMissingKeys(self.originalStringsDict, self.myStringsDict)

    def getMissingKeys(self):
        '''Returns a list with the missing keys.'''
        return self.missingKeys

    def getMyStringsDict(self):
        return self.myStringsDict

    def getCompletePercentage(self):
        return (len(self.myStringsDict)/float(len(self.originalStringsDict))) * 100

    @staticmethod
    def findMissingKeys(fullDict, incompleteDict):
        '''Given the original (fullDict) strings dictionary, this returns a list of the missing keys on incompleteDict.
           If the file is fully translated it will return an empty list.'''
        missingKeys = []
        for k in fullDict:
            if k not in incompleteDict:
                missingKeys.append(k)
        return missingKeys

    @staticmethod
    def readXML(fileName):
        result={}
        global PATTERN
        f=open(fileName,'r')
        line = f.readline()
        while line!="":
            matcher = PATTERN.search(line)
            if matcher != None:
                result[matcher.group(1)]=matcher.group(2)
            line = f.readline()
        f.close()
        return result


def getStringsFilePaths():
    '''Gets all the relative paths to strings.xml files in a list.'''
    p = os.popen("find . | grep strings.xml")
    filesPath = p.readlines()
    p.close()
    return filesPath

def usage():
    usage = """
    ams - Android Missing Strings reporting tool.
    
    Usage:
    ams [-l xx[,yy,zz...]] -o <output_file>

    Options:
    -h --help            Print this help


    -l --lang <xx>       Specify a language or many with comma separated 2-char language codes.

                         e.g:  -l cn         (creates report for Chinese strings.xml)
                               -l cn,it,fr   (creates report for Chinese, Italian and French strings.xml files)

                         If this parameter is ommited, a report with every language file found will be created.


    -o --oFile           Specify the output file name for the PDF report

    Copyright (c) 2014 - The Mit License (MIT)

    Authors:
    Angel Leon <gubatron@gmail.com>
    Katay Santos <kataysantos@gmail.com>

    """
    print usage

def main(argv):
    xmlFilePaths=[]
    outputFile = ''
    try:
        opts, args = getopt.getopt(argv, "ho:l:",["ofile=","lang="])
    except getopt.GetoptError:
        print "unhandled option"
        usage()
        sys.exit(2)

    if len(opts) == 0:
        usage()
        print "Error: missing parameters."
        sys.exit(2)

    for opt, arg in opts:
        if opt == '-h':
            usage()
            sys.exit(2)

        if opt in ("-o", "--ofile"):
            outputFile = arg

        if opt in ("-l", "--lang"):
            if "," in arg:
               languages=arg.split(",")
               for l in languages:
                   xmlFilePaths.append("./res/values-" + l + "/strings.xml")
            else:
                xmlFilePaths=["./res/values-" + arg + "/strings.xml"]

    if outputFile == '':
        usage()
        print "Error: missing -o (output file) parameter."
        sys.exit(2)

    if len(xmlFilePaths) == 0:
        xmlFilePaths=getStringsFilePaths()

    xmlOriginalFile="./res/values/strings.xml"
    originalDict=MissingStringsReport.readXML(xmlOriginalFile)

    pdf=FPDF()
    pdf.add_page()

    for xmlFilePath in xmlFilePaths:
        filePath = xmlFilePath.strip()
        
        if filePath != xmlOriginalFile:
            report = MissingStringsReport(filePath, originalDict)
            print "Generating report for " + filePath + "..."
            pdf.set_font('Arial','B',12)
            pdf.cell(100,10,"Language file: " + filePath,0,0)
            pdf.cell(40,10,"%d%% completed " % (report.getCompletePercentage()),0,1,'R')
            pdf.cell(40,10,"Missing elements: ",0,1)

            for missingKey in report.getMissingKeys():
                pdf.set_font('Arial','I',8)
                tag = "<string name=\"%s\">%s</string>" % (missingKey, originalDict[missingKey])
                pdf.multi_cell(190,10,tag,1,1)

            pdf.add_page()

    pdf.output(outputFile,'F')
    print "\nSuccess: Android Missing String report ready at " + outputFile


if __name__ == '__main__':
    
    main(sys.argv[1:])