#!/usr/bin/env python # CSS Test Suite Build Script # Copyright 2011 Hewlett-Packard Development Company, L.P. # Initial code by fantasai, joint copyright 2010 W3C and Microsoft # Licensed under BSD 3-Clause: import sys import os import json import optparse import shutil from collections import defaultdict from apiclient import apiclient from w3ctestlib import Sources, Utils, Suite, Indexer from mercurial import ui class Builder(object): def __init__(self, ui, outputPath, backupPath, ignorePaths, onlyCache): self.reset(onlyCache) self.ui = ui self.skipDirs = ('support') self.rawDirs = {'other-formats': 'other'} self.sourceTree = Sources.SourceTree() self.sourceCache = Sources.SourceCache(self.sourceTree) self.cacheDir = 'tools/cache' self.outputPath = outputPath.rstrip('/') if (outputPath) else 'dist' self.backupPath = backupPath.rstrip('/') if (backupPath) else None self.ignorePaths = [path.rstrip('/') for path in ignorePaths] if (ignorePaths) else [] self.workPath = 'build-temp' self.ignorePaths += (self.outputPath, self.backupPath, self.workPath) def reset(self, onlyCache): self.useCacheOnly = onlyCache self.shepherd = apiclient.apiclient.APIClient('https://api.csswg.org/shepherd/', version = 'vnd.csswg.shepherd.v1') if (not onlyCache) else None self.cacheData = False self.testSuiteData = {} self.specificationData = {} self.flagData = {} self.specNames = {} self.specAnchors = {} self.buildSuiteNames = [] self.buildSpecNames = {} self.testSuites = {} def _loadShepherdData(self, apiName, description, **kwargs): self.ui.status("Loading ", description, " information\n") cacheFile = os.path.join(self.cacheDir, apiName + '.json') if (not self.useCacheOnly or (not os.path.exists(cacheFile))): result = self.shepherd.get(apiName, **kwargs) if (result and (200 == result.status)): data = {} for name in result.data: # trim leading _ data[name[1:]] = result.data[name] with open(cacheFile, 'w') as file: json.dump(data, file) return data self.ui.status("Shepherd API call failed, result: ", result.status if result else 'None', "\n") if (os.path.exists(cacheFile)): self.ui.status("Loading cached data.\n") try: with open(cacheFile, 'r') as file: return json.load(file) except: pass return None def _addAnchors(self, anchors, specName): for anchor in anchors: self.specAnchors[specName].add(anchor['uri'].lower()) if ('children' in anchor): self._addAnchors(anchor['children'], specName) def _normalizeScheme(self, url): if (url and url.startswith('http:')): return 'https:' + url[5:] return url def getSpecName(self, url): if (not self.specNames): for specName in self.specificationData: specData = self.specificationData[specName] officialURL = self._normalizeScheme(specData.get('base_uri')) if (officialURL): if (officialURL.endswith('/')): officialURL = officialURL[:-1] self.specNames[officialURL.lower()] = specName draftURL = self._normalizeScheme(specData.get('draft_uri')) if (draftURL): if (draftURL.endswith('/')): draftURL = draftURL[:-1] self.specNames[draftURL.lower()] = specName self.specAnchors[specName] = set() if ('anchors' in specData): self._addAnchors(specData['anchors'], specName) if ('draft_anchors' in specData): self._addAnchors(specData['draft_anchors'], specName) url = self._normalizeScheme(url.lower()) for specURL in self.specNames: if (url.startswith(specURL) and ((url == specURL) or url.startswith(specURL + '/') or url.startswith(specURL + '#'))): anchorURL = url[len(specURL):] if (anchorURL.startswith('/')): anchorURL = anchorURL[1:] specName = self.specNames[specURL] if (anchorURL in self.specAnchors[specName]): return (specName, anchorURL) return (specName, None) return (None, None) def gatherTests(self, dir): dirName = os.path.basename(dir) if (dirName in self.skipDirs): return self.ui.note("Scanning directory: ", dir, "\n") suiteFileNames = defaultdict(set) for fileName in Utils.listfiles(dir): filePath = os.path.join(dir, fileName) if not self.sourceTree.isTestCase(filePath): continue source = self.sourceCache.generateSource(filePath, fileName) if not source.isTest(): continue try: metaData = source.getMetadata(True) except Exception as error: self.ui.warn("Exception parsing '", filePath, "': ", error, "\n") continue if not metaData: if (source.errors): self.ui.warn("Error parsing '", filePath, "': ", ' '.join(source.errors), "\n") else: self.ui.warn("No metadata available for '", filePath, "'\n") continue for specURL in metaData['links']: specName, anchorURL = self.getSpecName(specURL) if not specName: self.ui.note("Unknown specification URL: ", specURL, "\n in: ", filePath, "\n") continue if not specName in self.buildSpecNames: continue if not anchorURL: self.ui.warn("Test links to unknown specification anchor: ", specURL, "\n in: ", filePath, "\n") continue for testSuiteName in self.buildSpecNames[specName]: formats = self.testSuiteData[testSuiteName].get('formats') if (formats): for formatName in formats: if (((formatName) in self.formatData) and (self.formatData[formatName].get('mime_type') == source.mimetype)): suiteFileNames[testSuiteName].add(fileName) break else: self.ui.note("Test not in acceptable format: ", source.mimetype, "\n for: ", filePath, "\n") for testSuiteName in suiteFileNames: if (dirName in self.rawDirs): self.testSuites[testSuiteName].addRaw(dir, self.rawDirs[dirName]) else: self.testSuites[testSuiteName].addTestsByList(dir, suiteFileNames[testSuiteName]) for subDir in Utils.listdirs(dir): subDirPath = os.path.join(dir, subDir) if (not (self.sourceTree.isIgnoredDir(subDirPath) or (subDirPath in self.ignorePaths))): self.gatherTests(subDirPath) def _findSections(self, baseURL, anchors, sectionData, parentSectionName = ''): if (anchors): for anchor in anchors: if ('section' in anchor): sectionData.append((baseURL + anchor['uri'], anchor['name'], anchor['title'] if 'title' in anchor else 'Untitled')) else: sectionData.append((baseURL + anchor['uri'], parentSectionName + '.#' + anchor['name'], None)) if ('children' in anchor): self._findSections(baseURL, anchor['children'], sectionData, anchor['name']) return sectionData def getSections(self, specName): specData = self.specificationData[specName] specURL = specData['base_uri'] if ('base_uri' in specData) else specData.get('draft_uri') anchorData = specData['anchors'] if ('anchors' in specData) else specData['draft_anchors'] sectionData = [] self._findSections(specURL, anchorData, sectionData) return sectionData def _user(self, user): if (user): data = user['full_name'] if ('organization' in user): data += ', ' + user['organization'] if ('uri' in user): data += ', ' + user['uri'] elif ('email' in user): data += ', <' + user['email'].replace('@', ' @') + '>' return data return 'None Yet' def getSuiteData(self): data = {} for testSuiteName in self.testSuiteData: testSuiteData = self.testSuiteData[testSuiteName] specData = self.specificationData[testSuiteData['specs'][0]] data[testSuiteName] = { 'title': testSuiteData['title'] if ('title' in testSuiteData) else 'Untitled', 'spec': specData['title'] if ('title' in specData) else specData['name'], 'specroot': specData['base_uri'] if ('base_uri' in specData) else specData.get('draft_uri'), 'draftroot': specData['draft_uri'] if ('draft_uri' in specData) else specData.get('base_uri'), 'owner': self._user(testSuiteData['owners'][0] if ('owners' in testSuiteData) else None), 'harness': testSuiteName, 'status': testSuiteData['status'] if ('status' in testSuiteData) else 'Unknown' } return data def getFlags(self): data = {} for flag in self.flagData: flagData = self.flagData[flag] data[flag] = { 'title': flagData['description'] if ('description' in flagData) else 'Unknown', 'abbr': flagData['title'] if ('title' in flagData) else flag } return data def build(self, testSuiteNames): try: os.makedirs(self.cacheDir) except: pass self.testSuiteData = self._loadShepherdData('test_suites', 'test suite', repo = 'css') if (not self.testSuiteData): self.ui.warn("ERROR: Unable to load test suite information.\n") return -1 if (testSuiteNames): self.buildSuiteNames = [] for testSuiteName in testSuiteNames: if (testSuiteName in self.testSuiteData): self.buildSuiteNames.append(testSuiteName) else: self.ui.status("Unknown test suite: ", testSuiteName, "\n") else: self.buildSuiteNames = [testSuiteName for testSuiteName in self.testSuiteData if self.testSuiteData[testSuiteName].get('build')] self.buildSpecNames = defaultdict(list) if (self.buildSuiteNames): self.specificationData = self._loadShepherdData('specifications', 'specification', anchors = True, draft = True) if (not self.specificationData): self.ui.warn("ERROR: Unable to load specification information.\n") return -2 for testSuiteName in self.buildSuiteNames: specNames = self.testSuiteData[testSuiteName].get('specs') if (specNames): for specName in specNames: if (specName in self.specificationData): self.buildSpecNames[specName].append(testSuiteName) else: self.ui.warn("WARNING: Test suite '", testSuiteName, "' references unknown specification: '", specName, "'.\n") else: self.ui.warn("ERROR: Test suite '", testSuiteName, "' does not have target specifications.\n") return -6 else: self.ui.status("No test suites identified\n") return 0 if (not self.buildSpecNames): self.ui.status("No target specifications identified\n") return -3 self.flagData = self._loadShepherdData('test_flags', 'test flag') if (not self.flagData): self.ui.warn("ERROR: Unable to load flag information\n") return -4 self.formatData = self._loadShepherdData('test_formats', 'test format') if (not self.formatData): self.ui.warn("ERROR: Unable to load format information\n") return -5 self.buildSuiteNames.sort() for testSuiteName in self.buildSuiteNames: data = self.testSuiteData[testSuiteName] specData = self.specificationData[data['specs'][0]] specURL = specData['base_uri'] if ('base_uri' in specData) else specData.get('draft_uri') draftURL = specData['draft_uri'] if ('draft_uri' in specData) else specData.get('base_uri') self.testSuites[testSuiteName] = Suite.TestSuite(testSuiteName, data['title'], specURL, draftURL, self.sourceCache, self.ui) # XXX need to support multiple specs if ('formats' in data): self.testSuites[testSuiteName].setFormats(data['formats']) self.ui.status("Scanning test files\n") for dir in Utils.listdirs('.'): if (not (self.sourceTree.isIgnoredDir(dir) or (dir in self.ignorePaths))): self.gatherTests(dir) if (os.path.exists(self.workPath)): self.ui.note("Clearing work path: ", self.workPath, "\n") shutil.rmtree(self.workPath) suiteData = self.getSuiteData() flagData = self.getFlags() templatePath = os.path.join('tools', 'templates') for testSuiteName in self.buildSuiteNames: testSuite = self.testSuites[testSuiteName] self.ui.status("Building ", testSuiteName, "\n") specSections = self.getSections(self.testSuiteData[testSuiteName]['specs'][0]) indexer = Indexer.Indexer(testSuite, specSections, suiteData, flagData, True, templatePathList = [templatePath], extraData = {'devel' : False, 'official' : True }) workPath = os.path.join(self.workPath, testSuiteName) testSuite.buildInto(workPath, indexer) # move from work path to output path for testSuiteName in self.buildSuiteNames: workPath = os.path.join(self.workPath, testSuiteName) outputPath = os.path.join(self.outputPath, testSuiteName) backupPath = os.path.join(self.backupPath, testSuiteName) if (self.backupPath) else None if (os.path.exists(workPath)): if (os.path.exists(outputPath)): if (backupPath): if (os.path.exists(backupPath)): self.ui.note("Removing ", backupPath, "\n") shutil.rmtree(backupPath) # delete old backup self.ui.note("Backing up ", outputPath, " to ", backupPath, "\n") shutil.move(outputPath, backupPath) # backup old output else: self.ui.note("Removing ", outputPath, "\n") shutil.rmtree(outputPath) # no backups, delete old output self.ui.note("Moving ", workPath, " to ", outputPath, "\n") shutil.move(workPath, outputPath) if (os.path.exists(self.workPath)): shutil.rmtree(self.workPath) return 0 if __name__ == "__main__": # called from the command line parser = optparse.OptionParser(usage = "usage: %prog [options] test_suite [...]") parser.add_option("-q", "--quiet", action = "store_true", dest = "quiet", default = False, help = "don't print status messages to stdout") parser.add_option("-d", "--debug", action = "store_true", dest = "debug", default = False, help = "print detailed debugging information to stdout") parser.add_option("-v", "--verbose", action = "store_true", dest = "verbose", default = False, help = "print more detailed debugging information to stdout") parser.add_option("-o", "--output", dest = "output", metavar = "OUTPUT_PATH", help = "Path to build into (default 'dist')") parser.add_option("-b", "--backup", dest = "backup", metavar = "BACKUP_PATH", help = "Path to preserve old version to") parser.add_option("-i", "--ignore", action = "append", dest = "ignore", metavar = "IGNORE_PATH", help = "Ignore files in this path") parser.add_option("-c", "--cache", action = "store_true", dest = "cache", default = False, help = "use cached test suite and specification data only") (options, args) = parser.parse_args() ui = ui.ui() ui.setconfig('ui', 'debug', str(options.debug)) ui.setconfig('ui', 'quiet', str(options.quiet)) ui.setconfig('ui', 'verbose', str(options.verbose)) builder = Builder(ui, options.output, options.backup, options.ignore, options.cache) result = builder.build(args) quit(result)