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 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, 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
