def from_doc_root_to_app_root(jobconf, confObj, doc_root):
japp_root = jobconf.get("compile-options/paths/app-root", "source")
app_root = os.path.normpath(os.path.join(confObj.absPath(japp_root), 'index.html'))
# as soon as app_root and doc_root have a drive letter, the next might fail due to capitalization
_, _, url_path = Path.getCommonPrefix(doc_root, app_root)
url_path = Path.posifyPath(url_path)
return url_path
def _scanResourcePath(self, path):
if not os.path.exists(path):
raise ValueError("The given resource path does not exist: %s" % path)
self._console.debug("Scanning resource folder...")
path = os.path.abspath(path)
lib_prefix_len = len(path)
if not path.endswith(os.sep):
lib_prefix_len += 1
for root, dirs, files in filetool.walk(path):
# filter ignored directories
for dir in dirs:
if self._ignoredDirectories.match(dir):
dirs.remove(dir)
for file in files:
fpath = os.path.join(root, file)
fpath = os.path.normpath(fpath)
if Image.isImage(fpath):
if CombinedImage.isCombinedImage(fpath):
res = CombinedImage(fpath)
else:
res = Image(fpath)
res.analyzeImage()
else:
res = Resource(fpath)
res.id = Path.posifyPath(fpath[lib_prefix_len:])
res.library= self
self.resources.add(res)
return
def filter(respath):
respath = Path.posifyPath(respath)
for res in self._resList:
mo = res.search(respath) # this might need a better 'match' algorithm
if mo:
return True
return False
def generateBootScript(bootPackage=""):
def packagesOfFiles(fileUri, packages):
# returns list of lists, each containing destination file name of the corresp. part
# npackages = [['script/gui-0.js'], ['script/gui-1.js'],...]
npackages = []
file = os.path.basename(fileUri)
for packageId in range(len(packages)):
packageFileName = self._resolveFileName(file, variants, settings, packageId)
npackages.append((packageFileName,))
return npackages
self._console.info("Generating boot script...")
bootBlocks = []
# For resource list
resourceUri = compConf.get('uris/resource', 'resource')
resourceUri = Path.posifyPath(resourceUri)
globalCodes = self.generateGlobalCodes(libs, translationMaps, settings, variants, format, resourceUri, scriptUri)
filesPackages = packagesOfFiles(fileUri, packages)
bootBlocks.append(self.generateBootCode(parts, filesPackages, boot, variants, settings, bootPackage, globalCodes, "build", format))
if format:
bootContent = "\n\n".join(bootBlocks)
else:
bootContent = "".join(bootBlocks)
return bootContent
def from_doc_root_to_app_root(jobconf, confObj, doc_root):
japp_root = jobconf.get("compile-options/paths/app-root", "source")
app_root = os.path.normpath(
os.path.join(confObj.absPath(japp_root), 'index.html'))
# as soon as app_root and doc_root have a drive letter, the next might fail due to capitalization
_, _, url_path = Path.getCommonPrefix(doc_root, app_root)
url_path = Path.posifyPath(url_path)
return url_path
def getImageId(imagePath, prefixSpec):
prefix, altprefix = extractFromPrefixSpec(prefixSpec)
imageId = imagePath # init
_, imageId, _ = Path.getCommonPrefix(imagePath, prefix) # assume: imagePath = prefix "/" imageId
if altprefix:
imageId = altprefix + "/" + imageId
imageId = Path.posifyPath(imageId)
return imageId
def getImageId(imagePath, prefixSpec):
prefix, altprefix = extractFromPrefixSpec(prefixSpec)
imageId = imagePath # init
_, imageId, _ = Path.getCommonPrefix(imagePath, prefix) # assume: imagePath = prefix "/" imageId
if altprefix:
imageId = altprefix + "/" + imageId
imageId = Path.posifyPath(imageId)
return imageId
def assetIdFromPath(self, resource, lib):
def extractAssetPart(libresuri, imguri):
pre,libsfx,imgsfx = Path.getCommonPrefix(libresuri, imguri) # split libresuri from imguri
if imgsfx[0] == os.sep: imgsfx = imgsfx[1:] # strip leading '/'
return imgsfx # use the bare img suffix as its asset Id
librespath = os.path.normpath(os.path.join(lib['path'], lib['resource']))
assetId = extractAssetPart(librespath, resource)
assetId = Path.posifyPath(assetId)
return assetId
def _scanResourcePath(self):
resources = set()
if self.resourcePath is None:
return resources
if not os.path.isdir(os.path.join(self.path, self.resourcePath)):
self._console.info("Lib<%s>: Skipping non-existing resource path" %
self.namespace)
return resources
path = os.path.join(self.path, self.resourcePath)
self._console.debug("Scanning resource folder...")
path = os.path.abspath(path)
lib_prefix_len = len(path)
if not path.endswith(os.sep):
lib_prefix_len += 1
for root, dirs, files in filetool.walk(path):
# filter ignored directories
for dir in dirs:
if self._ignoredDirEntries.match(dir):
dirs.remove(dir)
for file in files:
if self._ignoredDirEntries.match(file):
continue
fpath = os.path.join(root, file)
fpath = os.path.normpath(fpath)
if Image.isImage(fpath):
if CombinedImage.isCombinedImage(fpath):
res = CombinedImage(fpath)
else:
res = Image(fpath)
res.analyzeImage()
elif FontMap.isFontMap(fpath):
res = FontMap(fpath)
else:
res = Resource(fpath)
res.set_id(Path.posifyPath(fpath[lib_prefix_len:]))
res.library = self
resources.add(res)
self._console.indent()
self._console.debug("Found %s resources" % len(resources))
self._console.outdent()
return resources
def _scanResourcePath(self):
resources = set()
if self.resourcePath is None:
return resources
if not os.path.isdir(os.path.join(self.path,self.resourcePath)):
self._console.info("Lib<%s>: Skipping non-existing resource path" % self.namespace)
return resources
path = os.path.join(self.path,self.resourcePath)
self._console.debug("Scanning resource folder...")
path = os.path.abspath(path)
lib_prefix_len = len(path)
if not path.endswith(os.sep):
lib_prefix_len += 1
for root, dirs, files in filetool.walk(path):
# filter ignored directories
for dir in dirs:
if self._ignoredDirEntries.match(dir):
dirs.remove(dir)
for file in files:
if self._ignoredDirEntries.match(file):
continue
fpath = os.path.join(root, file)
fpath = os.path.normpath(fpath)
if Image.isImage(fpath):
if CombinedImage.isCombinedImage(fpath):
res = CombinedImage(fpath)
else:
res = Image(fpath)
res.analyzeImage()
elif FontMap.isFontMap(fpath):
res = FontMap(fpath)
else:
res = Resource(fpath)
res.set_id(Path.posifyPath(fpath[lib_prefix_len:]))
res.library= self
resources.add(res)
self._console.indent()
self._console.debug("Found %s resources" % len(resources))
self._console.outdent()
return resources
def _scanResourcePath(self, path):
if not os.path.exists(path):
raise ValueError("The given resource path does not exist: %s" %
path)
self._console.debug("Scanning resource folder...")
path = os.path.abspath(path)
lib_prefix_len = len(path)
if not path.endswith(os.sep):
lib_prefix_len += 1
self.resources = set()
for root, dirs, files in filetool.walk(path):
# filter ignored directories
for dir in dirs:
if self._ignoredDirEntries.match(dir):
dirs.remove(dir)
for file in files:
if self._ignoredDirEntries.match(file):
continue
fpath = os.path.join(root, file)
fpath = os.path.normpath(fpath)
if Image.isImage(fpath):
if CombinedImage.isCombinedImage(fpath):
res = CombinedImage(fpath)
else:
res = Image(fpath)
res.analyzeImage()
else:
res = Resource(fpath)
res.set_id(Path.posifyPath(fpath[lib_prefix_len:]))
res.library = self
self.resources.add(res)
self._console.indent()
self._console.debug("Found %s resources" % len(self.resources))
self._console.outdent()
return
def analyseResource(resource, lib):
##
# compute the resource value of an image for the script
def imgResVal(resource):
imgId = resource
# Cache or generate
if (imgId in imgLookupTable and
imgLookupTable[imgId ]["time"] > os.stat(imgId ).st_mtime):
imageInfo = imgLookupTable[imgId ]["content"]
else:
imageInfo = self._imageInfo.getImageInfo(imgId , assetId)
imgLookupTable[imgId ] = {"time": time.time(), "content": imageInfo}
# Now process the image information
# use an ImgInfoFmt object, to abstract from flat format
imgfmt = ImgInfoFmt()
imgfmt.lib = lib['namespace']
if not 'type' in imageInfo:
raise RuntimeError, "Unable to get image info from file: %s" % imgId
imgfmt.type = imageInfo['type']
# Add this image
# imageInfo = {width, height, filetype}
if not 'width' in imageInfo or not 'height' in imageInfo:
raise RuntimeError, "Unable to get image info from file: %s" % imgId
imgfmt.width = imageInfo['width']
imgfmt.height = imageInfo['height']
imgfmt.type = imageInfo['type']
return imgfmt
# ----------------------------------------------------------
imgpatt = re.compile(r'\.(png|jpeg|jpg|gif)$', re.I)
librespath = os.path.normpath(os.path.join(lib['path'], lib['resource']))
assetId = extractAssetPart(librespath, resource)
assetId = Path.posifyPath(assetId)
if imgpatt.search(resource): # handle images
resvalue = imgResVal(resource)
else: # handle other resources
resvalue = lib['namespace']
return assetId, resvalue
def analyseResource(self, resource):
##
# compute the resource value of an image for the script
def imgResVal(resource, assetId):
imageInfo = self._imageInfoObj.getImageInfo(resource, assetId)
# Now process the image information
# use an ImgInfoFmt object, to abstract from flat format
imgfmt = ImgInfoFmt()
imgfmt.lib = self.namespace
if not 'type' in imageInfo:
raise RuntimeError, "Unable to get image info from file: %s" % resource
imgfmt.type = imageInfo['type']
# Add this image
# imageInfo = {width, height, filetype}
if not 'width' in imageInfo or not 'height' in imageInfo:
raise RuntimeError, "Unable to get image info from file: %s" % resource
imgfmt.width = imageInfo['width']
imgfmt.height = imageInfo['height']
imgfmt.type = imageInfo['type']
return imgfmt
# ----------------------------------------------------------
imgpatt = re.compile(r'\.(png|jpeg|jpg|gif)$', re.I)
librespath = os.path.normpath(self._resourcePath)
lib_prefix_len = len(librespath)
if not librespath.endswith(os.sep):
lib_prefix_len += 1
assetId = resource[lib_prefix_len:]
assetId = Path.posifyPath(assetId)
if imgpatt.search(resource): # handle images
resvalue = imgResVal(resource, assetId)
else: # handle other resources
resvalue = self.namespace
return assetId, resvalue
def analyseResource(self, resource):
##
# compute the resource value of an image for the script
def imgResVal(resource, assetId):
imageInfo = self._imageInfoObj.getImageInfo(resource, assetId)
# Now process the image information
# use an ImgInfoFmt object, to abstract from flat format
imgfmt = ImgInfoFmt()
imgfmt.lib = self.namespace
if not "type" in imageInfo:
raise RuntimeError, "Unable to get image info from file: %s" % resource
imgfmt.type = imageInfo["type"]
# Add this image
# imageInfo = {width, height, filetype}
if not "width" in imageInfo or not "height" in imageInfo:
raise RuntimeError, "Unable to get image info from file: %s" % resource
imgfmt.width = imageInfo["width"]
imgfmt.height = imageInfo["height"]
imgfmt.type = imageInfo["type"]
return imgfmt
# ----------------------------------------------------------
imgpatt = re.compile(r"\.(png|jpeg|jpg|gif)$", re.I)
librespath = os.path.normpath(self._resourcePath)
lib_prefix_len = len(librespath)
if not librespath.endswith(os.sep):
lib_prefix_len += 1
assetId = resource[lib_prefix_len:]
assetId = Path.posifyPath(assetId)
if imgpatt.search(resource): # handle images
resvalue = imgResVal(resource, assetId)
else: # handle other resources
resvalue = self.namespace
return assetId, resvalue
def processCombinedImg(data, meta_fname, combinedImageUri, combinedImageShortUri, combinedImageObject):
# make sure lib and type info for the combined image are present
assert combinedImageObject.lib, combinedImageObject.type
# see if we have cached the contents (json) of this .meta file
cacheId = "imgcomb-%s" % meta_fname
imgDict = self._cache.read(cacheId, meta_fname)
if imgDict == None:
mfile = open(meta_fname)
imgDict = simplejson.loads(mfile.read())
mfile.close()
self._cache.write(cacheId, imgDict)
# now loop through the dict structure from the .meta file
for imagePath, imageSpec_ in imgDict.items():
# sort of like this: imagePath : [width, height, type, combinedUri, off-x, off-y]
imageObject = ImgInfoFmt(imageSpec_) # turn this into an ImgInfoFmt object, to abstract from representation in .meta file and loader script
# have to normalize the uri's from the meta file
#imageUri = normalizeImgUri(imagePath, combinedImageUri, imageObject.mappedId)
imageUri = imagePath
## replace lib uri with lib namespace in imageUri
imageShortUri = extractAssetPart(librespath, imageUri)
imageShortUri = Path.posifyPath(imageShortUri)
# now put all elements of the image object together
imageObject.mappedId = combinedImageShortUri # correct the mapped uri of the combined image
imageObject.lib = combinedImageObject.lib
imageObject.mtype = combinedImageObject.type
imageObject.mlib = combinedImageObject.lib
# and store it in the data structure
data[imageShortUri] = imageObject.flatten() # this information takes precedence over existing
return
def runCompiled(self, script, treeCompiler, version="build"):
def getOutputFile(compileType):
filePath = compConf.get("paths/file")
if not filePath:
filePath = os.path.join(compileType, "script", script.namespace + ".js")
return filePath
def getFileUri(scriptUri):
appfile = os.path.basename(fileRelPath)
fileUri = os.path.join(scriptUri, appfile) # make complete with file name
fileUri = Path.posifyPath(fileUri)
return fileUri
##
# returns the Javascript code for the initial ("boot") script as a string,
# using the loader.tmpl template and filling its placeholders
def generateBootCode(parts, packages, boot, script, compConf, variants, settings, bootCode, globalCodes, version="source", decodeUrisFile=None, format=False):
##
# create a map with part names as key and array of package id's and
# return as string
def partsMap(script):
partData = {}
packages = script.packagesSortedSimple()
#print "packages: %r" % packages
for part in script.parts:
partData[part] = script.parts[part].packagesAsIndices(packages)
#print "part '%s': %r" % (part, script.parts[part].packages)
partData = json.dumpsCode(partData)
return partData
def fillTemplate(vals, template):
# Fill the code template with various vals
templ = MyTemplate(template)
result = templ.safe_substitute(vals)
return result
def packageUrisToJS1(packages, version, namespace=None):
# Translate URI data to JavaScript
allUris = []
for packageId, package in enumerate(packages):
packageUris = []
for fileId in package:
if version == "build":
# TODO: gosh, the next is an ugly hack!
#namespace = self._resourceHandler._genobj._namespaces[0] # all name spaces point to the same paths in the libinfo struct, so any of them will do
if not namespace:
namespace = script.namespace # all name spaces point to the same paths in the libinfo struct, so any of them will do
relpath = OsPath(fileId)
else:
namespace = self._classes[fileId]["namespace"]
relpath = OsPath(self._classes[fileId]["relpath"])
shortUri = Uri(relpath.toUri())
packageUris.append("%s:%s" % (namespace, shortUri.encodedValue()))
allUris.append(packageUris)
return allUris
##
# Translate URI data to JavaScript
# using Package objects
def packageUrisToJS(packages, version):
allUris = []
for packageId, package in enumerate(packages):
packageUris = []
if package.file: # build
namespace = "__out__"
fileId = package.file
relpath = OsPath(fileId)
shortUri = Uri(relpath.toUri())
packageUris.append("%s:%s" % (namespace, shortUri.encodedValue()))
else: # "source" :
for clazz in package.classes:
namespace = self._classes[clazz]["namespace"]
relpath = OsPath(self._classes[clazz]["relpath"])
shortUri = Uri(relpath.toUri())
packageUris.append("%s:%s" % (namespace, shortUri.encodedValue()))
allUris.append(packageUris)
return allUris
def loadTemplate(bootCode):
# try custom loader templates
loaderFile = compConf.get("paths/loader-template", None)
if not loaderFile:
# use default templates
if version=="build":
#loaderFile = os.path.join(filetool.root(), os.pardir, "data", "generator", "loader-build.tmpl.js")
# TODO: test-wise using generic template
loaderFile = os.path.join(filetool.root(), os.pardir, "data", "generator", "loader.tmpl.js")
else:
#loaderFile = os.path.join(filetool.root(), os.pardir, "data", "generator", "loader-source.tmpl.js")
loaderFile = os.path.join(filetool.root(), os.pardir, "data", "generator", "loader.tmpl.js")
template = filetool.read(loaderFile)
return template
# ---------------------------------------------------------------
if not parts:
return ""
result = ""
vals = {}
packages = script.packagesSortedSimple()
loader_with_boot = self._job.get("packages/loader-with-boot", True)
# stringify data in globalCodes
for entry in globalCodes:
globalCodes[entry] = json.dumpsCode(globalCodes[entry])
# undo damage done by simplejson to raw strings with escapes \\ -> \
globalCodes[entry] = globalCodes[entry].replace('\\\\\\', '\\').replace(r'\\', '\\') # " gets tripple escaped, therefore the first .replace()
vals.update(globalCodes)
if version=="build":
vals["Resources"] = json.dumpsCode({}) # TODO: undo Resources from globalCodes!!!
vals["Boot"] = '"%s"' % boot
if version == "build":
vals["BootPart"] = bootCode
else:
vals["BootPart"] = ""
# fake package data
for key, package in enumerate(packages):
vals["BootPart"] += "qx.$$packageData['%d']={};\n" % key
# Translate part information to JavaScript
vals["Parts"] = partsMap(script)
# Translate URI data to JavaScript
#vals["Uris"] = packageUrisToJS1(packages, version)
vals["Uris"] = packageUrisToJS(packages, version)
vals["Uris"] = json.dumpsCode(vals["Uris"])
# Add potential extra scripts
vals["UrisBefore"] = []
if self._job.get("add-script", False):
additional_scripts = self._job.get("add-script",[])
for additional_script in additional_scripts:
vals["UrisBefore"].append(additional_script["uri"])
vals["UrisBefore"] = json.dumpsCode(vals["UrisBefore"])
# Whether boot package is inline
if version == "source":
vals["BootIsInline"] = json.dumpsCode(False)
else:
vals["BootIsInline"] = json.dumpsCode(loader_with_boot)
# Closure package information
cParts = {}
if version == "build":
for part in script.parts:
if not loader_with_boot or part != "boot":
cParts[part] = True
vals["ClosureParts"] = json.dumpsCode(cParts)
# Package Hashes
vals["PackageHashes"] = {}
for key, package in enumerate(packages):
if package.hash:
vals["PackageHashes"][key] = package.hash
else:
vals["PackageHashes"][key] = "%d" % key # fake code package hashes in source ver.
vals["PackageHashes"] = json.dumpsCode(vals["PackageHashes"])
# Script hook for qx.$$loader.decodeUris() function
vals["DecodeUrisPlug"] = ""
if decodeUrisFile:
plugCode = filetool.read(self._config.absPath(decodeUrisFile)) # let it bomb if file can't be read
vals["DecodeUrisPlug"] = plugCode.strip()
# Enable "?nocache=...." for script loading?
vals["NoCacheParam"] = "true" if self._job.get("compile-options/uris/add-nocache-param", True) else "false"
# Add build details
vals["Build"] = int(time.time()*1000)
vals["Type"] = version
# Locate and load loader basic script
template = loadTemplate(bootCode)
# Fill template gives result
result = fillTemplate(vals, template)
return result
##
# shallow layer above generateBootCode(), and its only client
def generateBootScript(globalCodes, script, bootPackage="", compileType="build"):
self._console.info("Generating boot script...")
if not self._job.get("packages/i18n-with-boot", True):
# remove I18N info from globalCodes, so they don't go into the loader
globalCodes["Translations"] = {}
globalCodes["Locales"] = {}
else:
if compileType == "build":
# also remove them here, as this info is now with the packages
globalCodes["Translations"] = {}
globalCodes["Locales"] = {}
plugCodeFile = compConf.get("code/decode-uris-plug", False)
if compileType == "build":
filepackages = [(x.file,) for x in packages]
bootContent = generateBootCode(parts, filepackages, boot, script, compConf, variants, settings, bootPackage, globalCodes, compileType, plugCodeFile, format)
else:
filepackages = [x.classes for x in packages]
bootContent = generateBootCode(parts, filepackages, boot, script, compConf, variants={}, settings={}, bootCode=None, globalCodes=globalCodes, version=compileType, decodeUrisFile=plugCodeFile, format=format)
return bootContent
def getPackageData(package):
data = {}
data["resources"] = package.data.resources
data["translations"] = package.data.translations
data["locales"] = package.data.locales
data = json.dumpsCode(data)
data += ';\n'
return data
def compilePackage(packageIndex, package):
self._console.info("Compiling package #%s:" % packageIndex, False)
self._console.indent()
# Compile file content
pkgCode = self._treeCompiler.compileClasses(package.classes, variants, optimize, format)
pkgData = getPackageData(package)
hash = sha.getHash(pkgData + pkgCode)[:12] # first 12 chars should be enough
isBootPackage = packageIndex == 0
if isBootPackage:
compiledContent = ("qx.$$packageData['%s']=" % hash) + pkgData + pkgCode
else:
compiledContent = u'''qx.$$packageData['%s']=%s\n''' % (hash, pkgData)
compiledContent += u'''qx.Part.$$notifyLoad("%s", function() {\n%s\n});''' % (hash, pkgCode)
#
package.hash = hash # to fill qx.$$loader.packageHashes in generateBootScript()
self._console.debug("Done: %s" % self._computeContentSize(compiledContent))
self._console.outdent()
return compiledContent
##
# 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)
# -- Main - runCompiled ------------------------------------------------
# Early return
compileType = self._job.get("compile/type", "")
if compileType not in ("build", "source"):
return
packages = script.packagesSortedSimple()
parts = script.parts
boot = script.boot
variants = script.variants
libraries = script.libraries
self._treeCompiler = treeCompiler
self._variants = variants
self._script = script
self._console.info("Generate %s version..." % compileType)
self._console.indent()
# - Evaluate job config ---------------------
# Compile config
compConf = self._job.get("compile-options")
compConf = ExtMap(compConf)
# Whether the code should be formatted
format = compConf.get("code/format", False)
script.scriptCompress = compConf.get("paths/gzip", False)
# Read in settings
settings = self.getSettings()
script.settings = settings
# Read libraries
libs = self._job.get("library", [])
# Get translation maps
locales = compConf.get("code/locales", [])
translationMaps = self.getTranslationMaps(packages, variants, locales)
# Read in base file name
fileRelPath = getOutputFile(compileType)
filePath = self._config.absPath(fileRelPath)
script.baseScriptPath = filePath
if compileType == "build":
# read in uri prefixes
scriptUri = compConf.get('uris/script', 'script')
scriptUri = Path.posifyPath(scriptUri)
fileUri = getFileUri(scriptUri)
# for resource list
resourceUri = compConf.get('uris/resource', 'resource')
resourceUri = Path.posifyPath(resourceUri)
else:
# source version needs place where the app HTML ("index.html") lives
self.approot = self._config.absPath(compConf.get("paths/app-root", ""))
resourceUri = None
scriptUri = None
# Get global script data (like qxlibraries, qxresources,...)
globalCodes = {}
globalCodes["Settings"] = settings
globalCodes["Variants"] = self.generateVariantsCode(variants)
globalCodes["Libinfo"] = self.generateLibInfoCode(libs, format, resourceUri, scriptUri)
# add synthetic output lib
if scriptUri: out_sourceUri= scriptUri
else:
out_sourceUri = self._computeResourceUri({'class': ".", 'path': os.path.dirname(script.baseScriptPath)}, OsPath(""), rType="class", appRoot=self.approot)
out_sourceUri = os.path.normpath(out_sourceUri.encodedValue())
globalCodes["Libinfo"]['__out__'] = { 'sourceUri': out_sourceUri }
globalCodes["Resources"] = self.generateResourceInfoCode(script, settings, libraries, format)
globalCodes["Translations"],\
globalCodes["Locales"] = mergeTranslationMaps(translationMaps)
# Potentally create dedicated I18N packages
i18n_as_parts = not self._job.get("packages/i18n-with-boot", True)
if i18n_as_parts:
script = self.generateI18NParts(script, globalCodes)
self.writePackages([p for p in script.packages if getattr(p, "__localeflag", False)], script)
if compileType == "build":
# - Specific job config ---------------------
# read in compiler options
optimize = compConf.get("code/optimize", [])
self._treeCompiler.setOptimize(optimize)
# - Generating packages ---------------------
self._console.info("Generating packages...")
self._console.indent()
bootPackage = ""
for packageIndex, package in enumerate(packages):
package.compiled = compilePackage(packageIndex, package)
self._console.outdent()
if not len(packages):
raise RuntimeError("No valid boot package generated.")
# - Put loader and packages together -------
loader_with_boot = self._job.get("packages/loader-with-boot", True)
# handle loader and boot package
if not loader_with_boot:
loadPackage = Package(0) # make a dummy Package for the loader
packages.insert(0, loadPackage)
# attach file names (do this before calling generateBootScript)
for package, fileName in zip(packages, self.packagesFileNames(script.baseScriptPath, len(packages))):
package.file = os.path.basename(fileName)
if self._job.get("compile-options/paths/scripts-add-hash", False):
package.file = self._fileNameWithHash(package.file, package.hash)
# generate and integrate boot code
if loader_with_boot:
# merge loader code with first package
bootCode = generateBootScript(globalCodes, script, packages[0].compiled)
packages[0].compiled = bootCode
else:
loaderCode = generateBootScript(globalCodes, script)
packages[0].compiled = loaderCode
# write packages
self.writePackages(packages, script)
# ---- 'source' version ------------------------------------------------
else:
sourceContent = generateBootScript(globalCodes, script, bootPackage="", compileType=compileType)
# Construct file name
resolvedFilePath = self._resolveFileName(filePath, variants, settings)
# Save result file
filetool.save(resolvedFilePath, sourceContent)
if compConf.get("paths/gzip"):
filetool.gzip(resolvedFilePath, sourceContent)
self._console.outdent()
self._console.debug("Done: %s" % self._computeContentSize(sourceContent))
self._console.outdent()
self._console.outdent()
return # runCompiled()
def flatten(self):
a = [self.width, self.height, self.type, self.lib]
if self.mappedId:
a.extend([Path.posifyPath(self.mappedId), self.left, self.top])
return a
def flatten(self):
a = [self.width, self.height, self.type, self.lib]
if self.mappedId:
a.extend([Path.posifyPath(self.mappedId), self.left, self.top])
return a
def runCompiled(self, script, treeCompiler):
def getAppName(memo={}):
if not 'appname' in memo:
appname = self._job.get("let/APPLICATION")
if not appname:
raise RuntimeError, "Need an application name in config (key let/APPLICATION)"
else:
memo['appname'] = appname
return memo['appname']
def getOutputFile():
filePath = compConf.get("paths/file")
if not filePath:
filePath = os.path.join("build", "script", getAppName() + ".js")
return filePath
def getFileUri(scriptUri):
appfile = os.path.basename(fileRelPath)
fileUri = os.path.join(scriptUri, appfile) # make complete with file name
fileUri = Path.posifyPath(fileUri)
return fileUri
def generateBootScript(bootPackage=""):
def packagesOfFiles(fileUri, packages):
# returns list of lists, each containing destination file name of the corresp. part
# npackages = [['script/gui-0.js'], ['script/gui-1.js'],...]
npackages = []
file = os.path.basename(fileUri)
for packageId in range(len(packages)):
packageFileName = self._resolveFileName(file, variants, settings, packageId)
npackages.append((packageFileName,))
return npackages
self._console.info("Generating boot script...")
bootBlocks = []
# For resource list
resourceUri = compConf.get('uris/resource', 'resource')
resourceUri = Path.posifyPath(resourceUri)
globalCodes = self.generateGlobalCodes(libs, translationMaps, settings, variants, format, resourceUri, scriptUri)
filesPackages = packagesOfFiles(fileUri, packages)
bootBlocks.append(self.generateBootCode(parts, filesPackages, boot, variants, settings, bootPackage, globalCodes, "build", format))
if format:
bootContent = "\n\n".join(bootBlocks)
else:
bootContent = "".join(bootBlocks)
return bootContent
def writePackages(compiledPackages, startId=0):
for packageId, content in enumerate(compiledPackages):
writePackage(content, startId + packageId)
return
def writePackage(content, packageId=""):
# Construct file name
resolvedFilePath = self._resolveFileName(filePath, variants, settings, packageId)
# Save result file
filetool.save(resolvedFilePath, content)
if compConf.get("paths/gzip"):
filetool.gzip(resolvedFilePath, content)
self._console.debug("Done: %s" % self._computeContentSize(content))
self._console.debug("")
return
# ----------------------------------------------------------------------
if not self._job.get("compile-dist", False):
return
packages = script.packages
parts = script.parts
boot = script.boot
variants = script.variants
classList = script.classes
self._treeCompiler = treeCompiler
self._classList = classList
compConf = ExtMap(self._job.get("compile-dist"))
# Read in base file name
fileRelPath = getOutputFile()
filePath = self._config.absPath(fileRelPath)
# Read in uri prefixes
scriptUri = compConf.get('uris/script', 'script')
scriptUri = Path.posifyPath(scriptUri)
fileUri = getFileUri(scriptUri)
# Read in compiler options
optimize = compConf.get("code/optimize", [])
self._treeCompiler.setOptimize(optimize)
# Whether the code should be formatted
format = compConf.get("code/format", False)
# Read in settings
settings = self.getSettings()
# Get translation maps
locales = compConf.get("code/locales", [])
translationMaps = self.getTranslationMaps(packages, variants, locales)
libs = self._job.get("library", [])
# Generating packages
self._console.info("Generating packages...")
self._console.indent()
bootPackage = ""
compiledPackages = []
for packageId, classes in enumerate(packages):
self._console.info("Compiling package #%s:" % packageId, False)
self._console.indent()
# Compile file content
compiledContent = self._treeCompiler.compileClasses(classes, variants, optimize, format)
compiledPackages.append(compiledContent)
self._console.debug("Done: %s" % self._computeContentSize(compiledContent))
self._console.outdent()
self._console.outdent()
# Generating boot script
if not len(compiledPackages):
raise RuntimeError("No valid boot package generated.")
if self._job.get("packages/loader-with-boot", True):
content = generateBootScript(compiledPackages[0])
writePackage(content)
writePackages(compiledPackages[1:], 1)
else:
content = generateBootScript()
writePackage(content)
writePackages(compiledPackages)
return
def from_doc_root_to_app_root(jobconf, confObj, doc_root):
japp_root = jobconf.get("compile-options/paths/app-root", "source")
app_root = os.path.normpath(os.path.join(confObj.absPath(japp_root), 'index.html'))
_, _, url_path = Path.getCommonPrefix(doc_root, app_root)
url_path = Path.posifyPath(url_path)
return url_path
def getFileUri(scriptUri):
appfile = os.path.basename(fileRelPath)
fileUri = os.path.join(scriptUri, appfile) # make complete with file name
fileUri = Path.posifyPath(fileUri)
return fileUri
def getFileUri(scriptUri):
appfile = os.path.basename(fileRelPath)
fileUri = os.path.join(scriptUri, appfile) # make complete with file name
fileUri = Path.posifyPath(fileUri)
return fileUri
def generateResourceInfoCode(self, settings, libs, format=False):
"""Pre-calculate image information (e.g. sizes)"""
data = {}
resdata = data
imgpatt = re.compile(r'\.(png|jpeg|jpg|gif)$', re.I)
skippatt = re.compile(r'\.(meta|py)$', re.I)
self._console.info("Analysing assets...")
self._console.indent()
self._imageInfo = ImageInfo(self._console, self._cache)
# some helper functions
def replaceWithNamespace(imguri, liburi, libns):
pre,libsfx,imgsfx = Path.getCommonPrefix(liburi, imguri)
if imgsfx[0] == os.sep: imgsfx = imgsfx[1:] # strip leading '/'
imgshorturi = os.path.join("${%s}" % libns, imgsfx)
return imgshorturi
def extractAssetPart(libresuri, imguri):
pre,libsfx,imgsfx = Path.getCommonPrefix(libresuri, imguri) # split libresuri from imguri
if imgsfx[0] == os.sep: imgsfx = imgsfx[1:] # strip leading '/'
return imgsfx # use the bare img suffix as its asset Id
##
# calculate the uri of the clipped image, by taking the uri of the combined image,
# "substracting" its asset id (the right end), taking what remains (the left
# part), extracting the asset id of the clipped image, and pre-fixing it with the
# left part of the combined image uri.
# imageUri = (combinedUri - combinedAssetId) + imageAssetId
#
# @param uriFromMetafile |String| the path of the clipped image from when the meta file was generated,
# like: "./source/resource/qx/decoration/Modern/..."
# @param trueCombinedUri |String| the uri of the combined image, as returned from
# the library scan and adapted for the current
# application, like:
# "../../framework/source/resource/qx/decoration/Modern/panel-combined.png"
# @param combinedUriFromMetafile |String| the path of the combined image, as
# recorded in the .meta file
def normalizeImgUri(uriFromMetafile, trueCombinedUri, combinedUriFromMetafile):
# normalize paths (esp. "./x" -> "x")
(uriFromMetafile, trueCombinedUri, combinedUriFromMetafile) = map(os.path.normpath,
(uriFromMetafile, trueCombinedUri, combinedUriFromMetafile))
# get the "wrong" left part of the combined image, as used in the .meta file (in mappedUriPrefix)
trueUriPrefix, mappedUriPrefix, _ = Path.getCommonSuffix(trueCombinedUri, combinedUriFromMetafile)
# ...and strip it from clipped image, to get a correct image id (in uriSuffix)
_, _, uriSuffix = Path.getCommonPrefix(mappedUriPrefix, uriFromMetafile)
# ...then compose the correct prefix with the correct suffix
normalUri = os.path.normpath(os.path.join(trueUriPrefix, uriSuffix))
return normalUri
##
# - reads through the entries of a .meta file, which is the contents of a combined image
# - for each contained image:
# - computes the image id ("short uri")
# - collects the list of interesting values (width, height, ..., combined image, ...)
# - and adds these as key:value to the general data map of images
#
# @param data |{imageId:[width, height, ...]}| general map for qx.$$resource in loader
# @param meta_fname |String| file path of the .meta file
# @param combinedImageUri |String| uri of the combined image
# @param combinedImageShortUri |String| short uri (image/asset id) of the combined image
# these are necessary to compute the image id's of the contained imgs
# @param combinedImageObject |ImgInfoFmt| an ImgInfoFmt wrapper object for the combined image
# (interesting for the lib and type info)
def processCombinedImg(data, meta_fname, combinedImageUri, combinedImageShortUri, combinedImageObject):
# make sure lib and type info for the combined image are present
assert combinedImageObject.lib, combinedImageObject.type
# see if we have cached the contents (json) of this .meta file
cacheId = "imgcomb-%s" % meta_fname
imgDict = self._cache.read(cacheId, meta_fname)
if imgDict == None:
mfile = open(meta_fname)
imgDict = simplejson.loads(mfile.read())
mfile.close()
self._cache.write(cacheId, imgDict)
# now loop through the dict structure from the .meta file
for imagePath, imageSpec_ in imgDict.items():
# sort of like this: imagePath : [width, height, type, combinedUri, off-x, off-y]
imageObject = ImgInfoFmt(imageSpec_) # turn this into an ImgInfoFmt object, to abstract from representation in .meta file and loader script
# have to normalize the uri's from the meta file
#imageUri = normalizeImgUri(imagePath, combinedImageUri, imageObject.mappedId)
imageUri = imagePath
## replace lib uri with lib namespace in imageUri
imageShortUri = extractAssetPart(librespath, imageUri)
imageShortUri = Path.posifyPath(imageShortUri)
# now put all elements of the image object together
imageObject.mappedId = combinedImageShortUri # correct the mapped uri of the combined image
imageObject.lib = combinedImageObject.lib
imageObject.mtype = combinedImageObject.type
imageObject.mlib = combinedImageObject.lib
# and store it in the data structure
data[imageShortUri] = imageObject.flatten() # this information takes precedence over existing
return
# -- main --------------------------------------------------------------
resourceFilter= self._resourceHandler.getResourceFilterByAssets(self._classList)
for lib in libs:
#libresuri = self._computeResourceUri(lib, "", rType='resource', appRoot=self.approot)
librespath = os.path.normpath(os.path.join(lib['path'], lib['resource']))
resourceList = self._resourceHandler.findAllResources([lib], resourceFilter)
# resourceList = [[file1,uri1],[file2,uri2],...]
for resource in resourceList:
##assetId = replaceWithNamespace(imguri, libresuri, lib['namespace'])
#assetId = extractAssetPart(libresuri, resource[1])
assetId = extractAssetPart(librespath,resource)
assetId = Path.posifyPath(assetId)
if imgpatt.search(resource): # handle images
imgpath= resource
#imguri = resource[1]
imguri = resource
imageInfo = self._imageInfo.getImageInfo(imgpath, assetId)
# use an ImgInfoFmt object, to abstract from flat format
imgfmt = ImgInfoFmt()
imgfmt.lib = lib['namespace']
if not 'type' in imageInfo:
raise RuntimeError, "Unable to get image info from file: %s" % imgpath
imgfmt.type = imageInfo['type']
# check for a combined image and process the contained images
meta_fname = os.path.splitext(imgpath)[0]+'.meta'
if os.path.exists(meta_fname): # add included imgs
processCombinedImg(data, meta_fname, imguri, assetId, imgfmt)
# add this image directly
# imageInfo = {width, height, filetype}
if not 'width' in imageInfo or not 'height' in imageInfo:
raise RuntimeError, "Unable to get image info from file: %s" % imgpath
imgfmt.width, imgfmt.height, imgfmt.type = (
imageInfo['width'], imageInfo['height'], imageInfo['type'])
# check if img is already registered as part of a combined image
if assetId in data:
x = ImgInfoFmt()
x.fromFlat(data[assetId])
if x.mappedId:
continue # don't overwrite the combined entry
data[assetId] = imgfmt.flatten()
elif skippatt.search(resource[0]):
continue
else: # handle other resources
resdata[assetId] = lib['namespace']
# wpbasti: Image data is not part relevant yet.
self._console.outdent()
return resdata
def runCompiled(self, script, treeCompiler, version="build"):
def getOutputFile(compileType):
filePath = compConf.get("paths/file")
if not filePath:
filePath = os.path.join(compileType, "script", self.getAppName() + ".js")
return filePath
def getFileUri(scriptUri):
appfile = os.path.basename(fileRelPath)
fileUri = os.path.join(scriptUri, appfile) # make complete with file name
fileUri = Path.posifyPath(fileUri)
return fileUri
def generateBootScript(globalCodes, script, bootPackage="", compileType="build"):
def packagesOfFiles(fileUri, packages):
# returns list of lists, each containing destination file name of the corresp. part
# npackages = [['script/gui-0.js'], ['script/gui-1.js'],...]
npackages = []
file = os.path.basename(fileUri)
if self._job.get("packages/loader-with-boot", True):
totalLen = len(packages)
else:
totalLen = len(packages) + 1
for packageId, packageFileName in enumerate(self.packagesFileNames(file, totalLen, classPackagesOnly=True)):
npackages.append((packageFileName,))
packages[packageId].file = packageFileName # TODO: very unnice to fix this here
return npackages
# besser: fixPackagesFiles()
def packagesOfFilesX(fileUri, packages):
# returns list of lists, each containing destination file name of the corresp. package
# npackages = [['script/gui-0.js'], ['script/gui-1.js'],...]
file = os.path.basename(fileUri)
loader_with_boot = self._job.get("packages/loader-with-boot", True)
for packageId, package in enumerate(packages):
if loader_with_boot:
suffix = packageId - 1
if suffix < 0:
suffix = ""
else:
suffix = packageId
packageFileName = self._resolveFileName(file, self._variants, self._settings, suffix)
package.file = packageFileName
return packages
# ----------------------------------------------------------------------------
self._console.info("Generating boot script...")
if not self._job.get("packages/i18n-with-boot", True):
globalCodes = self.writeI18NFiles(globalCodes, script)
# remove I18N info from globalCodes, so they don't go into the loader
globalCodes["Translations"] = {}
globalCodes["Locales"] = {}
else:
if compileType == "build":
# also remove them here, as this info is now with the packages
globalCodes["Translations"] = {}
globalCodes["Locales"] = {}
plugCodeFile = compConf.get("code/decode-uris-plug", False)
if compileType == "build":
filepackages = packagesOfFiles(fileUri, packages)
bootContent = self.generateBootCode(parts, filepackages, boot, script, compConf, variants, settings, bootPackage, globalCodes, compileType, plugCodeFile, format)
else:
filepackages = [x.classes for x in packages]
bootContent = self.generateBootCode(parts, filepackages, boot, script, compConf, variants={}, settings={}, bootCode=None, globalCodes=globalCodes, version=compileType, decodeUrisFile=plugCodeFile, format=format)
return bootContent
def getPackageData(package):
data = {}
data["resources"] = package.data.resources
data["translations"] = package.data.translations
data["locales"] = package.data.locales
data = json.dumpsCode(data)
data += ';\n'
return data
def compilePackage(packageIndex, package):
self._console.info("Compiling package #%s:" % packageIndex, False)
self._console.indent()
# Compile file content
pkgCode = self._treeCompiler.compileClasses(package.classes, variants, optimize, format)
pkgData = getPackageData(package)
hash = sha.getHash(pkgData + pkgCode)[:12] # first 12 chars should be enough
isBootPackage = packageIndex == 0
if isBootPackage:
compiledContent = ("qx.$$packageData['%s']=" % hash) + pkgData + pkgCode
else:
compiledContent = u'''qx.$$packageData['%s']=%s\n''' % (hash, pkgData)
compiledContent += u'''qx.Part.$$notifyLoad("%s", function() {\n%s\n});''' % (hash, pkgCode)
#
package.hash = hash # to fill qx.$$loader.packageHashes in generateBootScript()
self._console.debug("Done: %s" % self._computeContentSize(compiledContent))
self._console.outdent()
return compiledContent
# -- Main --------------------------------------------------------------
# Early return
compileType = self._job.get("compile/type", "")
if compileType not in ("build", "source"):
return
packages = script.packagesSortedSimple()
parts = script.parts
boot = script.boot
variants = script.variants
self._classList = script.classes
self._treeCompiler = treeCompiler
self._variants = variants
self._console.info("Generate %s version..." % compileType)
self._console.indent()
# - Evaluate job config ---------------------
# Compile config
compConf = self._job.get("compile-options")
compConf = ExtMap(compConf)
# Whether the code should be formatted
format = compConf.get("code/format", False)
script.scriptCompress = compConf.get("paths/gzip", False)
# Read in settings
settings = self.getSettings()
script.settings = settings
# Read libraries
libs = self._job.get("library", [])
# Get translation maps
locales = compConf.get("code/locales", [])
translationMaps = self.getTranslationMaps(packages, variants, locales)
# Read in base file name
fileRelPath = getOutputFile(compileType)
filePath = self._config.absPath(fileRelPath)
script.baseScriptPath = filePath
if compileType == "build":
# read in uri prefixes
scriptUri = compConf.get('uris/script', 'script')
scriptUri = Path.posifyPath(scriptUri)
fileUri = getFileUri(scriptUri)
# for resource list
resourceUri = compConf.get('uris/resource', 'resource')
resourceUri = Path.posifyPath(resourceUri)
else:
# source version needs place where the app HTML ("index.html") lives
self.approot = self._config.absPath(compConf.get("paths/app-root", ""))
resourceUri = None
scriptUri = None
# Get global script data (like qxlibraries, qxresources,...)
globalCodes = self.generateGlobalCodes(script, libs, translationMaps, settings, variants, format, resourceUri, scriptUri)
if compileType == "build":
# - Specific job config ---------------------
# read in compiler options
optimize = compConf.get("code/optimize", [])
self._treeCompiler.setOptimize(optimize)
# - Generating packages ---------------------
self._console.info("Generating packages...")
self._console.indent()
bootPackage = ""
for packageIndex, package in enumerate(packages):
package.compiled = compilePackage(packageIndex, package)
self._console.outdent()
if not len(packages):
raise RuntimeError("No valid boot package generated.")
# - Put loader and packages together -------
loader_with_boot = self._job.get("packages/loader-with-boot", True)
# handle loader and boot package
if loader_with_boot:
bootCode = generateBootScript(globalCodes, script, packages[0].compiled)
packages[0].compiled = bootCode
else:
loaderCode = generateBootScript(globalCodes, script)
loadPackage = Package(0) # make a dummy Package for the loader
loadPackage.compiled = loaderCode
packages.insert(0, loadPackage)
# attach file names
for package, fileName in zip(packages, self.packagesFileNames(script.baseScriptPath, len(packages))):
package.file = fileName
# write packages
self.writePackages(packages, script)
# ---- 'source' version ------------------------------------------------
else:
sourceContent = generateBootScript(globalCodes, script, bootPackage="", compileType=compileType)
# Construct file name
resolvedFilePath = self._resolveFileName(filePath, variants, settings)
# Save result file
filetool.save(resolvedFilePath, sourceContent)
if compConf.get("paths/gzip"):
filetool.gzip(resolvedFilePath, sourceContent)
self._console.outdent()
self._console.debug("Done: %s" % self._computeContentSize(sourceContent))
self._console.outdent()
self._console.outdent()
return # runCompiled()
def runCompiled(self, script, treeCompiler, version="build"):
def getOutputFile(compileType):
filePath = compConf.get("paths/file")
if not filePath:
filePath = os.path.join(compileType, "script", script.namespace + ".js")
return filePath
def getFileUri(scriptUri):
appfile = os.path.basename(fileRelPath)
fileUri = os.path.join(scriptUri, appfile) # make complete with file name
fileUri = Path.posifyPath(fileUri)
return fileUri
##
# returns the Javascript code for the initial ("boot") script as a string,
# using the loader.tmpl template and filling its placeholders
def generateBootCode(parts, packages, boot, script, compConf, variants, settings, bootCode, globalCodes, version="source", decodeUrisFile=None, format=False):
##
# create a map with part names as key and array of package id's and
# return as string
def partsMap(script):
partData = {}
packages = script.packagesSortedSimple()
#print "packages: %r" % packages
for part in script.parts:
partData[part] = script.parts[part].packagesAsIndices(packages)
#print "part '%s': %r" % (part, script.parts[part].packages)
partData = json.dumpsCode(partData)
return partData
def fillTemplate(vals, template):
# Fill the code template with various vals
templ = MyTemplate(template)
result = templ.safe_substitute(vals)
return result
def packageUrisToJS1(packages, version, namespace=None):
# Translate URI data to JavaScript
allUris = []
for packageId, package in enumerate(packages):
packageUris = []
for fileId in package:
if version == "build":
# TODO: gosh, the next is an ugly hack!
#namespace = self._resourceHandler._genobj._namespaces[0] # all name spaces point to the same paths in the libinfo struct, so any of them will do
if not namespace:
namespace = script.namespace # all name spaces point to the same paths in the libinfo struct, so any of them will do
relpath = OsPath(fileId)
else:
namespace = self._classes[fileId]["namespace"]
relpath = OsPath(self._classes[fileId]["relpath"])
shortUri = Uri(relpath.toUri())
packageUris.append("%s:%s" % (namespace, shortUri.encodedValue()))
allUris.append(packageUris)
return allUris
##
# Translate URI data to JavaScript
# using Package objects
def packageUrisToJS(packages, version):
allUris = []
for packageId, package in enumerate(packages):
packageUris = []
if package.file: # build
namespace = "__out__"
fileId = package.file
relpath = OsPath(fileId)
shortUri = Uri(relpath.toUri())
packageUris.append("%s:%s" % (namespace, shortUri.encodedValue()))
else: # "source" :
for clazz in package.classes:
namespace = self._classes[clazz]["namespace"]
relpath = OsPath(self._classes[clazz]["relpath"])
shortUri = Uri(relpath.toUri())
packageUris.append("%s:%s" % (namespace, shortUri.encodedValue()))
allUris.append(packageUris)
return allUris
def loadTemplate(bootCode):
# try custom loader templates
loaderFile = compConf.get("paths/loader-template", None)
if not loaderFile:
# use default templates
if version=="build":
#loaderFile = os.path.join(filetool.root(), os.pardir, "data", "generator", "loader-build.tmpl.js")
# TODO: test-wise using generic template
loaderFile = os.path.join(filetool.root(), os.pardir, "data", "generator", "loader.tmpl.js")
else:
#loaderFile = os.path.join(filetool.root(), os.pardir, "data", "generator", "loader-source.tmpl.js")
loaderFile = os.path.join(filetool.root(), os.pardir, "data", "generator", "loader.tmpl.js")
template = filetool.read(loaderFile)
return template
# ---------------------------------------------------------------
if not parts:
return ""
result = ""
vals = {}
packages = script.packagesSortedSimple()
loader_with_boot = self._job.get("packages/loader-with-boot", True)
# stringify data in globalCodes
for entry in globalCodes:
globalCodes[entry] = json.dumpsCode(globalCodes[entry])
# undo damage done by simplejson to raw strings with escapes \\ -> \
globalCodes[entry] = globalCodes[entry].replace('\\\\\\', '\\').replace(r'\\', '\\') # " gets tripple escaped, therefore the first .replace()
vals.update(globalCodes)
if version=="build":
vals["Resources"] = json.dumpsCode({}) # TODO: undo Resources from globalCodes!!!
vals["Boot"] = '"%s"' % boot
if version == "build":
vals["BootPart"] = bootCode
else:
vals["BootPart"] = ""
# fake package data
for key, package in enumerate(packages):
vals["BootPart"] += "qx.$$packageData['%d']={};\n" % key
# Translate part information to JavaScript
vals["Parts"] = partsMap(script)
# Translate URI data to JavaScript
#vals["Uris"] = packageUrisToJS1(packages, version)
vals["Uris"] = packageUrisToJS(packages, version)
vals["Uris"] = json.dumpsCode(vals["Uris"])
# Add potential extra scripts
vals["UrisBefore"] = []
if self._job.get("add-script", False):
additional_scripts = self._job.get("add-script",[])
for additional_script in additional_scripts:
vals["UrisBefore"].append(additional_script["uri"])
vals["UrisBefore"] = json.dumpsCode(vals["UrisBefore"])
# Whether boot package is inline
if version == "source":
vals["BootIsInline"] = json.dumpsCode(False)
else:
vals["BootIsInline"] = json.dumpsCode(loader_with_boot)
# Closure package information
cParts = {}
if version == "build":
for part in script.parts:
if not loader_with_boot or part != "boot":
cParts[part] = True
vals["ClosureParts"] = json.dumpsCode(cParts)
# Package Hashes
vals["PackageHashes"] = {}
for key, package in enumerate(packages):
if package.hash:
vals["PackageHashes"][key] = package.hash
else:
vals["PackageHashes"][key] = "%d" % key # fake code package hashes in source ver.
vals["PackageHashes"] = json.dumpsCode(vals["PackageHashes"])
# Script hook for qx.$$loader.decodeUris() function
vals["DecodeUrisPlug"] = ""
if decodeUrisFile:
plugCode = filetool.read(self._config.absPath(decodeUrisFile)) # let it bomb if file can't be read
vals["DecodeUrisPlug"] = plugCode.strip()
# Enable "?nocache=...." for script loading?
vals["NoCacheParam"] = "true" if self._job.get("compile-options/uris/add-nocache-param", True) else "false"
# Locate and load loader basic script
template = loadTemplate(bootCode)
# Fill template gives result
result = fillTemplate(vals, template)
return result
##
# shallow layer above generateBootCode(), and its only client
def generateBootScript(globalCodes, script, bootPackage="", compileType="build"):
self._console.info("Generating boot script...")
if not self._job.get("packages/i18n-with-boot", True):
# remove I18N info from globalCodes, so they don't go into the loader
globalCodes["Translations"] = {}
globalCodes["Locales"] = {}
else:
if compileType == "build":
# also remove them here, as this info is now with the packages
globalCodes["Translations"] = {}
globalCodes["Locales"] = {}
plugCodeFile = compConf.get("code/decode-uris-plug", False)
if compileType == "build":
filepackages = [(x.file,) for x in packages]
bootContent = generateBootCode(parts, filepackages, boot, script, compConf, variants, settings, bootPackage, globalCodes, compileType, plugCodeFile, format)
else:
filepackages = [x.classes for x in packages]
bootContent = generateBootCode(parts, filepackages, boot, script, compConf, variants={}, settings={}, bootCode=None, globalCodes=globalCodes, version=compileType, decodeUrisFile=plugCodeFile, format=format)
return bootContent
def getPackageData(package):
data = {}
data["resources"] = package.data.resources
data["translations"] = package.data.translations
data["locales"] = package.data.locales
data = json.dumpsCode(data)
data += ';\n'
return data
def compilePackage(packageIndex, package):
self._console.info("Compiling package #%s:" % packageIndex, False)
self._console.indent()
# Compile file content
pkgCode = self._treeCompiler.compileClasses(package.classes, variants, optimize, format)
pkgData = getPackageData(package)
hash = sha.getHash(pkgData + pkgCode)[:12] # first 12 chars should be enough
isBootPackage = packageIndex == 0
if isBootPackage:
compiledContent = ("qx.$$packageData['%s']=" % hash) + pkgData + pkgCode
else:
compiledContent = u'''qx.$$packageData['%s']=%s\n''' % (hash, pkgData)
compiledContent += u'''qx.Part.$$notifyLoad("%s", function() {\n%s\n});''' % (hash, pkgCode)
#
package.hash = hash # to fill qx.$$loader.packageHashes in generateBootScript()
self._console.debug("Done: %s" % self._computeContentSize(compiledContent))
self._console.outdent()
return compiledContent
##
# 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)
# -- Main - runCompiled ------------------------------------------------
# Early return
compileType = self._job.get("compile/type", "")
if compileType not in ("build", "source"):
return
packages = script.packagesSortedSimple()
parts = script.parts
boot = script.boot
variants = script.variants
libraries = script.libraries
self._treeCompiler = treeCompiler
self._variants = variants
self._script = script
self._console.info("Generate %s version..." % compileType)
self._console.indent()
# - Evaluate job config ---------------------
# Compile config
compConf = self._job.get("compile-options")
compConf = ExtMap(compConf)
# Whether the code should be formatted
format = compConf.get("code/format", False)
script.scriptCompress = compConf.get("paths/gzip", False)
# Read in settings
settings = self.getSettings()
script.settings = settings
# Read libraries
libs = self._job.get("library", [])
# Get translation maps
locales = compConf.get("code/locales", [])
translationMaps = self.getTranslationMaps(packages, variants, locales)
# Read in base file name
fileRelPath = getOutputFile(compileType)
filePath = self._config.absPath(fileRelPath)
script.baseScriptPath = filePath
if compileType == "build":
# read in uri prefixes
scriptUri = compConf.get('uris/script', 'script')
scriptUri = Path.posifyPath(scriptUri)
fileUri = getFileUri(scriptUri)
# for resource list
resourceUri = compConf.get('uris/resource', 'resource')
resourceUri = Path.posifyPath(resourceUri)
else:
# source version needs place where the app HTML ("index.html") lives
self.approot = self._config.absPath(compConf.get("paths/app-root", ""))
resourceUri = None
scriptUri = None
# Get global script data (like qxlibraries, qxresources,...)
globalCodes = {}
globalCodes["Settings"] = settings
globalCodes["Variants"] = self.generateVariantsCode(variants)
globalCodes["Libinfo"] = self.generateLibInfoCode(libs, format, resourceUri, scriptUri)
# add synthetic output lib
if scriptUri: out_sourceUri= scriptUri
else:
out_sourceUri = self._computeResourceUri({'class': ".", 'path': os.path.dirname(script.baseScriptPath)}, OsPath(""), rType="class", appRoot=self.approot)
out_sourceUri = os.path.normpath(out_sourceUri.encodedValue())
globalCodes["Libinfo"]['__out__'] = { 'sourceUri': out_sourceUri }
globalCodes["Resources"] = self.generateResourceInfoCode(script, settings, libraries, format)
globalCodes["Translations"],\
globalCodes["Locales"] = mergeTranslationMaps(translationMaps)
# Potentally create dedicated I18N packages
i18n_as_parts = not self._job.get("packages/i18n-with-boot", True)
if i18n_as_parts:
script = self.generateI18NParts(script, globalCodes)
self.writePackages([p for p in script.packages if getattr(p, "__localeflag", False)], script)
if compileType == "build":
# - Specific job config ---------------------
# read in compiler options
optimize = compConf.get("code/optimize", [])
self._treeCompiler.setOptimize(optimize)
# - Generating packages ---------------------
self._console.info("Generating packages...")
self._console.indent()
bootPackage = ""
for packageIndex, package in enumerate(packages):
package.compiled = compilePackage(packageIndex, package)
self._console.outdent()
if not len(packages):
raise RuntimeError("No valid boot package generated.")
# - Put loader and packages together -------
loader_with_boot = self._job.get("packages/loader-with-boot", True)
# handle loader and boot package
if not loader_with_boot:
loadPackage = Package(0) # make a dummy Package for the loader
packages.insert(0, loadPackage)
# attach file names (do this before calling generateBootScript)
for package, fileName in zip(packages, self.packagesFileNames(script.baseScriptPath, len(packages))):
package.file = os.path.basename(fileName)
if self._job.get("compile-options/paths/scripts-add-hash", False):
package.file = self._fileNameWithHash(package.file, package.hash)
# generate and integrate boot code
if loader_with_boot:
# merge loader code with first package
bootCode = generateBootScript(globalCodes, script, packages[0].compiled)
packages[0].compiled = bootCode
else:
loaderCode = generateBootScript(globalCodes, script)
packages[0].compiled = loaderCode
# write packages
self.writePackages(packages, script)
# ---- 'source' version ------------------------------------------------
else:
sourceContent = generateBootScript(globalCodes, script, bootPackage="", compileType=compileType)
# Construct file name
resolvedFilePath = self._resolveFileName(filePath, variants, settings)
# Save result file
filetool.save(resolvedFilePath, sourceContent)
if compConf.get("paths/gzip"):
filetool.gzip(resolvedFilePath, sourceContent)
self._console.outdent()
self._console.debug("Done: %s" % self._computeContentSize(sourceContent))
self._console.outdent()
self._console.outdent()
return # runCompiled()
