rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
def copyJsFiles(destdir): | def CopyJsFiles(destdir): | def copyJsFiles(destdir): # copy js source file to script dir if not os.path.exists(destdir): os.makedirs(destdir) while True: file = (yield) if file == None: break clazz = "demobrowser.demo.%s.%s" % demoCategoryFromFile(file) shutil.copyfile('source/class/%s.js' % clazz.replace('.','/'), "%s/%s.src.js" % (destdir,cla... |
def createDemoData(destdir): | def CreateDemoData(destdir): | def createDemoData(destdir): dist = os.path.join(destdir, demoDataFn) res = [] ocategory = "" while True: (htmlFilePath, category, demo) = (yield) if htmlFilePath == None: break # init new category if category != ocategory: ocategory = category resCategory = {} res.append(resCategory) resCategory["classname"] = categ... |
dataCreator = createDemoData(dest) | dataCreator = CreateDemoData(dest) | def main(dest, scan): dist = os.path.join(dest, demoDataFn) # Init the various consumers that work on every demo dataCreator = createDemoData(dest) # generator for the demodata.js file dataCreator.send(None) # init it configCreator = createDemoJson() # generator for the config.demo.json file config... |
configCreator = createDemoJson() | configCreator = CreateDemoJson() | def main(dest, scan): dist = os.path.join(dest, demoDataFn) # Init the various consumers that work on every demo dataCreator = createDemoData(dest) # generator for the demodata.js file dataCreator.send(None) # init it configCreator = createDemoJson() # generator for the config.demo.json file config... |
jsFileCopier = copyJsFiles(dest) | jsFileCopier = CopyJsFiles(dest) | def main(dest, scan): dist = os.path.join(dest, demoDataFn) # Init the various consumers that work on every demo dataCreator = createDemoData(dest) # generator for the demodata.js file dataCreator.send(None) # init it configCreator = createDemoJson() # generator for the config.demo.json file config... |
open(file, 'w').write(json.dumps(data, sort_keys=True, indent=indent, separators=separators)) | filetool.save(file, json.dumps(data, sort_keys=True, indent=indent, separators=separators)) | def depsToJsonFile(classDepsIter, depsLogConf): data = {} for (packageId, classId, depId, loadOrRun) in classDepsIter: if classId not in data: data[classId] = {} data[classId]["load"] = [] data[classId]["run"] = [] |
open(file, 'w').write(json.dumps(data, sort_keys=True, indent=indent, separators=separators)) | filetool.save(file, json.dumps(data, sort_keys=True, indent=indent, separators=separators)) | def depsToProviderFormat(classDepsIter, depsLogConf): data = {} # Class deps for (packageId, classId, depId, loadOrRun) in classDepsIter: if classId not in data: data[classId] = {} data[classId]["load"] = [] data[classId]["run"] = [] |
open(file, 'w').write(json.dumps(output, sort_keys=True, indent=indent, separators=separators)) | filetool.save(file, json.dumps(output, sort_keys=True, indent=indent, separators=separators)) | def depsToFlareFile(classDepsIter, depsLogConf): data = {} for (packageId, classId, depId, loadOrRun) in classDepsIter: if classId not in data: data[classId] = {} data[classId]['name'] = classId data[classId]["size"] = 1000 data[classId]["imports"] = [] |
open(file, 'w').write(dot) | filetool.save(file, dot) | def writeDotFile(gr1, depsLogConf): file = depsLogConf.get('dot/file', "deps.dot") dot = gr1.write(fmt='dotwt') self._console.info("Writing dependency graph to file: %s" % file) open(file, 'w').write(dot) return |
if scanner.peek()[0].name == "ident": token = scanner.next() rexp += token.value | try: if scanner.peek()[0].name == "ident": token = scanner.next() rexp += token.value except StopIteration: pass | def parseRegexp(scanner): # leading '/' is already consumed rexp = "" token = scanner.next() while True: #print "(rexp)", token.value rexp += token.value # accumulate token strings if rexp.endswith("/"): # check for end of regexp # make sure "/" is not escaped, ie. preceded by an odd number of "\" if not Scanner... |
toks = scanner.peek(2) | try: toks = scanner.peek(2) except StopIteration: return True | def restLineIsEmpty(scanner): toks = scanner.peek(2) if (toks[0].name == 'nl' or (toks[0].name == 'white' and toks[1].name == 'nl')): return True else: return False |
if sendReport: if (self.sim): self.log("SIMULATION: Formatting log and sending report.\n") else: ignore = None if "ignoreLogEntries" in browser: ignore = browser["ignoreLogEntries"] else: if "ignoreLogEntries" in appConf: ignore = appConf["ignoreLogEntries"] if getReportFrom == 'testLog': self.formatLog(logFile, repo... | if not sendReport: return ignore = None if "ignoreLogEntries" in browser: ignore = browser["ignoreLogEntries"] else: if "ignoreLogEntries" in appConf: ignore = appConf["ignoreLogEntries"] if (self.sim): self.log("SIMULATION: Formatting log and sending report.\n") else: if getReportFrom == 'testLog': self.formatLog(lo... | def runTests(self, appConf): import time testStartDate = time.strftime(self.timeFormat) |
self.reportResults(appConf['appName'], testStartDate, logFile, ignore) | if (self.sim): self.log("SIMULATION: Sending results to report server.\n") else: self.reportResults(appConf['appName'], testStartDate, logFile, ignore) | def runTests(self, appConf): import time testStartDate = time.strftime(self.timeFormat) |
self._storePrivateFields() | def _privateOptimizeHelper(self, tree, id, variants): privateoptimizer.patch(tree, id) #self._storePrivateFields() #if the above line is left out permanently, other cache maintenance code can be removed (bug#4148) | |
depsLogConf = self._job.get("log/dependencies", False) if not depsLogConf: return packages = script.packagesSortedSimple() parts = script.parts variants = script.variants depsLogConf = ExtMap(depsLogConf) | def runLogDependencies(self, script): | |
def depsToConsole1(classDepsIter): | def depsToConsole(classDepsIter, type): | def depsToConsole1(classDepsIter): oPackageId = '' self._console.indent() self._console.indent() depsMap = collectDispersedDependencies(classDepsIter) |
self._console.info("Used by: %s (load)" % depId) | self._console.info("%s: %s (load)" % (relstring, depId)) | def depsToConsole1(classDepsIter): oPackageId = '' self._console.indent() self._console.indent() depsMap = collectDispersedDependencies(classDepsIter) |
self._console.info("Used by: %s (run)" % depId) | self._console.info("%s: %s (run)" % (relstring, depId)) | def depsToConsole1(classDepsIter): oPackageId = '' self._console.indent() self._console.indent() depsMap = collectDispersedDependencies(classDepsIter) |
self._console.outdent() self._console.outdent() return def depsToConsole(classDepsIter): oPackageId = oClassId = oLoadOrRun = '' self._console.indent() self._console.indent() for (packageId, classId, depId, loadOrRun) in classDepsIter: if packageId != oPackageId: oPackageId = packageId self._console.outdent() self._... | def depsToConsole1(classDepsIter): oPackageId = '' self._console.indent() self._console.indent() depsMap = collectDispersedDependencies(classDepsIter) | |
def usedByDeps(depsLogConf): | def logDeps(depsLogConf, type): | def usedByDeps(depsLogConf): |
classDepsIter = lookupUsedByDeps(packages) | if type == "using": classDepsIter = lookupUsingDeps(packages) else: classDepsIter = lookupUsedByDeps(packages) | def usedByDeps(depsLogConf): |
depsToConsole1(classDepsIter) return for packageId, package in enumerate(packages): self._console.info("Package %s" % packageId) self._console.indent() for part in parts.values(): if package in part.packages: self._console.info("Part %s" % part.name) for classId in sorted(package.classes): self._console.info("Class: ... | depsToConsole(classDepsIter, type) | def usedByDeps(depsLogConf): |
depsLogConf = self._job.get("log/dependencies", False) if not depsLogConf: return packages = script.packagesSortedSimple() parts = script.parts variants = script.variants depsLogConf = ExtMap(depsLogConf) | def usingDeps(depsLogConf): | |
if type == "used-by": usedByDeps(depsLogConf) elif type == "using": usingDeps(depsLogConf) | if type in ("used-by", "using"): logDeps(depsLogConf, type) | def usingDeps(depsLogConf): |
self._console.error('Dependency log type "%s" not in ["using", "used-by"]; skipping...' % mode) | self._console.error('Dependency log type "%s" not in ["using", "used-by"]; skipping...' % type) | def usingDeps(depsLogConf): |
if x in y.packageDeps: | if x in y.packageDeps and y not in x.packageDeps: | def cmpFunc (x, y): if x.part_count != y.part_count: return cmp(x.part_count, y.part_count) else: if x in y.packageDeps: # y needs x, so x is "larger" (must be earlier) return 1 elif y in x.packageDeps: # other way round return -1 else: return 0 |
elif y in x.packageDeps: | elif y in x.packageDeps and x not in y.packageDeps: | def cmpFunc (x, y): if x.part_count != y.part_count: return cmp(x.part_count, y.part_count) else: if x in y.packageDeps: # y needs x, so x is "larger" (must be earlier) return 1 elif y in x.packageDeps: # other way round return -1 else: return 0 |
def buildAllDemos(self, demoVersion="build", demoBrowser=False): | def buildAllDemos(self, demoVersion="build", demoBrowser=None): | def buildAllDemos(self, demoVersion="build", demoBrowser=False): demoData = [] for libraryName in self.libraries: library = self.libraries[libraryName] libraryData = { "classname": libraryName, "tests": [] } validDemo = False for versionName in library.versions: version = library.versions[versionName] if not version.... |
status = version.buildDemo(variant, demoVersion) | status = {"buildError" : False} | def buildAllDemos(self, demoVersion="build", demoBrowser=False): demoData = [] for libraryName in self.libraries: library = self.libraries[libraryName] libraryData = { "classname": libraryName, "tests": [] } validDemo = False for versionName in library.versions: version = library.versions[versionName] if not version.... |
htmlfile = self.copyHtmlFile(libraryName, versionName, variant, demoVersion) | htmlfile = self.copyHtmlFile(libraryName, versionName, variant, demoVersion, demoBrowser) | def buildAllDemos(self, demoVersion="build", demoBrowser=False): demoData = [] for libraryName in self.libraries: library = self.libraries[libraryName] libraryData = { "classname": libraryName, "tests": [] } validDemo = False for versionName in library.versions: version = library.versions[versionName] if not version.... |
dbScriptDir = os.path.join(self.dir, "demobrowser", demoVersion, "script") | dbScriptDir = os.path.join(demoBrowser, demoVersion, "script") | def buildAllDemos(self, demoVersion="build", demoBrowser=False): demoData = [] for libraryName in self.libraries: library = self.libraries[libraryName] libraryData = { "classname": libraryName, "tests": [] } validDemo = False for versionName in library.versions: version = library.versions[versionName] if not version.... |
def copyHtmlFile(self, libraryName, versionName, variantName, demoVersion="build", demobrowserDir=None): if not demobrowserDir: demobrowserDir = os.path.join(self.dir, "demobrowser") console.info("Copying HTML file to demobrowser directory %s" %demobrowserDir) sourceFilePath = os.path.join(demobrowserDir,"source", "dem... | def copyHtmlFile(self, libraryName, versionName, variantName, demoVersion, demoBrowser): dbManifest = getDataFromJsonFile(os.path.join(demoBrowser, "Manifest.json")) dbResourcePath = dbManifest["provides"]["resource"] dbNamespace = dbManifest["provides"]["namespace"] sourceFilePath = os.path.join(demoBrowser, dbResou... | def copyHtmlFile(self, libraryName, versionName, variantName, demoVersion="build", demobrowserDir=None): if not demobrowserDir: demobrowserDir = os.path.join(self.dir, "demobrowser") console.info("Copying HTML file to demobrowser directory %s" %demobrowserDir) sourceFilePath = os.path.join(demobrowserDir,"source", "dem... |
targetDir = os.path.join(demobrowserDir, demoVersion, "demo", libraryName) | targetDir = os.path.join(demoBrowser, demoVersion, "demo", libraryName) | def copyHtmlFile(self, libraryName, versionName, variantName, demoVersion="build", demobrowserDir=None): if not demobrowserDir: demobrowserDir = os.path.join(self.dir, "demobrowser") console.info("Copying HTML file to demobrowser directory %s" %demobrowserDir) sourceFilePath = os.path.join(demobrowserDir,"source", "dem... |
demoUrl = "../../../../%s/%s/demo/%s/%s/" %(libraryName,versionName,variantName,demoVersion) | demoUrl = "../../../../../%s/%s/demo/%s/%s/" %(libraryName,versionName,variantName,demoVersion) | def copyHtmlFile(self, libraryName, versionName, variantName, demoVersion="build", demobrowserDir=None): if not demobrowserDir: demobrowserDir = os.path.join(self.dir, "demobrowser") console.info("Copying HTML file to demobrowser directory %s" %demobrowserDir) sourceFilePath = os.path.join(demobrowserDir,"source", "dem... |
try: manifestFile = open(manifestPath) except: raise RuntimeError, "Manifest file %s not found" %manifestPath manifest = json.load(manifestFile) return manifest | return getDataFromJsonFile(manifestPath) | def getManifest(self): try: return self.manifest except AttributeError: pass manifestPath = os.path.join(self.path, "Manifest.json") try: manifestFile = open(manifestPath) except: raise RuntimeError, "Manifest file %s not found" %manifestPath manifest = json.load(manifestFile) return manifest |
try: manifestFile = open(manifestPath) except: raise RuntimeError, "Manifest file %s not found" %manifestPath manifest = json.load(manifestFile) return manifest | return getDataFromJsonFile(manifestPath) | def getDemoManifest(self, demoVariant = "default"): manifestPath = os.path.join(self.path, "demo", demoVariant, "Manifest.json") try: manifestFile = open(manifestPath) except: raise RuntimeError, "Manifest file %s not found" %manifestPath manifest = json.load(manifestFile) return manifest |
def main(args): repository = Repository(args[0]) if args[1][:6] == "demos-": repository.buildAllDemos(args[1][6:], True) | def getDataFromJsonFile(path): try: jsonFile = codecs.open(path, "r", "UTF-8") except: raise RuntimeError, "File %s not found" %jsonFile try: return json.load(jsonFile) except Exception, e: raise RuntimeError, "Couldn't parse JSON from file %s" %jsonFile def getComputedConf(): parser = optparse.OptionParser() parse... | def main(args): repository = Repository(args[0]) if args[1][:6] == "demos-": repository.buildAllDemos(args[1][6:], True) |
parser = optparse.OptionParser() (options, args) = parser.parse_args() main(args) | main() | def main(args): repository = Repository(args[0]) if args[1][:6] == "demos-": repository.buildAllDemos(args[1][6:], True) |
self._console.warn("%s: | if fileId in ("qx.Theme", "qx.Interface", "qx.Mixin"): pass else: self._console.warn("%s: | def buildShallowDeps(): # Notes: # load time = before class = require # runtime = after class = use |
cmd = montage_cmd % (orientation, " ".join(clips), combined) | temp = tempfile.TemporaryFile(mode='r+t') temp.write("\n".join(clips)) temp.seek(0) cmd = montage_cmd % (orientation, "@" + os.path.normpath(temp.name), combined) | def combine(self, combined, files, horizontal): self._console.indent() montage_cmd = "montage -geometry +0+0 -gravity NorthWest -tile %s -background None %s %s" if horizontal: orientation = "x1" else: orientation = "1x" |
temp = tempfile.TemporaryFile(mode='r+t') | temp = tempfile.NamedTemporaryFile(mode='r+t') | def combine(self, combined, files, horizontal): self._console.indent() montage_cmd = "montage -geometry +0+0 -gravity NorthWest -tile %s -background None %s %s" if horizontal: orientation = "x1" else: orientation = "1x" |
def addResourceToPackage(script, classToResourceMap, assetId, resvalue): | def addResourceToPackages(script, classToResourceMap, assetId, resval): def assetRexMatchItem(assetRex, item): if isinstance(item, types.StringTypes): return assetRex.match(item) else: for embId in item.embeds: if assetRex.match(embId): return True return False if isinstance(resval, NameSpace): resvalue = resval... | def addResourceToPackage(script, classToResourceMap, assetId, resvalue): classesUsing = set(()) for clazz, assetSet in classToResourceMap.items(): for assetRex in assetSet: if assetRex.match(assetId): classesUsing.add(clazz) break for package in script.packages: if classesUsing.intersection(set(package.classes)): packa... |
if assetRex.match(assetId): | if assetRexMatchItem(assetRex, checkval): | def addResourceToPackage(script, classToResourceMap, assetId, resvalue): classesUsing = set(()) for clazz, assetSet in classToResourceMap.items(): for assetRex in assetSet: if assetRex.match(assetId): classesUsing.add(clazz) break for package in script.packages: if classesUsing.intersection(set(package.classes)): packa... |
def serialize(filteredResources, resdata): | def serialize(filteredResources, combinedImages, resdata): | def serialize(filteredResources, resdata): for resId, resval in filteredResources.items(): # build up resdata if isinstance(resval, ImgInfoFmt): resvalue = resval.flatten() else: # handle other resources resvalue = resval resdata[resId] = resvalue addResourceToPackage(script, classToResourceMap, resId, resvalue) # re... |
addResourceToPackage(script, classToResourceMap, resId, resvalue) | addResourceToPackages(script, classToResourceMap, resId, resvalue) for combId, combImg in combinedImages.items(): if combImg.used == True: addResourceToPackages(script, classToResourceMap, combId, combImg) | def serialize(filteredResources, resdata): for resId, resval in filteredResources.items(): # build up resdata if isinstance(resval, ImgInfoFmt): resvalue = resval.flatten() else: # handle other resources resvalue = resval resdata[resId] = resvalue addResourceToPackage(script, classToResourceMap, resId, resvalue) # re... |
for embId in combImg.embeds: if embId in filteredResources.keys(): lib = filteredResources[embId].lib filteredResources[embId] = combImg.embeds[embId] filteredResources[embId].lib = lib if combId not in filteredResources.keys(): filteredResources[combId] = combImg.info | filteredResourceIds = filteredResources.keys() for embId in requiredEmbeds(combImg, filteredResourceIds): lib = filteredResources[embId].lib filteredResources[embId] = combImg.embeds[embId] filteredResources[embId].lib = lib if combId not in filteredResourceIds: filteredResources[combId] = combImg.info combImg.... | def addCombinedImage(combinedResource, combinedId, combinedObj): '''this does basically what processCombinedImg does, but with no side effects''' # Read the .meta file # it doesn't seem worth to apply caching here meta_fname = os.path.splitext(combinedResource)[0]+'.meta' meta_content = filetool.read(meta_fname) imgD... |
resdata = serialize(filteredResources, resdata) | resdata = serialize(filteredResources, combinedImages, resdata) | def addCombinedImage(combinedResource, combinedId, combinedObj): '''this does basically what processCombinedImg does, but with no side effects''' # Read the .meta file # it doesn't seem worth to apply caching here meta_fname = os.path.splitext(combinedResource)[0]+'.meta' meta_content = filetool.read(meta_fname) imgD... |
try: url,text=t[0].split("|") except ValueError: | i = t[0].find("|") if i>-1: url = t[0][:i] text= t[0][i+1:] else: url = t[0] text= "" text = text.strip() if url.startswith("http://"): return '`%s <%s>`_' % (text,url) elif url.find(ns12)>-1: url = internalLink(url) else: | def convertToRst_A(s,l,t): try: url,text=t[0].split("|") except ValueError: #raise ParseFatalException(s,l,"invalid URL link reference: " + t[0]) print >> sys.stderr, ("invalid URL link reference: " + t[0]) return '<%s>' %t[0] return '`%s <%s>`_' % (text,url) |
print >> sys.stderr, ("invalid URL link reference: " + t[0]) return '<%s>' %t[0] return '`%s <%s>`_' % (text,url) | pass if text: return ':doc:`%s <%s>`' % (text,url) else: return ':doc:`%s`' % url def convertToRst_I(s,l,t): import random i = t[0].find("|") if i>-1: url = t[0][:i] text= t[0][i+1:] else: url = t[0] text= "" text = text.strip() if url.startswith("http://"): pass elif url.find(ns12)>-1: url = internalLink(url) url ... | def convertToRst_A(s,l,t): try: url,text=t[0].split("|") except ValueError: #raise ParseFatalException(s,l,"invalid URL link reference: " + t[0]) print >> sys.stderr, ("invalid URL link reference: " + t[0]) return '<%s>' %t[0] return '`%s <%s>`_' % (text,url) |
boldItalic = QuotedString("***").setParseAction(convertToRst("**","**")) | def convertToRst_A(s,l,t): try: url,text=t[0].split("|") except ValueError: #raise ParseFatalException(s,l,"invalid URL link reference: " + t[0]) print >> sys.stderr, ("invalid URL link reference: " + t[0]) return '<%s>' %t[0] return '`%s <%s>`_' % (text,url) | |
wikiMarkup = urlRef | italicized1 | italicized2 | h2 = QuotedString("======").setParseAction(convertHeading(linechars["h2"])) h3 = QuotedString("=====").setParseAction(convertHeading(linechars["h3"])) h4 = QuotedString("====").setParseAction(convertHeading(linechars["h4"])) h5 = QuotedString("===").setParseAction(convertHeading(linechar... | def convertToRst_A(s,l,t): try: url,text=t[0].split("|") except ValueError: #raise ParseFatalException(s,l,"invalid URL link reference: " + t[0]) print >> sys.stderr, ("invalid URL link reference: " + t[0]) return '<%s>' %t[0] return '`%s <%s>`_' % (text,url) |
wikiInput = codecs.open(path, "r", "utf-8").read() | wikiInput = codecs.open(path, "rU", "utf-8").read() | def transform(path): wikiInput = codecs.open(path, "r", "utf-8").read() rstString = wikiMarkup.transformString(wikiInput) if len(rstString)>0: codecs.open(txtEnd.sub(".rst", path), "w", "utf-8").write(rstString) |
assert(os.isdir(path)) | assert(os.path.isdir(path)) | def main(path): assert(os.isdir(path)) for root,dirs,files in os.walk(path): for file in (f for f in files if f.endswith(".txt")): transform(os.path.join(root,file)) |
wikiInput = codecs.open(sys.argv[1],"r", "utf-8").read() | wikiInput = codecs.open(sys.argv[1], "rU", "utf-8").read() | def main(path): assert(os.isdir(path)) for root,dirs,files in os.walk(path): for file in (f for f in files if f.endswith(".txt")): transform(os.path.join(root,file)) |
print wikiMarkup.transformString(wikiInput) | res = wikiMarkup.transformString(wikiInput) res = rmEmptyLines(res) print res | def main(path): assert(os.isdir(path)) for root,dirs,files in os.walk(path): for file in (f for f in files if f.endswith(".txt")): transform(os.path.join(root,file)) |
ldeps = self.getMethodDeps(depsItem, variants) | ldeps = self.getForeignDeps(depsItem, variants) | def _analyzeClassDepsNode(self, node, loadtime, runtime, inFunction, variants): |
def getMethodDeps(self, depsItem, variants): | def getForeignDeps(self, depsItem, variants): | def getLeadingId(idStr): leadingId = idStr dotIdx = idStr.find('.') if dotIdx > -1: leadingId = idStr[:dotIdx] return leadingId |
def getMethodDepsR(dependencyItem, variants, totalDeps): | def getForeignDepsR(dependencyItem, variants, totalDeps): | def getMethodDepsR(dependencyItem, variants, totalDeps): # We don't add the in-param to the global result classId = dependencyItem.name methodId= dependencyItem.attribute |
downstreamDeps = getMethodDepsR(depsItem, variants, totalDeps.union(localDeps)) | downstreamDeps = getForeignDepsR(depsItem, variants, totalDeps.union(localDeps)) | def getMethodDepsR(dependencyItem, variants, totalDeps): # We don't add the in-param to the global result classId = dependencyItem.name methodId= dependencyItem.attribute |
deps = getMethodDepsR(depsItem, variants, checkset) | deps = getForeignDepsR(depsItem, variants, checkset) | def getMethodDepsR(dependencyItem, variants, totalDeps): # We don't add the in-param to the global result classId = dependencyItem.name methodId= dependencyItem.attribute |
def getMethodDeps1(self, depsItem, variants): def getMethodDepsR(depsItem, variants, totalDeps): | def getForeignDeps1(self, depsItem, variants): def getForeignDepsR(depsItem, variants, totalDeps): | def getMethodDeps1(self, depsItem, variants): def getMethodDepsR(depsItem, variants, totalDeps): for depsItem in deps_rt: dclassid = depsItem.name dclassobj= self._classesObj[dclassid] ddeps = dclassobj.dependencies() methoddeps = lookup_methoddeps(depsItem.attribute, ddeps) for deps in methoddeps: downstream = getMet... |
downstream = getMethodDepsR(deps, variants) | downstream = getForeignDepsR(deps, variants) | def getMethodDepsR(depsItem, variants, totalDeps): for depsItem in deps_rt: dclassid = depsItem.name dclassobj= self._classesObj[dclassid] ddeps = dclassobj.dependencies() methoddeps = lookup_methoddeps(depsItem.attribute, ddeps) for deps in methoddeps: downstream = getMethodDepsR(deps, variants) mydeps.update(downstr... |
javaClassPath = "-cp " configClassPath = self._job.get("simulate/java-classpath", False) if configClassPath: javaClassPath += configClassPath qxSeleniumPath = self._job.get("simulate/qxselenium-path", False) javaClassPath += classPathSeparator + qxSeleniumPath rhinoClass = self._job.get("simulate/rhino-class", False) | javaClassPath += classPathSeparator.join(configClassPath) rhinoClass = self._job.get("simulate/rhino-class", "org.mozilla.javascript.tools.shell.Main") | def runSimulation(self): self._console.info("Running Simulation...") classPathSeparator = ":" if util.getPlatformInfo()[0] == "Windows": classPathSeparator = ";" javaClassPath = "-cp " configClassPath = self._job.get("simulate/java-classpath", False) if configClassPath: javaClassPath += configClassPath qxSeleniumPat... |
cmd = "java %s %s %s" %(javaClassPath, rhinoClass, runnerScript) self._console.debug("Selenium start command: " + cmd) | cmd = "%s %s %s %s" %(javaBin, javaClassPath, rhinoClass, runnerScript) self._console.info("Selenium start command: " + cmd) | def runSimulation(self): self._console.info("Running Simulation...") classPathSeparator = ":" if util.getPlatformInfo()[0] == "Windows": classPathSeparator = ";" javaClassPath = "-cp " configClassPath = self._job.get("simulate/java-classpath", False) if configClassPath: javaClassPath += configClassPath qxSeleniumPat... |
demoData = [] | repositoryData = [] | def buildAllDemos(self, demoVersion="build", demoBrowser=None, copyDemos=False): if demoBrowser: demoBrowser = os.path.abspath(demoBrowser) console.info("Generating demos for all known libraries") demoData = [] console.indent() for libraryName in self.libraries: library = self.libraries[libraryName] libraryData = { "c... |
status = version.buildDemo(variant, demoVersion) | def buildAllDemos(self, demoVersion="build", demoBrowser=None, copyDemos=False): if demoBrowser: demoBrowser = os.path.abspath(demoBrowser) console.info("Generating demos for all known libraries") demoData = [] console.indent() for libraryName in self.libraries: library = self.libraries[libraryName] libraryData = { "c... | |
status = {"buildError" : None} | def buildAllDemos(self, demoVersion="build", demoBrowser=None, copyDemos=False): if demoBrowser: demoBrowser = os.path.abspath(demoBrowser) console.info("Generating demos for all known libraries") demoData = [] console.indent() for libraryName in self.libraries: library = self.libraries[libraryName] libraryData = { "c... | |
versionData["tests"].append(self.getDemoData(libraryName, versionName, variant)) | demoData = self.getDemoData(libraryName, versionName, variant) demoData["manifest"] = version.getDemoManifest(variant) versionData["tests"].append(demoData) | def buildAllDemos(self, demoVersion="build", demoBrowser=None, copyDemos=False): if demoBrowser: demoBrowser = os.path.abspath(demoBrowser) console.info("Generating demos for all known libraries") demoData = [] console.indent() for libraryName in self.libraries: library = self.libraries[libraryName] libraryData = { "c... |
demoData.append(libraryData) | repositoryData.append(libraryData) | def buildAllDemos(self, demoVersion="build", demoBrowser=None, copyDemos=False): if demoBrowser: demoBrowser = os.path.abspath(demoBrowser) console.info("Generating demos for all known libraries") demoData = [] console.indent() for libraryName in self.libraries: library = self.libraries[libraryName] libraryData = { "c... |
jsonData = demjson.encode(demoData, strict=False, compactly=False) | jsonData = demjson.encode(repositoryData, strict=False, compactly=False) | def buildAllDemos(self, demoVersion="build", demoBrowser=None, copyDemos=False): if demoBrowser: demoBrowser = os.path.abspath(demoBrowser) console.info("Generating demos for all known libraries") demoData = [] console.indent() for libraryName in self.libraries: library = self.libraries[libraryName] libraryData = { "c... |
self._console.info("Sorting %s classes..." % len(result)) | self._console.info("Sorting %s classes " % len(result), False) | def processExplicitCludes(result): # Explicit include/exclude if len(includeNoDeps) > 0 or len(excludeNoDeps) > 0: self._console.info("Processing explicitely configured includes/excludes...") for entry in includeNoDeps: if not entry in result: result.append(entry) |
deps, _ = self.getCombinedDeps(classId, variants, buildType) | deps, cached = self.getCombinedDeps(classId, variants, buildType) if self._console.getLevel() is "info": self._console.dot("%s" % "." if cached else "*") | def sortClassesRecurser(classId, available, variants, result, path): if classId in result: return |
loader_with_boot = self._job.get("packages/loader-with-boot", True) | def getPackageData(package): data = {} data["resources"] = package.resources data = json.dumpsCode(data) data += ';\n' return data | |
isBootPackage = packageIndex == 0 and loader_with_boot | isBootPackage = packageIndex == 0 | def getPackageData(package): data = {} data["resources"] = package.resources data = json.dumpsCode(data) data += ';\n' return data |
return opening + t[0] + closing | return opening + wikiMarkup.transformString(t[0]) + closing | def conversionParseAction(s,l,t): return opening + t[0] + closing |
printDocError(classNode, "Missing target for see.") | printDocError(package, "Missing target for see.") | def createPackageDoc(text, packageName, docTree = None): if not docTree: docTree = tree.Node("doctree") package = getPackageNode(docTree, packageName) commentAttributes = comment.parseText(text) # Read all description, param and return attributes for attrib in commentAttributes: # Add description if attrib["category"... |
globalCodes = self.writeI18NFiles(globalCodes, script) | def packagesOfFiles(fileUri, packages): 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.... | |
def writeI18NFiles(self, globalCodes, script): | def writeI18NPackages(self, script): | def writePackage(self, content, filePath, script): if script.scriptCompress: filetool.gzip(filePath, content) else: filetool.save(filePath, content) |
return globalCodes | return | def writeI18NFiles(self, globalCodes, script): |
if variant == "class": | if variant in ("class", "bootstrap"): | def handleClassDefinition(docTree, item, variant): params = item.getChild("params") className = params.children[0].get("value") if len(params.children) > 1: classMap = params.children[1] else: classMap = {} commentAttributes = comment.parseNode(item) classNode = getClassNode(docTree, className, commentAttributes) if... |
lintCommand = os.path.join(qxPath, 'tool', 'bin', "ecmalint.py") lintsettings = ExtMap(self._job.get('lint-check')) allowedGlobals = lintsettings.get('allowed-globals', []) | lintCommand = os.path.join(qxPath, 'tool', 'bin', "ecmalint.py") lintJob = self._job allowedGlobals = lintJob.get('lint-check/allowed-globals', []) includePatt = lintJob.get('include', []) excludePatt = lintJob.get('exclude', []) | def runLint(self, classes): if not self._job.get('lint-check', False): return |
numClasses = len(classes) for pos, classId in enumerate(classes): | classesToCheck = getFilteredClassList(classes, includePatt, excludePatt) for pos, classId in enumerate(classesToCheck): | def runLint(self, classes): if not self._job.get('lint-check', False): return |
meta = self.getMeta() | meta = self.getHints() | def analyzeClassTree(variantSet): |
def getMeta(self, metatype=""): | def getHints(self, metatype=""): | def getMeta(self, metatype=""): |
for optional in self.getMeta(classId)["optionalDeps"]: | for optional in self.getHints(classId)["optionalDeps"]: | def getOptionals(self, includeWithDeps): result = [] |
self._console.error("Could not extract translation from %s!" % fileId) self._console.error("%s" % detail) sys.exit(1) | raise RuntimeError("Could not extract translation from %s!\n%s" % (fileId, detail)) | def getTranslation(self, fileId, variants): fileEntry = self._classes[fileId] filePath = fileEntry["path"] |
if method == "trn" or method == "trc": no=2 else: no=1 | if method == "trn" or method == "trc": minArgc=2 else: minArgc=1 | def _addTranslationBlock(self, method, data, node, var): entry = { "method" : method, "line" : node.get("line"), "column" : node.get("column") } |
elif len(strings) < no: raise NameError("Unsupported param of type %s at line %s" % (child.type, child.get("line"))) if len(strings) == no: | elif len(strings) < minArgc: self._console.warn("Unknown expression as argument to translation method at line %s" % (child.get("line"),)) if len(strings) == minArgc: | def _addTranslationBlock(self, method, data, node, var): entry = { "method" : method, "line" : node.get("line"), "column" : node.get("column") } |
if len(strings) != no: raise NameError("Invalid number of parameters %s at line %s" % (len(strings), node.get("line"))) if method == "trc": entry["hint"] = strings[0] entry["id"] = strings[1] else: entry["id"] = strings[0] if method == "trn": entry["plural"] = strings[1] data.append(entry) | lenStrings = len(strings) if lenStrings > 0: if method == "trc": entry["hint"] = strings[0] if lenStrings > 1 and strings[1]: entry["id"] = strings[1] else: if strings[0]: entry["id"] = strings[0] if method == "trn" and lenStrings > 1: entry["plural"] = strings[1] if "id" in entry: data.append(entry) return | def _addTranslationBlock(self, method, data, node, var): entry = { "method" : method, "line" : node.get("line"), "column" : node.get("column") } |
raise NameError("Unsupported param of type at line %s" % node.get("line")) | self._console.warn("Unknown expression as argument to translation method at line %s" % (node.get("line"),)) | def _concatOperation(self, node): result = "" |
def lookupDeps(packages, depstype="using"): | def lookupUsingDeps(packages, ): def hasVisibleDeps(classId): load_names = [x.name for x in classDeps["load"]] run_names = [x.name for x in classDeps["run"]] return set(load_names).union(run_names).difference(ignored_names) | def runLogDependencies(self, script): |
if depstype == "using": yield (packageId, classId, dep.name, 'load') else: yield (packageId, dep.name, classId, 'load') | yield (packageId, classId, dep.name, 'load') | def lookupDeps(packages, depstype="using"): |
if depstype == "using": yield (packageId, classId, dep.name, 'run') else: yield (packageId, dep.name, classId, 'run') load_names = [x.name for x in classDeps["load"]] run_names = [x.name for x in classDeps["run"]] if not set(load_names).union(run_names).difference(ignored_names): if depstype == "using": yield (packag... | yield (packageId, classId, dep.name, 'run') if not hasVisibleDeps(classId): yield (packageId, classId, None, 'load') yield (packageId, classId, None, 'run') return def lookupUsedByDeps(packages, ): depsMap = {} for packageId, package in enumerate(packages): for classId in sorted(package.classes): if classId ... | def lookupDeps(packages, depstype="using"): |
classDepsIter = lookupDeps(packages, depstype="using") | classDepsIter = lookupUsingDeps(packages,) | def logDeps(depsLogConf, type): |
classDepsIter = lookupDeps(packages, depstype="used-by") | classDepsIter = lookupUsedByDeps(packages,) | def logDeps(depsLogConf, type): |
self.scopes = None | def __init__(self, id, path, library, context, container): #__slots__ = ('id', 'path', 'size', 'encoding', 'library', 'context', 'source', 'scopes', 'translations') global console, cache, DefaultIgnoredNamesDynamic super(Class, self).__init__(path) self.id = id # qooxdoo name of class, classId self.libr... | |
self.cacheId = "class-%s" % self.path | def __init__(self, id, path, library, context, container): #__slots__ = ('id', 'path', 'size', 'encoding', 'library', 'context', 'source', 'scopes', 'translations') global console, cache, DefaultIgnoredNamesDynamic super(Class, self).__init__(path) self.id = id # qooxdoo name of class, classId self.libr... | |
def _getClassCache(self): cache = self.context["cache"] classInfo, modTime = cache.read(self.cacheId, self.path) if classInfo: return classInfo, modTime else: return {}, None def _writeClassCache(self, data): cache = self.context["cache"] cache.write(self.cacheId, data) | def _getClassCache(self): cache = self.context["cache"] classInfo, modTime = cache.read(self.cacheId, self.path) if classInfo: return classInfo, modTime else: return {}, None | |
def _getSourceTree(self, cacheId, tradeSpaceForSpeed): | def _getSourceTree(self, cacheId): tradeSpaceForSpeed = False | def _getSourceTree(self, cacheId, tradeSpaceForSpeed): |
tree.cacheId = cacheId | def _getSourceTree(self, cacheId, tradeSpaceForSpeed): |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.