def writeI18NFiles(self, globalCodes, script):
# for each locale code, collect mappings
transKeys = globalCodes['Translations'].keys()
localeKeys = globalCodes['Locales'].keys()
newParts = {} # language codes to part objects, {"C": part}
newPackages= {} # language codes to private package objects, {"C": package}
for localeCode in set(transKeys + localeKeys):
# new: also provide a localeCode "part" with corresponding packages
part = Part(localeCode)
part.bit_mask = script.getPartBitMask()
newParts[localeCode] = part
package = Package(part.bit_mask) # this might be modified later
newPackages[localeCode] = package
part.packages.append(package)
data = {}
data[localeCode] = { 'Translations': {}, 'Locales': {} } # we want to have the locale code in the data
if localeCode in transKeys:
data[localeCode]['Translations'] = globalCodes['Translations'][localeCode]
package.data.translations[localeCode] = globalCodes['Translations'][localeCode]
if localeCode in localeKeys:
data[localeCode]['Locales'] = globalCodes['Locales'][localeCode]
package.data.locales[localeCode] = globalCodes['Locales'][localeCode]
# write to file
#dataS = json.dumpsCode(data)
hash, dataS = package.packageContent() # TODO: this currently works only for pure data packages
dataS = dataS.replace('\\\\\\', '\\').replace(r'\\', '\\') # undo damage done by simplejson to raw strings with escapes \\ -> \
package.compiled = dataS
fPath = self._resolveFileName(script.baseScriptPath, script.variants, script.settings, localeCode)
self.writePackage(dataS, fPath, script)
package.file = os.path.basename(fPath) # TODO: the use of os.path.basename is a hack
package.hash = hash
# Finalize the new packages and parts
# - add prerequisite languages to parts; e.g. ["C", "en", "en_EN"]
for partId, part in newParts.items():
if newPackages["C"] not in part.packages:
package = newPackages["C"]
part.packages.append(package) # all need "C"
package.id |= part.bit_mask # adapt package's bit string
if len(partId) > 2 and partId[2] == "_": # it's a sub-language -> include main language
mainlang = partId[:2]
if mainlang not in newPackages:
raise RuntimeError("Locale '%s' specified, but not base locale '%s'" % (partId, mainlang))
if newPackages[mainlang] not in part.packages:
part.packages.append(newPackages[mainlang]) # add main language
newPackages[mainlang].id |= part.bit_mask # adapt package's bit string
# finally, sort packages
for part in newParts.values():
part.packagesSorted
# - add to script object
script.parts.update([(x.name, x) for x in newParts.values()]) # TODO: update might overwrite exist. entries!
script.packages.extend(newPackages.values())
return globalCodes
def generateI18NParts(self, script, globalCodes):
# for each locale code, collect mappings
transKeys = globalCodes['Translations'].keys()
localeKeys = globalCodes['Locales'].keys()
newParts = {} # language codes to part objects, {"C": part}
newPackages= {} # language codes to private package objects, {"C": package}
for localeCode in set(transKeys + localeKeys):
# new: also provide a localeCode "part" with corresponding packages
part = Part(localeCode)
part.bit_mask = script.getPartBitMask()
newParts[localeCode] = part
package = Package(part.bit_mask) # this might be modified later
newPackages[localeCode] = package
part.packages.append(package)
data = {}
data[localeCode] = { 'Translations': {}, 'Locales': {} } # we want to have the locale code in the data
if localeCode in transKeys:
data[localeCode]['Translations'] = globalCodes['Translations'][localeCode]
package.data.translations[localeCode] = globalCodes['Translations'][localeCode]
if localeCode in localeKeys:
data[localeCode]['Locales'] = globalCodes['Locales'][localeCode]
package.data.locales[localeCode] = globalCodes['Locales'][localeCode]
# file name and hash code
hash, dataS = package.packageContent() # TODO: this currently works only for pure data packages
dataS = dataS.replace('\\\\\\', '\\').replace(r'\\', '\\') # undo damage done by simplejson to raw strings with escapes \\ -> \
package.compiled = dataS
package.hash = hash
fPath = self._resolveFileName(script.baseScriptPath, script.variants, script.settings, localeCode)
package.file = os.path.basename(fPath)
if self._job.get("compile-options/paths/scripts-add-hash", False):
package.file = self._fileNameWithHash(package.file, package.hash)
setattr(package,"__localeflag", True) # TODO: temp. hack for writeI18NPackages()
# Finalize the new packages and parts
# - add prerequisite languages to parts; e.g. ["C", "en", "en_EN"]
for partId, part in newParts.items():
if newPackages["C"] not in part.packages:
package = newPackages["C"]
part.packages.append(package) # all need "C"
package.id |= part.bit_mask # adapt package's bit string
if len(partId) > 2 and partId[2] == "_": # it's a sub-language -> include main language
mainlang = partId[:2]
if mainlang not in newPackages:
raise RuntimeError("Locale '%s' specified, but not base locale '%s'" % (partId, mainlang))
if newPackages[mainlang] not in part.packages:
part.packages.append(newPackages[mainlang]) # add main language
newPackages[mainlang].id |= part.bit_mask # adapt package's bit string
# finally, sort packages
for part in newParts.values():
part.packagesSorted
# - add to script object
for partId in newParts:
if partId in script.parts:
raise RuntimeError("Name collison between code part and generated I18N part.")
script.parts[partId] = newParts[partId]
script.packages.extend(newPackages.values())
return script
def generateI18NParts(self, script, locales):
##
# collect translation and locale info from the packages
def getTranslationMaps(packages):
packageTranslations = []
for package in packages:
trans_dat = package.data.translations
loc_dat = package.data.locales
packageTranslations.append((trans_dat,loc_dat))
return packageTranslations
##
# takes an array of (po-data, locale-data) dict pairs
# merge all po data and all cldr data in a single dict each
def mergeTranslationMaps(transMaps):
poData = {}
cldrData = {}
for pac_dat, loc_dat in transMaps:
for loc in pac_dat:
if loc not in poData:
poData[loc] = {}
poData[loc].update(pac_dat[loc])
for loc in loc_dat:
if loc not in cldrData:
cldrData[loc] = {}
cldrData[loc].update(loc_dat[loc])
return (poData, cldrData)
# ----------------------------------------------------------------------
translationMaps = getTranslationMaps(script.packages)
translationData , \
localeData = mergeTranslationMaps(translationMaps)
# for each locale code, collect mappings
transKeys = translationData.keys()
localeKeys = localeData.keys()
newParts = {} # language codes to part objects, {"C": part}
newPackages= {} # language codes to private package objects, {"C": package}
for localeCode in set(transKeys + localeKeys):
# also provide a localeCode "part" with corresponding packages
intpart = Part(localeCode)
intpart.bit_mask = script.getPartBitMask()
newParts[localeCode] = intpart
intpackage = Package(intpart.bit_mask) # this might be modified later
newPackages[localeCode] = intpackage
intpart.packages.append(intpackage)
data = {}
data[localeCode] = { 'Translations': {}, 'Locales': {} } # we want to have the locale code in the data
if localeCode in transKeys:
data[localeCode]['Translations'] = translationData[localeCode]
intpackage.data.translations[localeCode] = translationData[localeCode]
if localeCode in localeKeys:
data[localeCode]['Locales'] = localeData[localeCode]
intpackage.data.locales[localeCode] = localeData[localeCode]
# file name and hash code
hash_, dataS = intpackage.packageContent() # TODO: this currently works only for pure data packages
dataS = dataS.replace('\\\\\\', '\\').replace(r'\\', '\\') # undo damage done by simplejson to raw strings with escapes \\ -> \
intpackage.compiled.append(dataS)
intpackage.hash = hash_
fPath = self._resolveFileName(script.baseScriptPath, script.variants, script.settings, localeCode)
intpackage.file = os.path.basename(fPath)
if self._job.get("compile-options/paths/scripts-add-hash", False):
intpackage.file = self._fileNameWithHash(intpackage.file, intpackage.hash)
intpackage.files = ["%s:%s" % ("__out__", intpackage.file)]
setattr(intpackage,"__localeflag", True) # TODO: temp. hack for writeI18NPackages()
# Finalize the new packages and parts
# - add prerequisite languages to parts; e.g. ["C", "en", "en_EN"]
for partId, intpart in newParts.items():
if newPackages["C"] not in intpart.packages:
intpackage = newPackages["C"]
intpart.packages.append(intpackage) # all need "C"
intpackage.part_mask |= intpart.bit_mask # adapt package's bit string
if len(partId) > 2 and partId[2] == "_": # it's a sub-language -> include main language
mainlang = partId[:2]
if mainlang not in newPackages:
raise RuntimeError("Locale '%s' specified, but not base locale '%s'" % (partId, mainlang))
if newPackages[mainlang] not in intpart.packages:
intpart.packages.append(newPackages[mainlang]) # add main language
newPackages[mainlang].part_mask |= intpart.bit_mask # adapt package's bit string
# finally, sort packages
for intpart in newParts.values():
intpart.packagesSorted
# - add to script object
for partId in newParts:
if partId in script.parts:
raise RuntimeError("Name collison between code part and generated I18N part.")
script.parts[partId] = newParts[partId]
script.packages.extend(newPackages.values())
return script
def generateI18NParts(self, script, globalCodes):
# for each locale code, collect mappings
transKeys = globalCodes['Translations'].keys()
localeKeys = globalCodes['Locales'].keys()
newParts = {} # language codes to part objects, {"C": part}
newPackages= {} # language codes to private package objects, {"C": package}
for localeCode in set(transKeys + localeKeys):
# new: also provide a localeCode "part" with corresponding packages
part = Part(localeCode)
part.bit_mask = script.getPartBitMask()
newParts[localeCode] = part
package = Package(part.bit_mask) # this might be modified later
newPackages[localeCode] = package
part.packages.append(package)
data = {}
data[localeCode] = { 'Translations': {}, 'Locales': {} } # we want to have the locale code in the data
if localeCode in transKeys:
data[localeCode]['Translations'] = globalCodes['Translations'][localeCode]
package.data.translations[localeCode] = globalCodes['Translations'][localeCode]
if localeCode in localeKeys:
data[localeCode]['Locales'] = globalCodes['Locales'][localeCode]
package.data.locales[localeCode] = globalCodes['Locales'][localeCode]
# file name and hash code
hash, dataS = package.packageContent() # TODO: this currently works only for pure data packages
dataS = dataS.replace('\\\\\\', '\\').replace(r'\\', '\\') # undo damage done by simplejson to raw strings with escapes \\ -> \
package.compiled = dataS
package.hash = hash
fPath = self._resolveFileName(script.baseScriptPath, script.variants, script.settings, localeCode)
package.file = os.path.basename(fPath)
if self._job.get("compile-options/paths/scripts-add-hash", False):
package.file = self._fileNameWithHash(package.file, package.hash)
setattr(package,"__localeflag", True) # TODO: temp. hack for writeI18NPackages()
# Finalize the new packages and parts
# - add prerequisite languages to parts; e.g. ["C", "en", "en_EN"]
for partId, part in newParts.items():
if newPackages["C"] not in part.packages:
package = newPackages["C"]
part.packages.append(package) # all need "C"
package.id |= part.bit_mask # adapt package's bit string
if len(partId) > 2 and partId[2] == "_": # it's a sub-language -> include main language
mainlang = partId[:2]
if mainlang not in newPackages:
raise RuntimeError("Locale '%s' specified, but not base locale '%s'" % (partId, mainlang))
if newPackages[mainlang] not in part.packages:
part.packages.append(newPackages[mainlang]) # add main language
newPackages[mainlang].id |= part.bit_mask # adapt package's bit string
# finally, sort packages
for part in newParts.values():
part.packagesSorted
# - add to script object
for partId in newParts:
if partId in script.parts:
raise RuntimeError("Name collison between code part and generated I18N part.")
script.parts[partId] = newParts[partId]
script.packages.extend(newPackages.values())
return script
