130 lines
3.4 KiB
Python
130 lines
3.4 KiB
Python
#!/usr/bin/python2
|
|
import codecs
|
|
import glob
|
|
import logging
|
|
import os
|
|
import polib
|
|
import re
|
|
|
|
PO_GLOB = 'src/translations/*.po'
|
|
DESKTOP_PATH = 'dist/org.clementine_player.Clementine.desktop'
|
|
|
|
class ConfigParser(object):
|
|
"""
|
|
Better version of the ConfigParser from the stdlib that handles unicode.
|
|
"""
|
|
|
|
SECTION_RE = re.compile('^\[(.*)\]\s*$')
|
|
VALUE_RE = re.compile('^([^\s=]+)\s*=\s*(.*)')
|
|
|
|
def __init__(self, encoding='utf-8'):
|
|
self._sections = []
|
|
self.encoding = encoding
|
|
|
|
def read(self, filename):
|
|
with codecs.open(filename, 'r', self.encoding) as handle:
|
|
current_section = None
|
|
|
|
for line in handle:
|
|
match = self.SECTION_RE.match(line)
|
|
if match:
|
|
current_section = self._add_section(match.group(1))
|
|
continue
|
|
|
|
match = self.VALUE_RE.match(line)
|
|
if match:
|
|
current_section['items'].append(
|
|
(match.group(1), match.group(2).strip()))
|
|
continue
|
|
|
|
def _add_section(self, section_name):
|
|
section = {
|
|
'name': section_name,
|
|
'items': [],
|
|
}
|
|
self._sections.append(section)
|
|
return section
|
|
|
|
def _find_section(self, section_name):
|
|
return [
|
|
section
|
|
for section in self._sections
|
|
if section['name'] == section_name
|
|
][0]
|
|
|
|
def _find_item_value(self, section, key):
|
|
return [
|
|
item[1]
|
|
for item in section['items']
|
|
if item[0] == key
|
|
][0]
|
|
|
|
def sections(self):
|
|
return [x['name'] for x in self._sections]
|
|
|
|
def get(self, section_name, key):
|
|
try:
|
|
return self._find_item_value(self._find_section(section_name), key)
|
|
except IndexError:
|
|
return None
|
|
|
|
def set(self, section_name, key, value):
|
|
try:
|
|
section = self._find_section(section_name)
|
|
except IndexError:
|
|
section = self._add_section(section_name)
|
|
|
|
for index, (existing_key, _existing_value) in enumerate(section['items']):
|
|
if existing_key == key:
|
|
section['items'][index] = (key, value)
|
|
return
|
|
|
|
section['items'].append((key, value))
|
|
|
|
def write(self, filename):
|
|
with codecs.open(filename, 'w', self.encoding) as handle:
|
|
for section in self._sections:
|
|
handle.write('[%s]\n' % section['name'])
|
|
for key, value in section['items']:
|
|
handle.write('%s=%s\n' % (key, value))
|
|
|
|
handle.write('\n')
|
|
|
|
|
|
def main():
|
|
logging.basicConfig(level=logging.DEBUG,
|
|
format="%(asctime)s %(levelname)-7s %(message)s")
|
|
|
|
config_parser = ConfigParser()
|
|
config_parser.read(DESKTOP_PATH)
|
|
|
|
shortcuts = [
|
|
{
|
|
'section_name': section_name,
|
|
'original': config_parser.get(section_name, 'Name'),
|
|
}
|
|
for section_name in config_parser.sections()
|
|
if section_name.endswith('Shortcut Group')
|
|
]
|
|
|
|
for po_filename in glob.glob(PO_GLOB):
|
|
language = os.path.splitext(os.path.basename(po_filename))[0]
|
|
config_key = 'Name[%s]' % language
|
|
po_file = polib.pofile(po_filename)
|
|
|
|
logging.info('Reading language %s', po_filename)
|
|
|
|
for shortcut in shortcuts:
|
|
original = shortcut['original']
|
|
entry = po_file.find(original)
|
|
if entry is not None and entry.msgstr and entry.msgstr != original:
|
|
logging.info('Setting %s for %s to %s',
|
|
config_key, shortcut['section_name'], entry.msgstr)
|
|
config_parser.set(shortcut['section_name'], config_key, entry.msgstr)
|
|
|
|
config_parser.write(DESKTOP_PATH)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|