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 _getParts(self, partIncludes, partsCfg, script):
self._console.debug("Creating part structures...")
self._console.indent()
parts = {}
for partPos, partId in enumerate(partIncludes):
npart = Part(partId) # create new Part object
npart.bit_mask = script.getPartBitMask() # add unique bit
npart.initial_deps = partIncludes[partId][:] # defining classes from config
npart.deps = partIncludes[partId][:] # initialize dependencies with defining classes
if 'expected-load-order' in partsCfg[partId]:
npart.collapse_index = partsCfg[partId]['expected-load-order']
if 'no-merge-private-package' in partsCfg[partId]:
npart.no_merge_private_package = partsCfg[partId]['no-merge-private-package']
parts[partId] = npart
self._console.debug("Part #%s => %s" % (partId, npart.bit_mask))
self._console.outdent()
return parts
def _getParts(self, partIncludes, partsCfg, script):
self._console.debug("Creating part structures...")
self._console.indent()
parts = {}
for partPos, partId in enumerate(partIncludes):
npart = Part(partId) # create new Part object
npart.bit_mask = script.getPartBitMask() # add unique bit
npart.initial_deps = partIncludes[partId][:] # defining classes from config
npart.deps = partIncludes[partId][:] # initialize dependencies with defining classes
if 'expected-load-order' in partsCfg[partId]:
npart.collapse_index = partsCfg[partId]['expected-load-order']
if 'no-merge-private-package' in partsCfg[partId]:
npart.no_merge_private_package = partsCfg[partId]['no-merge-private-package']
parts[partId] = npart
self._console.debug("Part #%s => %s" % (partId, npart.bit_mask))
self._console.outdent()
return parts
def _getParts(self, partIncludes, partsCfg, script):
self._console.debug("Creating part structures...")
self._console.indent()
parts = {}
for partPos, partId in enumerate(partIncludes):
npart = Part(partId) # create new Part object
npart.bit_mask = script.getPartBitMask() # add unique bit
initial_deps = list(
set(partIncludes[partId]).difference(script.excludes)
) # defining classes from config minus expanded excludes
npart.initial_deps = initial_deps # for later cross-part checking
npart.deps = initial_deps[:] # own copy, as this will get expanded
if 'expected-load-order' in partsCfg[partId]:
npart.collapse_index = partsCfg[partId]['expected-load-order']
if 'no-merge-private-package' in partsCfg[partId]:
npart.no_merge_private_package = partsCfg[partId][
'no-merge-private-package']
parts[partId] = npart
self._console.debug("Part #%s => %s" % (partId, npart.bit_mask))
self._console.outdent()
return parts
def _getParts(self, partIncludes, partsCfg, script):
self._console.debug("Creating part structures...")
self._console.indent()
parts = {}
for partPos, partId in enumerate(partIncludes):
npart = Part(partId) # create new Part object
npart.bit_mask = script.getPartBitMask() # add unique bit
initial_deps = list(set(partIncludes[partId]).difference(script.excludes)) # defining classes from config minus expanded excludes
npart.initial_deps = initial_deps # for later cross-part checking
npart.deps = initial_deps[:] # own copy, as this will get expanded
if 'expected-load-order' in partsCfg[partId]:
npart.collapse_index = partsCfg[partId]['expected-load-order']
if 'no-merge-private-package' in partsCfg[partId]:
npart.no_merge_private_package = partsCfg[partId]['no-merge-private-package']
parts[partId] = npart
self._console.debug("Part #%s => %s" % (partId, npart.bit_mask))
self._console.outdent()
return parts
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 partsConfigFromClassList(includeWithDeps, excludeWithDeps, script):
def evalPackagesConfig(excludeWithDeps, classList, variants):
# Reading configuration
partsCfg = self._job.get("packages/parts", {})
# Expanding expressions
self._console.debug("Expanding include expressions...")
partIncludes = {}
for partId in partsCfg:
partIncludes[partId] = textutil.expandGlobs(partsCfg[partId]['include'], self._classesObj)
# Computing packages
#boot, partPackages, packageClasses = self._partBuilder.getPackages(partIncludes, excludeWithDeps, self._context, script)
partPackages, _ = self._partBuilder.getPackages(partIncludes, excludeWithDeps, self._context, script)
packageClasses = script.packagesSorted()
#return boot, partPackages, packageClasses
return script.boot, script.parts, packageClasses
# -----------------------------------------------------------
classList = script.classes
variants = script.variants
self._partBuilder = PartBuilder(self._console, self._depLoader)
# Check for a 'packages' configuration in the job
if 0:
# this branch should work, but doesn't;
# create a synthetic job key and let evalPackagesConfig do the rest
if not self._job.get("packages"):
package_config = {
"parts" : {
"boot" : {
"include" : includeWithDeps
}
},
"init" : "boot"
}
self._job.setFeature("packages", package_config)
(boot,
partPackages, # partPackages[partId]=[0,1,3]
packageClasses # packageClasses[0]=['qx.Class','qx.bom.Stylesheet',...]
) = evalPackagesConfig(excludeWithDeps, classList, variants)
else:
if self._job.get("packages"):
(boot,
partPackages, # partPackages[partId]=[0,1,3]
packageClasses # packageClasses[0]=['qx.Class','qx.bom.Stylesheet',...]
) = evalPackagesConfig(excludeWithDeps, classList, variants)
else:
# Emulate a 'boot' part
boot = "boot"
partPackages = { "boot" : [0] }
packageClasses = [classList]
# patch script object
script.boot = boot
packageObj = Package(0)
packageObj.classes = script.classesObj
script.packages.append(packageObj)
partObj = Part("boot")
partObj.packages.append(packageObj)
initial_deps = list(set(includeWithDeps).difference(script.excludes)) # defining classes from config minus expanded excludes
partObj.initial_deps = initial_deps
partObj.deps = initial_deps[:]
script.parts = { "boot" : partObj }
return boot, partPackages, packageClasses
def partsConfigFromClassList(includeWithDeps, excludeWithDeps, script):
def evalPackagesConfig(excludeWithDeps, classList, variants):
# Reading configuration
partsCfg = self._job.get("packages/parts", {})
# Expanding expressions
self._console.debug("Expanding include expressions...")
partIncludes = {}
for partId in partsCfg:
partIncludes[partId] = textutil.expandGlobs(
partsCfg[partId]['include'], self._classesObj)
# Computing packages
#boot, partPackages, packageClasses = self._partBuilder.getPackages(partIncludes, excludeWithDeps, self._context, script)
partPackages, _ = self._partBuilder.getPackages(
partIncludes, excludeWithDeps, self._context, script)
packageClasses = script.packagesSorted()
#return boot, partPackages, packageClasses
return script.boot, script.parts, packageClasses
# -----------------------------------------------------------
classList = script.classes
variants = script.variants
self._partBuilder = PartBuilder(self._console, self._depLoader)
# Check for a 'packages' configuration in the job
if 0:
# this branch should work, but doesn't;
# create a synthetic job key and let evalPackagesConfig do the rest
if not self._job.get("packages"):
package_config = {
"parts": {
"boot": {
"include": includeWithDeps
}
},
"init": "boot"
}
self._job.setFeature("packages", package_config)
(
boot,
partPackages, # partPackages[partId]=[0,1,3]
packageClasses # packageClasses[0]=['qx.Class','qx.bom.Stylesheet',...]
) = evalPackagesConfig(excludeWithDeps, classList, variants)
else:
if self._job.get("packages"):
(
boot,
partPackages, # partPackages[partId]=[0,1,3]
packageClasses # packageClasses[0]=['qx.Class','qx.bom.Stylesheet',...]
) = evalPackagesConfig(excludeWithDeps, classList,
variants)
else:
# Emulate a 'boot' part
boot = "boot"
partPackages = {"boot": [0]}
packageClasses = [classList]
# patch script object
script.boot = boot
packageObj = Package(0)
packageObj.classes = script.classesObj
script.packages.append(packageObj)
partObj = Part("boot")
partObj.packages.append(packageObj)
initial_deps = list(
set(includeWithDeps).difference(script.excludes)
) # defining classes from config minus expanded excludes
partObj.initial_deps = initial_deps
partObj.deps = initial_deps[:]
script.parts = {"boot": partObj}
return boot, partPackages, packageClasses
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