other fixes for building

[pmachines.git] / ya2 / build / lang.py

'''Tools for l10n.'''
from os import system, makedirs, remove, listdir, getcwd, chdir
from os.path import exists, isfile, join
from shutil import move, copy
from json import loads
from polib import pofile, POEntry
from ya2.build.build import find_file_names, FindFileNamesArgs


class LanguageBuilder:
    '''Tools for building files for l10n.'''

    def __init__(self, app_name, po_path, json_path, mo_path, root):
        self.__app_name = app_name
        self.__po_path = po_path
        self.__json_path = json_path
        self.__mo_path = mo_path
        self.__root = root

    def build(self):
        orig_dir = getcwd()
        chdir(self.__root)
        self.__build_pot()
        po_files = [name for name in listdir(self.__po_path)
                   if isfile(join(self.__po_path, name)) and
                       name.endswith('.po')]
        language_codes = [f.split('.')[0] for f in po_files]
        for l in language_codes: self.__process_language(l)
        chdir(orig_dir)

    def __build_pot(self):
        '''Builds the pot file in the lng_dir_code directory.'''
        find_info = FindFileNamesArgs(['py'], ['tests'])
        src_files = ' '.join(find_file_names(find_info))
        cmd_tmpl = 'xgettext -ci18n -d {appname} -L python ' + \
            '-o {pot_path}{appname}.pot '
        system(cmd_tmpl.format(appname=self.__app_name, pot_path=self.__po_path) + src_files)
        self.__add_from_json_to_pot()

    def __add_from_json_to_pot(self):
        json_files = [name for name in listdir(self.__json_path)
                      if isfile(join(self.__json_path, name)) and
                      name.endswith('.json') and
                      name != 'index.json']
        json_strings = []
        for json_file in json_files:
            with open(f'{self.__json_path}{json_file}') as f:
                json = loads(f.read())
            json_strings += [json['name']]
            for instruction_line in json['instructions'].split('\n'):
                if instruction_line:
                    json_strings += [instruction_line]
        def process_json_escape(string):
            return bytes(string, 'utf-8').decode('unicode-escape')
        json_strings = [process_json_escape(s) for s in json_strings]
        json_strings = list(set(json_strings))
        pot = pofile(f'{self.__po_path}{self.__app_name}.pot')
        pot_ids = [entry.msgid for entry in pot]
        for json_string in json_strings:
            if json_string not in pot_ids:
                entry = POEntry(msgid=json_string)
                pot.append(entry)
        pot.save(f'{self.__po_path}{self.__app_name}.pot')

    def __process_language(self, language_code):
        self.__merge(language_code)
        self.__build_mo(language_code)

    def __build_mo(self, language_code):
        '''Builds the mo file in the lng_dir_code directory.'''
        mo_template = '%s%s/LC_MESSAGES/%s.mo'
        mo_name = mo_template % (self.__mo_path, language_code, self.__app_name)
        lng_code = mo_name[len(self.__mo_path):].split('/')[0]
        lng_dir = self.__mo_path + lng_code + '/LC_MESSAGES/'
        cmd = 'msgfmt -o {lng_dir}{appname}.mo {po_path}{lng_code}.po'
        system(cmd.format(lng_dir=lng_dir, appname=self.__app_name, po_path=self.__po_path, lng_code=lng_code))

    def __merge(self, lng_code):
        '''Merges the new strings with the previous ones.'''
        lng_base_dir = self.__prepare(lng_code)
        self.__do_merge(lng_base_dir, lng_code)
        self.__postprocess(lng_code)

    def __prepare(self, lng_code):
        '''Prepares a directory for working with languages.'''
        makedirs(self.__mo_path + lng_code + '/LC_MESSAGES', exist_ok=True)
        lng_dir = self.__mo_path + lng_code + '/LC_MESSAGES/'
        if not exists('assets/locale/po/' + lng_code + '.po'):
            lines_to_fix = ['CHARSET/UTF-8', 'ENCODING/8bit']
            [self.__fix_line(line, lng_dir)
             for line in lines_to_fix]
            copy(lng_dir + self.__app_name + '.pot', lng_dir + self.__app_name + '.po')
        return lng_dir

    def __fix_line(self, line, lng_dir):
        '''Fixes po files (misaligned entries).'''
        cmd_tmpl = "sed 's/{line}/' {lng_dir}{appname}.pot > " + \
            "{lng_dir}{appname}tmp.po"
        system(cmd_tmpl.format(line=line, lng_dir=lng_dir, appname=self.__app_name))
        move(lng_dir + self.__app_name + 'tmp.po', lng_dir + self.__app_name + '.pot')

    def __do_merge(self, lng_dir, lng_code):
        '''Manages the msgmerge's invokation.'''
        print('merge', lng_dir)
        cmd = 'msgmerge -o {lng_dir}{appname}merge.po ' + \
            '{tgt_path}{lng_code}.po {tgt_path}{appname}.pot'
        cmd = cmd.format(lng_dir=lng_dir, lng_code=lng_code, appname=self.__app_name,
                         tgt_path=self.__po_path)
        system(cmd)
        copy(lng_dir + self.__app_name + 'merge.po',
             'assets/locale/po/%s.po' % lng_code)
        poname_tmpl = '{lng_dir}{appname}merge.po'
        remove(poname_tmpl.format(lng_dir=lng_dir, appname=self.__app_name))

    def __postprocess(self, lng_code):
        '''Fixes po files at the end of the building process.'''
        lines = open('assets/locale/po/%s.po' % lng_code, 'r').readlines()
        with open('assets/locale/po/%s.po' % lng_code, 'w') as outf:
            for line in lines:
                po_str = '"POT-Creation-Date: YEAR-MO-DA HO:MI+ZONE\\n"\n'
                outf.write(po_str if line.startswith(po_str[:20]) else line)