Beispiel #1
0
    def _build_document(self):
        """Take the internal fields dictionary, the _root_elem_name, and the style sheet url to build
        an xml document.
        """
        # check for all required xml fields
        fields_known = self._fields.keys()
        fields_known.sort()
        for requiredKey in self._required_fields:
            if requiredKey not in fields_known:
                raise DashXMLLogException("Missing Required Field %s" %
                                          requiredKey)

        doc = Document()
        processingInstr = doc.createProcessingInstruction(
            "xml-stylesheet",
            "type=\"text/xsl\" href=\"%s\"" % self._style_sheet_url)
        doc.appendChild(processingInstr)

        # create the base element
        base = doc.createElement(self._root_elem_name)
        doc.appendChild(base)

        for key in fields_known:
            elem = doc.createElement(key)
            base.appendChild(elem)

            val = doc.createTextNode("%s" % self._fields[key])
            elem.appendChild(val)

        return doc
Beispiel #2
0
def go(tests, output_prefix) :
    """genere les balises de tests de l arbre xml et leurs contenus."""
    from xml.dom.minidom import Document
    doc = Document()#creation du document
    doc.appendChild(doc.createProcessingInstruction("xml-stylesheet",
                                                    "type=\"text/xsl\" href=\"report.xsl\""))
    testsElt = doc.createElement("tests")#creation du noeud "tests"
    doc.appendChild(testsElt)
    #creation des noeuds "test" et de leurs contenus
    for test in tests:
        testElt = doc.createElement("test")
        testsElt.appendChild(testElt)
        #construction du noeud diagnostic
        testElt.appendChild(serializeDiagnostic(doc, test["diagnostic"]))
        
        #creation du noeud "comparisons"
        comparisons = doc.createElement("comparisons")
        #pour chaque instance de comparaison
        for comparison in test["comparisons"]: 
            comparisons.appendChild(serializeComparison(doc, comparison))
        testElt.appendChild(comparisons)
    output_file = os.path.join(output_prefix, 'report.xml')
    output_file_xsl = os.path.join(output_prefix, 'report.xsl')
    #on genere le fichier xml
    logfile = open(output_file, 'w')
    logfile.write(doc.toprettyxml(indent="  ", encoding="UTF-8"))
    logfile.close()

    print 'Le fichier résultat est', output_file
    # copie de la feuille xsl
    shutil.copyfile('xslt/report.xsl', output_file_xsl)
Beispiel #3
0
    def impl_create_pydevproject(self, appname, system_path, user_path):
        # create a pydevproject file
        doc = Document()
        doc.appendChild(doc.createProcessingInstruction("eclipse-pydev", 'version="1.0"'))
        pydevproject = doc.createElement("pydev_project")
        prop = self.add(
            doc, pydevproject, "pydev_property", "python %d.%d" % (sys.version_info[0], sys.version_info[1])
        )
        prop.setAttribute("name", "org.python.pydev.PYTHON_PROJECT_VERSION")
        prop = self.add(doc, pydevproject, "pydev_property", "Default")
        prop.setAttribute("name", "org.python.pydev.PYTHON_PROJECT_INTERPRETER")
        # add waf's paths
        wafadmin = [p for p in system_path if p.find("wafadmin") != -1]
        if wafadmin:
            prop = self.add(
                doc, pydevproject, "pydev_pathproperty", {"name": "org.python.pydev.PROJECT_EXTERNAL_SOURCE_PATH"}
            )
            for i in wafadmin:
                self.add(doc, prop, "path", i)
        if user_path:
            prop = self.add(doc, pydevproject, "pydev_pathproperty", {"name": "org.python.pydev.PROJECT_SOURCE_PATH"})
            for i in user_path:
                self.add(doc, prop, "path", "/" + appname + "/" + i)

        doc.appendChild(pydevproject)
        return doc
Beispiel #4
0
    def dumps(self, obj):
        """
        Dump the given object which may be a container of any objects
        supported by the reports added to the manager.
        """
        document = Document()

        if self.stylesheet:
            type = "text/xsl"
            href = "file://%s" % posixpath.abspath(self.stylesheet)
            style = document.createProcessingInstruction("xml-stylesheet",
                "type=\"%s\" href=\"%s\"" % (type, href))
            document.appendChild(style)

        node = document.createElement(self.name)
        document.appendChild(node)

        if self.version:
            node.setAttribute("version", self.version)

        try:
            self.call_dumps(obj, node)
        except KeyError as e:
            raise ValueError("Unsupported type: %s" % e)

        return document
Beispiel #5
0
    def dumps(self, obj):
        """
        Dump the given object which may be a container of any objects
        supported by the reports added to the manager.
        """
        document = Document()

        if self.stylesheet:
            type = "text/xsl"
            href = "file://%s" % posixpath.abspath(self.stylesheet)
            style = document.createProcessingInstruction(
                "xml-stylesheet", "type=\"%s\" href=\"%s\"" % (type, href))
            document.appendChild(style)

        node = document.createElement(self.name)
        document.appendChild(node)

        if self.version:
            node.setAttribute("version", self.version)

        try:
            self.call_dumps(obj, node)
        except KeyError as e:
            raise ValueError("Unsupported type: %s" % e)

        return document
Beispiel #6
0
	def impl_create_pydevproject(self, system_path, user_path):
		# create a pydevproject file
		doc = Document()
		doc.appendChild(doc.createProcessingInstruction('eclipse-pydev', 'version="1.0"'))
		pydevproject = doc.createElement('pydev_project')
		prop = self.add(doc, pydevproject,
					   'pydev_property',
					   'python %d.%d'%(sys.version_info[0], sys.version_info[1]))
		prop.setAttribute('name', 'org.python.pydev.PYTHON_PROJECT_VERSION')
		prop = self.add(doc, pydevproject, 'pydev_property', 'Default')
		prop.setAttribute('name', 'org.python.pydev.PYTHON_PROJECT_INTERPRETER')
		# add waf's paths
		wafadmin = [p for p in system_path if p.find('wafadmin') != -1]
		if wafadmin:
			prop = self.add(doc, pydevproject, 'pydev_pathproperty',
					{'name':'org.python.pydev.PROJECT_EXTERNAL_SOURCE_PATH'})
			for i in wafadmin:
				self.add(doc, prop, 'path', i)
		if user_path:
			prop = self.add(doc, pydevproject, 'pydev_pathproperty',
					{'name':'org.python.pydev.PROJECT_SOURCE_PATH'})
			for i in user_path:
				self.add(doc, prop, 'path', '/${PROJECT_DIR_NAME}/'+i)

		doc.appendChild(pydevproject)
		return doc
Beispiel #7
0
	def impl_create_pydevproject(self, appname, system_path, user_path):
		# create a pydevproject file
		doc = Document()
		doc.appendChild(doc.createProcessingInstruction('eclipse-pydev', 'version="1.0"'))
		pydevproject = doc.createElement('pydev_project')
		prop = self.add(doc, pydevproject,
					   'pydev_property',
					   'python %d.%d'%(sys.version_info[0], sys.version_info[1]))
		prop.setAttribute('name', 'org.python.pydev.PYTHON_PROJECT_VERSION')
		prop = self.add(doc, pydevproject, 'pydev_property', 'Default')
		prop.setAttribute('name', 'org.python.pydev.PYTHON_PROJECT_INTERPRETER')
		# add waf's paths
		wafadmin = [p for p in system_path if p.find('wafadmin') != -1]
		if wafadmin:
			prop = self.add(doc, pydevproject, 'pydev_pathproperty',
					{'name':'org.python.pydev.PROJECT_EXTERNAL_SOURCE_PATH'})
			for i in wafadmin:
				self.add(doc, prop, 'path', i)
		if user_path:
			prop = self.add(doc, pydevproject, 'pydev_pathproperty',
					{'name':'org.python.pydev.PROJECT_SOURCE_PATH'})
			for i in user_path:
				self.add(doc, prop, 'path', '/'+appname+'/'+i)

		doc.appendChild(pydevproject)
		return doc
def createXML(IRDtestResults):

	# Create the minidom document
	doc = Document()

	# create the Tests container:
	root = doc.createElement("IRDTests")
	doc.appendChild(root)
	
	#XSL processing instruction:
	pi = doc.createProcessingInstruction('xml-stylesheet',
										 'type="text/xsl" href="testResult.xslt"')
	root = doc.firstChild
	doc.insertBefore(pi, root)

	IRDs = list()
	failedIRDs = list()
	
	# add the test results:
	tests = doc.createElement("Tests")
	root.appendChild(tests)
	for irdResult in IRDtestResults:
		test = doc.createElement("Test")
		test.setAttribute("id", str(irdResult.TestId).lower())
		test.setAttribute("IRD", irdResult.IRD)
		
		if not irdResult.IRD in IRDs:
			IRDs.append(irdResult.IRD)
		
		if(not irdResult.bIsPass):
			if not irdResult.IRD in failedIRDs:
				failedIRDs.append(irdResult.IRD)
		test.setAttribute("pass", str(irdResult.bIsPass).lower())
		tests.appendChild(test)

	IRDs.sort()
	failedIRDs.sort()
	
	#add summary of IRDs:
	IRDsNode = doc.createElement("IRDs")
	root.appendChild(IRDsNode)
	for IRD in IRDs:
		irdNode = doc.createElement("IRD")
		IRDsNode.appendChild(irdNode)
		irdNode.setAttribute("name", IRD)
		bSuccess = True
		if IRD in failedIRDs:
			bSuccess = False
		irdNode.setAttribute("pass", str(bSuccess).lower())
	
	return doc
def main(args):
  # Input file should be called men.csv
  filename = 'men.csv'
  # The XML nodes will be named <bot>
  single_item = 'bot'
  safe_filename = filename[:-4]
  
  try:
    f = csv.reader(open(filename, 'r'))
  except IOError:
    print('ERROR: Input file men.csv not found in current working directory')
    sys.exit(1)
    
  doc = Document()
  # Use the file name as the root node name
  root_element = doc.createElement(safe_filename)
  doc.appendChild(root_element)
  # Add the style sheet info
  pi = doc.createProcessingInstruction('xml-stylesheet',
                                       'type="text/xsl"'
                                       'href="men.xsl"')
  doc.insertBefore(pi, doc.firstChild)
  # Get the header row from the csv file
  # If it's missing or short, use a default
  columns = next(f)
  if len(columns) < 4:
    columns = ['ipaddress','port','seq_no','active']

  # Remove white space from around column names
  for i in range(len(columns)):
    columns[i] = columns[i].strip()

  # Populate the XML document
  index = 0
  for row in f:
    index += 1
    item = doc.createElement(single_item)
    item.setAttribute('id', str(index))
    root_element.appendChild(item)
    for c in enumerate(create_col_nodes(columns, item, doc)):
      # jpo: Strip white space from node entries
      row[0] = row[0].strip()
      c[1].appendChild(doc.createTextNode(row.pop(0)))
  
  output_file = safe_filename + ".xml"
  # jpo: Add indents and newlines to the XML output
  doc.writexml(open(output_file, 'w'), ' ' * 2, ' ' * 2, '\n') # Write file
  
  print("Done: Created %s" % output_file)
Beispiel #10
0
def main(args):
    # Input file should be called men.csv
    filename = 'men.csv'
    # The XML nodes will be named <bot>
    single_item = 'bot'
    safe_filename = filename[:-4]

    try:
        f = csv.reader(open(filename, 'r'))
    except IOError:
        print(
            'ERROR: Input file men.csv not found in current working directory')
        sys.exit(1)

    doc = Document()
    # Use the file name as the root node name
    root_element = doc.createElement(safe_filename)
    doc.appendChild(root_element)
    # Add the style sheet info
    pi = doc.createProcessingInstruction('xml-stylesheet', 'type="text/xsl"'
                                         'href="men.xsl"')
    doc.insertBefore(pi, doc.firstChild)
    # Get the header row from the csv file
    # If it's missing or short, use a default
    columns = next(f)
    if len(columns) < 4:
        columns = ['ipaddress', 'port', 'seq_no', 'active']

    # Remove white space from around column names
    for i in range(len(columns)):
        columns[i] = columns[i].strip()

    # Populate the XML document
    index = 0
    for row in f:
        index += 1
        item = doc.createElement(single_item)
        item.setAttribute('id', str(index))
        root_element.appendChild(item)
        for c in enumerate(create_col_nodes(columns, item, doc)):
            # jpo: Strip white space from node entries
            row[0] = row[0].strip()
            c[1].appendChild(doc.createTextNode(row.pop(0)))

    output_file = safe_filename + ".xml"
    # jpo: Add indents and newlines to the XML output
    doc.writexml(open(output_file, 'w'), ' ' * 2, ' ' * 2, '\n')  # Write file

    print("Done: Created %s" % output_file)
Beispiel #11
0
class XMLDocument:

	def __init__(self, listRetreived, setWords):
		# Create the minidom document
		self.doc = Document()
		self.listRetreived = listRetreived
		self.setWords = setWords
	
	def getXML(self):
		# <!DOCTYPE Resultado SYSTEM "Resultados.dtd">
		self.doc.appendChild(self.doc.createProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" href=\"Resultados.xsl\""))
		
		Resultado = self.doc.createElement("Resultado")
		self.doc.appendChild(Resultado)

		Pregunta = self.doc.createElement("Pregunta")
		Resultado.appendChild(Pregunta)

		for word in self.setWords:
		
			Item = self.doc.createElement("Item")
			Pregunta.appendChild(Item)
			textItem = self.doc.createTextNode("%s" %(word))
			Item.appendChild(textItem)

		for element in self.listRetreived:
		
			Documento = self.doc.createElement("Documento")
			Documento.setAttribute("ID", "%s" %(element[0]))
			Resultado.appendChild(Documento)

			Titulo = self.doc.createElement("Titulo")
			Documento.appendChild(Titulo)
			textTitulo = self.doc.createTextNode("%s" %(element[1]))
			Titulo.appendChild(textTitulo)

			Relevancia = self.doc.createElement("Relevancia")
			Documento.appendChild(Relevancia)
			textRelevancia = self.doc.createTextNode('%s' %(element[3]))
			Relevancia.appendChild(textRelevancia)

			Texto = self.doc.createElement("Texto")
			Documento.appendChild(Texto)
			text = self.doc.createTextNode("%s" %(element[2]))
			Texto.appendChild(text)

		return self.doc.toprettyxml(indent="\t")
Beispiel #12
0
    def export(results, handle):
        '''save the chats in results (from get_chats or get_chats_between) as xml
        to handle (file like object)

        the caller is responsible of closing the handle
        '''
        from xml.dom.minidom import Document

        doc = Document()
        doc.appendChild(
            doc.createProcessingInstruction(
                "xml-stylesheet",
                "type=\"text/css\" href=\"conversation.css\""))
        conversation = doc.createElement("conversation")
        doc.appendChild(conversation)

        for stat, timestamp, message, nick, account in results:

            timestamp_tag = doc.createElement("timestamp")
            date_text = time.strftime('[%c]', time.gmtime(timestamp))
            timestamp_text = doc.createTextNode(date_text)
            timestamp_tag.appendChild(timestamp_text)

            nick_tag = doc.createElement("nick")
            nick_text = doc.createTextNode(nick)
            nick_tag.appendChild(nick_text)
            timestamp_tag.appendChild(nick_tag)

            status_tag = doc.createElement("status")
            status_text = doc.createTextNode(str(stat))
            status_tag.appendChild(status_text)
            timestamp_tag.appendChild(status_tag)

            account_tag = doc.createElement("account")
            account_text = doc.createTextNode(account)
            account_tag.appendChild(account_text)
            timestamp_tag.appendChild(account_tag)

            message_tag = doc.createElement("message")
            message_text = doc.createTextNode(message)
            message_tag.appendChild(message_text)
            timestamp_tag.appendChild(message_tag)

            conversation.appendChild(timestamp_tag)

        handle.write(doc.toprettyxml(indent="  ", encoding="UTF-8"))
Beispiel #13
0
def save_logs_as_xml(results, handle):
    '''save the chats in results (from get_chats or get_chats_between) as xml
    to handle (file like object)

    the caller is responsible of closing the handle
    '''
    from xml.dom.minidom import Document

    doc = Document()
    doc.appendChild(doc.createProcessingInstruction("xml-stylesheet",
                                "type=\"text/css\" href=\"conversation.css\""))
    conversation = doc.createElement("conversation")
    doc.appendChild(conversation)

    for stat, timestamp, message, nick, account in results:

        timestamp_tag = doc.createElement("timestamp")
        date_text = time.strftime('[%c]', time.gmtime(timestamp))
        timestamp_text = doc.createTextNode(date_text)
        timestamp_tag.appendChild(timestamp_text)

        nick_tag = doc.createElement("nick")
        nick_text = doc.createTextNode(nick)
        nick_tag.appendChild(nick_text)
        timestamp_tag.appendChild(nick_tag)

        status_tag = doc.createElement("status")
        status_text = doc.createTextNode(str(stat))
        status_tag.appendChild(status_text)
        timestamp_tag.appendChild(status_tag)

        account_tag = doc.createElement("account")
        account_text = doc.createTextNode(account)
        account_tag.appendChild(account_text)
        timestamp_tag.appendChild(account_tag)

        message_tag = doc.createElement("message")
        message_text = doc.createTextNode(message)
        message_tag.appendChild(message_text)
        timestamp_tag.appendChild(message_tag)

        conversation.appendChild(timestamp_tag)

    handle.write(doc.toprettyxml(indent="  ",  encoding="UTF-8"))
Beispiel #14
0
    def impl_create_pydevproject(self, system_path, user_path):
        # create a pydevproject file
        doc = Document()
        doc.appendChild(
            doc.createProcessingInstruction("eclipse-pydev", 'version="1.0"'))
        pydevproject = doc.createElement("pydev_project")
        prop = self.add(
            doc,
            pydevproject,
            "pydev_property",
            "python %d.%d" % (sys.version_info[0], sys.version_info[1]),
        )
        prop.setAttribute("name", "org.python.pydev.PYTHON_PROJECT_VERSION")
        prop = self.add(doc, pydevproject, "pydev_property", "Default")
        prop.setAttribute("name",
                          "org.python.pydev.PYTHON_PROJECT_INTERPRETER")
        # add waf's paths
        wafadmin = [p for p in system_path if p.find("wafadmin") != -1]
        if wafadmin:
            prop = self.add(
                doc,
                pydevproject,
                "pydev_pathproperty",
                {"name": "org.python.pydev.PROJECT_EXTERNAL_SOURCE_PATH"},
            )
            for i in wafadmin:
                self.add(doc, prop, "path", i)
        if user_path:
            prop = self.add(
                doc,
                pydevproject,
                "pydev_pathproperty",
                {"name": "org.python.pydev.PROJECT_SOURCE_PATH"},
            )
            for i in user_path:
                self.add(doc, prop, "path", "/${PROJECT_DIR_NAME}/" + i)

        doc.appendChild(pydevproject)
        return doc
Beispiel #15
0
	def impl_create_cproject(self, executable, waf, appname, workspace_includes, cpppath, source_dirs=[]):
		doc = Document()
		doc.appendChild(doc.createProcessingInstruction('fileVersion', '4.0.0'))
		cconf_id = cdt_core + '.default.config.1'
		cproject = doc.createElement('cproject')
		storageModule = self.add(doc, cproject, 'storageModule',
				{'moduleId': cdt_core + '.settings'})
		cconf = self.add(doc, storageModule, 'cconfiguration', {'id':cconf_id})

		storageModule = self.add(doc, cconf, 'storageModule',
				{'buildSystemId': oe_cdt + '.managedbuilder.core.configurationDataProvider',
				 'id': cconf_id,
				 'moduleId': cdt_core + '.settings',
				 'name': 'Default'})

		self.add(doc, storageModule, 'externalSettings')

		extensions = self.add(doc, storageModule, 'extensions')
		extension_list = """
			VCErrorParser
			MakeErrorParser
			GCCErrorParser
			GASErrorParser
			GLDErrorParser
		""".split()
		ext = self.add(doc, extensions, 'extension',
					{'id': cdt_core + '.ELF', 'point':cdt_core + '.BinaryParser'})
		for e in extension_list:
			ext = self.add(doc, extensions, 'extension',
					{'id': cdt_core + '.' + e, 'point':cdt_core + '.ErrorParser'})

		storageModule = self.add(doc, cconf, 'storageModule',
				{'moduleId': 'cdtBuildSystem', 'version': '4.0.0'})
		config = self.add(doc, storageModule, 'configuration',
					{'artifactName': appname,
					 'id': cconf_id,
					 'name': 'Default',
					 'parent': cdt_bld + '.prefbase.cfg'})
		folderInfo = self.add(doc, config, 'folderInfo',
							{'id': cconf_id+'.', 'name': '/', 'resourcePath': ''})

		toolChain = self.add(doc, folderInfo, 'toolChain',
				{'id': cdt_bld + '.prefbase.toolchain.1',
				 'name': 'No ToolChain',
				 'resourceTypeBasedDiscovery': 'false',
				 'superClass': cdt_bld + '.prefbase.toolchain'})

		targetPlatform = self.add(doc, toolChain, 'targetPlatform',
				{ 'binaryParser': 'org.eclipse.cdt.core.ELF',
				  'id': cdt_bld + '.prefbase.toolchain.1', 'name': ''})

		waf_build = '"%s" %s'%(waf, eclipse.fun)
		waf_clean = '"%s" clean'%(waf)
		builder = self.add(doc, toolChain, 'builder',
						{'autoBuildTarget': waf_build,
						 'command': executable,
						 'enableAutoBuild': 'false',
						 'cleanBuildTarget': waf_clean,
						 'enableIncrementalBuild': 'true',
						 'id': cdt_bld + '.settings.default.builder.1',
						 'incrementalBuildTarget': waf_build,
						 'managedBuildOn': 'false',
						 'name': 'Gnu Make Builder',
						 'superClass': cdt_bld + '.settings.default.builder'})

		for tool_name in ("Assembly", "GNU C++", "GNU C"):
			tool = self.add(doc, toolChain, 'tool',
					{'id': cdt_bld + '.settings.holder.1',
					 'name': tool_name,
					 'superClass': cdt_bld + '.settings.holder'})
			if cpppath or workspace_includes:
				incpaths = cdt_bld + '.settings.holder.incpaths'
				option = self.add(doc, tool, 'option',
						{'id': incpaths+'.1',
						 'name': 'Include Paths',
						 'superClass': incpaths,
						 'valueType': 'includePath'})
				for i in workspace_includes:
					self.add(doc, option, 'listOptionValue',
								{'builtIn': 'false',
								'value': '"${workspace_loc:/%s/%s}"'%(appname, i)})
				for i in cpppath:
					self.add(doc, option, 'listOptionValue',
								{'builtIn': 'false',
								'value': '"%s"'%(i)})
		if source_dirs:
			sourceEntries = self.add(doc, config, 'sourceEntries')
			for i in source_dirs:
				 self.add(doc, sourceEntries, 'entry',
							{'excluding': i,
							'flags': 'VALUE_WORKSPACE_PATH|RESOLVED',
							'kind': 'sourcePath',
							'name': ''})
				 self.add(doc, sourceEntries, 'entry',
							{
							'flags': 'VALUE_WORKSPACE_PATH|RESOLVED',
							'kind': 'sourcePath',
							'name': i})

		storageModule = self.add(doc, cconf, 'storageModule',
							{'moduleId': cdt_mk + '.buildtargets'})
		buildTargets = self.add(doc, storageModule, 'buildTargets')
		def addTargetWrap(name, runAll):
			return self.addTarget(doc, buildTargets, executable, name,
								'"%s" %s'%(waf, name), runAll)
		addTargetWrap('configure', True)
		addTargetWrap('dist', False)
		addTargetWrap('install', False)
		addTargetWrap('check', False)

		storageModule = self.add(doc, cproject, 'storageModule',
							{'moduleId': 'cdtBuildSystem',
							 'version': '4.0.0'})

		project = self.add(doc, storageModule, 'project',
					{'id': '%s.null.1'%appname, 'name': appname})

		doc.appendChild(cproject)
		return doc
Beispiel #16
0
    def xml(self,log4xml,Start_Time):
        Total,Pass,Fail=0,0,-len(self.result)
        for x in range(len(log4xml)):
            if log4xml[x].get('CODE') == '1':
                Total+=1
            elif log4xml[x].get('CODE') == '0':
                Pass+=1
            elif log4xml[x].get('CODE') == '-2' or log4xml[x].get('CODE') == '-1':
                Fail+=1

        testPlan = 'wait for write'

        Hosename=os.popen('Hostname').read()



        doc = Document()
        abc = doc.createProcessingInstruction("xml-stylesheet","type=\"text/xsl\" href=\"cts_result.xsl\"")
        doc.appendChild(abc)
        Result = doc.createElement('TestResult')
        Result.setAttribute('testPlan', testPlan)
        Result.setAttribute('starttime', self.StartTime)
        Result.setAttribute('endtime', self.EndTime)
        Result.setAttribute('suite', 'QGP_Automation')
        doc.appendChild(Result)



        DeviceInfo = doc.createElement('DeviceInfo')

        Result.appendChild(DeviceInfo)
        BuildInfo =doc.createElement('BuildInfo')
        BuildInfo.setAttribute('productName', ADB_getValue().product_Name)
        BuildInfo.setAttribute('productModel', ADB_getValue().product_Model)
        BuildInfo.setAttribute('deviceID', serial_number)
        BuildInfo.setAttribute('AUVersion', ADB_getValue().version_AU)
        BuildInfo.setAttribute('METAVersion', ADB_getValue().version_Meta)
        BuildInfo.setAttribute('AndroidVersion', ADB_getValue().version_Release)
        BuildInfo.setAttribute('AndroidAPILevel', ADB_getValue().version_SDK)


        DeviceInfo.appendChild(BuildInfo)
        HostInfo =doc.createElement('HostInfo')
        HostInfo.setAttribute('name', Hosename)
        HostInfo.setAttribute('osversion', 'wait for write')
        HostInfo.setAttribute('osname', 'wait for write')
        Result.appendChild(HostInfo)
        Summary=doc.createElement('Summary')
        Summary.setAttribute('total',str(Total))
        Summary.setAttribute('pass',str(Pass))
        Summary.setAttribute('failed',str(Fail))
        Result.appendChild(Summary)
        for y in range(len(self.result)):
            TestPackage=doc.createElement('TestPackage')
            TestPackage.setAttribute('name',self.result[y][:-4])
            aaa=self.result[y][:-4].replace('-','')
            TestPackage.setAttribute('appPackageName',self.result[y][:-4])#wuyou
            TestSuite=doc.createElement('TestSuite')
            TestCase =doc.createElement('TestCase')
            for x in range(len(log4xml)):
                CLASS = log4xml[x].get('class')
                if CLASS !=None:
                    className=CLASS.split('.')
                    if className[1]==aaa:

                        if log4xml[x].get('CODE') == '1':
                            pass
                        elif log4xml[x].get('CODE') == '-1':
                            Test=doc.createElement('Test')
                            Test.setAttribute('name',log4xml[x].get('test'))
                            Test.setAttribute('result','fail')
                            FailedScene=doc.createElement('FailedScene')
                            FailedScene.setAttribute('message',log4xml[x].get('stack'))
                            Test.appendChild(FailedScene)
                            a1=log4xml[x].get('FailReason')
                            if a1 !=None:
                                StackTrace=doc.createElement('StackTrace')
                                testR=doc.createTextNode(a1[0])
                                StackTrace.appendChild(testR)
                                FailedScene.appendChild(StackTrace)
                                TestCase.appendChild(Test)
                        elif log4xml[x].get('CODE') == '0':
                            Test=doc.createElement('Test')
                            Test.setAttribute('name',log4xml[x].get('test'))
                            Test.setAttribute('result','pass')
                            TestCase.appendChild(Test)
                        elif log4xml[x].get('CODE') == '-2':
                            Test=doc.createElement('Test')
                            Test.setAttribute('name',log4xml[x].get('test'))
                            Test.setAttribute('result','fail')
                            FailedScene=doc.createElement('FailedScene')
                            FailedScene.setAttribute('message',log4xml[x].get('stack'))
                            Test.appendChild(FailedScene)
                            a1=log4xml[x].get('FailReason')
                            if a1 !=None:
                                #print a1
                                StackTrace=doc.createElement('StackTrace')
                                testR=doc.createTextNode(a1[0])
                                StackTrace.appendChild(testR)
                                FailedScene.appendChild(StackTrace)
                                TestCase.appendChild(Test)
                    else:
                        pass

            TestSuite.appendChild(TestCase)

            TestPackage.appendChild(TestSuite)

            Result.appendChild(TestPackage)

        #f = open('C:\\Users\\c_youwu\\Desktop\\result\\testResult.xml','w')

        f = open('%s\\%s\\testResult.xml' % (QGP_Path().PATH_RESULTS,Start_Time) , 'w')
        f.write(doc.toprettyxml(indent = '',encoding='utf-8'))
        f.close()

        self.coverFiles(QGP_Path().PATH_DOCS,'%s\%s' % (QGP_Path().PATH_RESULTS,Start_Time))
Beispiel #17
0
import sys

if len(sys.argv) != 3:
    sys.exit()

dir = sys.argv[1]
eventfile = dir + "SMSSend_monitoring.log"
filefile = dir + "KernelFile_monitoring.log"
networkfile = dir + "KernelNetwork_monitoring.log"
smsfile = dir + "SMSSend_monitoring.log"
urlfile = dir + "OutboundUrl_monitoring.log"

xml = Document()

pi = xml.createProcessingInstruction(
    'xml-stylesheet',
    'type="text/xsl" href="' + sys.argv[2] + '/m3style/styler.xls"')
xml.appendChild(pi)

analysis = xml.createElement("analysis")
xml.appendChild(analysis)

testStrategy = xml.createElement("testStrategy")
testStrategy.setAttribute("name", "WidgetBasedRandomSelection")
analysis.appendChild(testStrategy)

events = xml.createElement("events")
testStrategy.appendChild(events)

actionset = xml.createElement("actionset")
testStrategy.appendChild(actionset)
Beispiel #18
0
	def impl_create_cproject(self, executable, waf_executable, appname, workspace_includes, cpppath, source_dirs=[]):
		doc = Document()
		doc.appendChild(doc.createProcessingInstruction('fileVersion', '4.0.0'))
		cconf_id = cdt_core + '.default.config.1'
		cproject = doc.createElement('cproject')
		storageModule = self.add(doc, cproject, 'storageModule',
				{'moduleId': cdt_core + '.settings'})
		cconf = self.add(doc, storageModule, 'cconfiguration', {'id':cconf_id})

		storageModule = self.add(doc, cconf, 'storageModule',
				{'buildSystemId': oe_cdt + '.managedbuilder.core.configurationDataProvider',
				 'id': cconf_id,
				 'moduleId': cdt_core + '.settings',
				 'name': 'Default'})

		self.add(doc, storageModule, 'externalSettings')

		extensions = self.add(doc, storageModule, 'extensions')
		extension_list = """
			VCErrorParser
			MakeErrorParser
			GCCErrorParser
			GASErrorParser
			GLDErrorParser
		""".split()
		self.add(doc, extensions, 'extension', {'id': cdt_core + '.ELF', 'point':cdt_core + '.BinaryParser'})
		for e in extension_list:
			self.add(doc, extensions, 'extension', {'id': cdt_core + '.' + e, 'point':cdt_core + '.ErrorParser'})

		storageModule = self.add(doc, cconf, 'storageModule',
				{'moduleId': 'cdtBuildSystem', 'version': '4.0.0'})
		config = self.add(doc, storageModule, 'configuration',
					{'artifactName': appname,
					 'id': cconf_id,
					 'name': 'Default',
					 'parent': cdt_bld + '.prefbase.cfg'})
		folderInfo = self.add(doc, config, 'folderInfo',
							{'id': cconf_id+'.', 'name': '/', 'resourcePath': ''})

		toolChain = self.add(doc, folderInfo, 'toolChain',
				{'id': cdt_bld + '.prefbase.toolchain.1',
				 'name': 'No ToolChain',
				 'resourceTypeBasedDiscovery': 'false',
				 'superClass': cdt_bld + '.prefbase.toolchain'})

		self.add(doc, toolChain, 'targetPlatform', {'binaryParser': 'org.eclipse.cdt.core.ELF', 'id': cdt_bld + '.prefbase.toolchain.1', 'name': ''})

		waf_build = '"%s" %s'%(waf_executable, eclipse.fun)
		waf_clean = '"%s" clean'%(waf_executable)
		self.add(doc, toolChain, 'builder',
					{'autoBuildTarget': waf_build,
					 'command': executable,
					 'enableAutoBuild': 'false',
					 'cleanBuildTarget': waf_clean,
					 'enableIncrementalBuild': 'true',
					 'id': cdt_bld + '.settings.default.builder.1',
					 'incrementalBuildTarget': waf_build,
					 'managedBuildOn': 'false',
					 'name': 'Gnu Make Builder',
					 'superClass': cdt_bld + '.settings.default.builder'})

		tool_index = 1;
		for tool_name in ("Assembly", "GNU C++", "GNU C"):
			tool = self.add(doc, toolChain, 'tool',
					{'id': cdt_bld + '.settings.holder.' + str(tool_index),
					 'name': tool_name,
					 'superClass': cdt_bld + '.settings.holder'})
			if cpppath or workspace_includes:
				incpaths = cdt_bld + '.settings.holder.incpaths'
				option = self.add(doc, tool, 'option',
						{'id': incpaths + '.' +  str(tool_index),
						 'name': 'Include Paths',
						 'superClass': incpaths,
						 'valueType': 'includePath'})
				for i in workspace_includes:
					self.add(doc, option, 'listOptionValue',
								{'builtIn': 'false',
								'value': '"${workspace_loc:/%s/%s}"'%(appname, i)})
				for i in cpppath:
					self.add(doc, option, 'listOptionValue',
								{'builtIn': 'false',
								'value': '"%s"'%(i)})
			if tool_name == "GNU C++" or tool_name == "GNU C":
				self.add(doc,tool,'inputType',{ 'id':'org.eclipse.cdt.build.core.settings.holder.inType.' + str(tool_index), \
					'languageId':'org.eclipse.cdt.core.gcc' if tool_name == "GNU C" else 'org.eclipse.cdt.core.g++','languageName':tool_name, \
					'sourceContentType':'org.eclipse.cdt.core.cSource,org.eclipse.cdt.core.cHeader', \
					'superClass':'org.eclipse.cdt.build.core.settings.holder.inType' })
			tool_index += 1

		if source_dirs:
			sourceEntries = self.add(doc, config, 'sourceEntries')
			for i in source_dirs:
				 self.add(doc, sourceEntries, 'entry',
							{'excluding': i,
							'flags': 'VALUE_WORKSPACE_PATH|RESOLVED',
							'kind': 'sourcePath',
							'name': ''})
				 self.add(doc, sourceEntries, 'entry',
							{
							'flags': 'VALUE_WORKSPACE_PATH|RESOLVED',
							'kind': 'sourcePath',
							'name': i})

		storageModule = self.add(doc, cconf, 'storageModule',
							{'moduleId': cdt_mk + '.buildtargets'})
		buildTargets = self.add(doc, storageModule, 'buildTargets')
		def addTargetWrap(name, runAll):
			return self.addTarget(doc, buildTargets, executable, name,
								'"%s" %s'%(waf_executable, name), runAll)
		addTargetWrap('configure', True)
		addTargetWrap('dist', False)
		addTargetWrap('install', False)
		addTargetWrap('check', False)

		storageModule = self.add(doc, cproject, 'storageModule',
							{'moduleId': 'cdtBuildSystem',
							 'version': '4.0.0'})

		self.add(doc, storageModule, 'project', {'id': '%s.null.1'%appname, 'name': appname})

		doc.appendChild(cproject)
		return doc
Beispiel #19
0
class XmlDataGenerator:
    def __init__(self, xmlTDT, nonXmlPrint=None, xmlStyleData=None):
        from xml.dom.minidom import Document
        self.xmlDoc = Document()
        self.xmlTDT = xmlTDT

        eleCount = 0
        self.eleMap = {}
        for eleTDT in self.xmlTDT:
            self.eleMap[eleTDT['name']] = eleCount
            if eleTDT.__contains__('alias'):
                for eName in eleTDT['alias']:
                    self.eleMap[eName] = eleCount
            eleTDT['ele'] = None
            if not eleTDT.__contains__('cls'):
                eleTDT['cls'] = eleTDT['findex'] + 1
            if not eleTDT.__contains__('sname'):
                eleTDT['sname'] = eleTDT['name']
            if not eleTDT.__contains__('must'):
                eleTDT['must'] = True
            eleCount += 1
        for eleTDT in self.xmlTDT:
            eleTDT['clslist'] = [
                index for index in range(0, eleCount)
                if self.xmlTDT[index]['cls'] > eleTDT['cls']
            ]

        self.topEle = self.__createElement(self.xmlDoc, self.xmlTDT[0])
        if xmlStyleData != None:
            self.xmlDoc.insertBefore(
                self.xmlDoc.createProcessingInstruction(
                    "xml-stylesheet", xmlStyleData), self.topEle)

    def __getFele(self, eleIndex):
        feleIndex = self.xmlTDT[eleIndex]['findex']
        feleTDT = self.xmlTDT[feleIndex]

        if feleIndex > 0:
            fele = feleTDT['ele']
            if fele == None:
                ffele = self.__getFele(feleIndex)
                if feleTDT['must']:
                    fele = self.__createElement(ffele, feleTDT)
                else:
                    fele = ffele
            return fele
        else:
            return self.topEle

    def __createElement(self,
                        fele,
                        eleTDT,
                        content=None,
                        eleName=None,
                        **eleAttrs):
        ele = self.xmlDoc.createElement(
            eleName if eleName != None else eleTDT['sname'])
        eleTDT['ele'] = ele
        fele.appendChild(ele)
        for eleAttr in eleAttrs.keys():
            ele.setAttribute(eleAttr, eleAttrs[eleAttr])
        if content != None:
            ele.appendChild(self.xmlDoc.createCDATASection(content))

        for index in eleTDT['clslist']:
            self.xmlTDT[index]['ele'] = None
        return ele

    def addElement(self, eleName, content=None, **eleAttrs):
        eleIndex = self.eleMap[eleName]
        fele = self.__getFele(eleIndex)
        self.__createElement(fele, self.xmlTDT[eleIndex], content, eleName,
                             **eleAttrs)

    def __str__(self, indent="\t", newl="\n", encoding=None):
        return self.xmlDoc.toprettyxml(indent, newl, encoding)
Beispiel #20
0
#!/usr/bin/python

import sys, os, re
from xml.dom.minidom import Document	

tables=[]
errors=[]
ingroup = False
currenttable = ''


xmlDoc = Document()

pi= xmlDoc.createProcessingInstruction("xml-stylesheet","type=\"text/xsl\" href=\"template.xsl\"")
xmlDoc.insertBefore(pi, xmlDoc.documentElement)

wml = xmlDoc.createElement("database")
xmlDoc.appendChild(wml)

schema = open(sys.argv[1], 'r')
result = file(sys.argv[2],"w")


createTablePattern = re.compile(r'^\s+create_table \"([a-z_-]+)\"',re.M|re.I)
endTablePattern = re.compile(r'^\s+end',re.M|re.I)
fieldPattern = re.compile(r'^\s+t\.[a-z]+\s+\"([a-z0-9-_]+)\"',re.M|re.I)



for i, line in enumerate(schema):
	if re.match('^\s+$',line,re.M|re.I):
Beispiel #21
0
def exportNmapXML(pcap, out='nmapout-p0f3p.xml', retdom=False):
    import time
    doc = Document()
    pyobj = processCaptures(pcap)
    root = doc.createElement('nmaprun')
    pi = doc.createProcessingInstruction(
        'xml-stylesheet',
        'type="text/xsl" href="file:///usr/local/bin/../share/nmap/nmap.xsl"')
    first = doc.firstChild
    doc.insertBefore(pi, first)
    root.setAttribute('scanner', 'p0fplus')
    t = int(time.time())
    root.setAttribute('start', str(t))
    ftime = time.ctime(t)
    root.setAttribute('startstr', ftime.replace('  ', ' '))
    doc.appendChild(root)
    for k, v in pyobj.items():
        host = doc.createElement('host')
        root.appendChild(host)
        addr = doc.createElement('address')
        addr.setAttribute('addrtype', 'ipv4')
        k = convB2Str(k)
        addr.setAttribute('ipaddr', k)
        host.appendChild(addr)
        hostnames = doc.createElement('hostnames')
        host.appendChild(hostnames)
        if v['hostnames'] is not None:
            for h in v['hostnames']:
                hostname = doc.createElement('hostname')
                if h[-1] == '.':
                    h = h[:-1]
                hostname.setAttribute('name', h)
                hostnames.appendChild(hostname)
        ports = None
        if v['applications'] is not None:
            for app in v['applications']:
                if 'sport' in app:
                    ports = doc.createElement('ports')
                    host.appendChild(ports)
                    port = doc.createElement('port')
                    port.setAttribute(
                        'protocol',
                        'tcp')  # FIXME: change when UDP is supported
                    port.setAttribute('portid', str(app['sport']))
                    ports.appendChild(port)
                    state = doc.createElement('state')
                    state.setAttribute('state', 'open')
                    state.setAttribute('reason', 'push-ack')
                    port.appendChild(state)
                    service = doc.createElement('service')
                    if 'appname' in app:
                        service.setAttribute('product', app['appname'])
                    if 'version' in app:
                        service.setAttribute('version', app['version'])
                    if 'extrainf' in app:
                        service.setAttribute('extrainfo', app['extrainf'])
                    port.appendChild(service)
        if v['otherports'] is not None:
            for portk, value in v['otherports'].items():
                if value['matched'] is False:
                    if ports is None:
                        ports = doc.createElement('ports')
                        host.appendChild(ports)
                    port = doc.createElement('port')
                    port.setAttribute('protocol', 'tcp')
                    port.setAttribute('portid', str(portk))
                    ports.appendChild(port)
                    state = doc.createElement('state')
                    state.setAttribute('state', 'open')
                    reasonstr = flag2str(value['flag'])
                    if reasonstr is not None:
                        state.setAttribute('reason', reasonstr)
                    port.appendChild(state)
        if 'guesses' in v['matches']:
            os = doc.createElement('os')
            host.appendChild(os)
            osmatch = doc.createElement('osmatch')
            for guess in v['matches']['guesses']:
                if guess['type'] != '!':  #is a system
                    osmatch = doc.createElement('osmatch')
                    namematch = ' '.join(
                        guess['label'].split(':')[2:]).replace('.x', '')
                    osmatch.setAttribute('name', namematch)
                    accuracy = str(100 -
                                   guess['distance'])  # best formula ever!
                    osmatch.setAttribute('accuracy', accuracy)
                    os.appendChild(osmatch)
                    osclass = doc.createElement('osclass')
                    osclass.setAttribute('osfamily', guess['os'])
                    osclass.setAttribute('osgen', guess['version'])
                    osclass.setAttribute('accuracy', accuracy)
                    osmatch.appendChild(osclass)
    if retdom is True:
        return doc  # return only the minidom object
    else:
        doc.writexml(open(out, 'w'), indent="  ", addindent="  ", newl='\n')
Beispiel #22
0
    def impl_create_cproject(self, executable, waf, appname, workspace_includes, cpppath, source_dirs=[]):
        doc = Document()
        doc.appendChild(doc.createProcessingInstruction("fileVersion", "4.0.0"))
        cconf_id = cdt_core + ".default.config.1"
        cproject = doc.createElement("cproject")
        storageModule = self.add(doc, cproject, "storageModule", {"moduleId": cdt_core + ".settings"})
        cconf = self.add(doc, storageModule, "cconfiguration", {"id": cconf_id})

        storageModule = self.add(
            doc,
            cconf,
            "storageModule",
            {
                "buildSystemId": oe_cdt + ".managedbuilder.core.configurationDataProvider",
                "id": cconf_id,
                "moduleId": cdt_core + ".settings",
                "name": "Default",
            },
        )

        self.add(doc, storageModule, "externalSettings")

        extensions = self.add(doc, storageModule, "extensions")
        extension_list = """
			VCErrorParser
			MakeErrorParser
			GCCErrorParser
			GASErrorParser
			GLDErrorParser
		""".split()
        ext = self.add(doc, extensions, "extension", {"id": cdt_core + ".ELF", "point": cdt_core + ".BinaryParser"})
        for e in extension_list:
            ext = self.add(doc, extensions, "extension", {"id": cdt_core + "." + e, "point": cdt_core + ".ErrorParser"})

        storageModule = self.add(doc, cconf, "storageModule", {"moduleId": "cdtBuildSystem", "version": "4.0.0"})
        config = self.add(
            doc,
            storageModule,
            "configuration",
            {"artifactName": appname, "id": cconf_id, "name": "Default", "parent": cdt_bld + ".prefbase.cfg"},
        )
        folderInfo = self.add(doc, config, "folderInfo", {"id": cconf_id + ".", "name": "/", "resourcePath": ""})

        toolChain = self.add(
            doc,
            folderInfo,
            "toolChain",
            {
                "id": cdt_bld + ".prefbase.toolchain.1",
                "name": "No ToolChain",
                "resourceTypeBasedDiscovery": "false",
                "superClass": cdt_bld + ".prefbase.toolchain",
            },
        )

        targetPlatform = self.add(
            doc,
            toolChain,
            "targetPlatform",
            {"binaryParser": "org.eclipse.cdt.core.ELF", "id": cdt_bld + ".prefbase.toolchain.1", "name": ""},
        )

        waf_build = '"%s" %s' % (waf, eclipse.fun)
        waf_clean = '"%s" clean' % (waf)
        builder = self.add(
            doc,
            toolChain,
            "builder",
            {
                "autoBuildTarget": waf_build,
                "command": executable,
                "enableAutoBuild": "false",
                "cleanBuildTarget": waf_clean,
                "enableIncrementalBuild": "true",
                "id": cdt_bld + ".settings.default.builder.1",
                "incrementalBuildTarget": waf_build,
                "managedBuildOn": "false",
                "name": "Gnu Make Builder",
                "superClass": cdt_bld + ".settings.default.builder",
            },
        )

        for tool_name in ("Assembly", "GNU C++", "GNU C"):
            tool = self.add(
                doc,
                toolChain,
                "tool",
                {"id": cdt_bld + ".settings.holder.1", "name": tool_name, "superClass": cdt_bld + ".settings.holder"},
            )
            if cpppath or workspace_includes:
                incpaths = cdt_bld + ".settings.holder.incpaths"
                option = self.add(
                    doc,
                    tool,
                    "option",
                    {
                        "id": incpaths + ".1",
                        "name": "Include Paths",
                        "superClass": incpaths,
                        "valueType": "includePath",
                    },
                )
                for i in workspace_includes:
                    self.add(
                        doc,
                        option,
                        "listOptionValue",
                        {"builtIn": "false", "value": '"${workspace_loc:/%s/%s}"' % (appname, i)},
                    )
                for i in cpppath:
                    self.add(doc, option, "listOptionValue", {"builtIn": "false", "value": '"%s"' % (i)})
        if source_dirs:
            sourceEntries = self.add(doc, config, "sourceEntries")
            for i in source_dirs:
                self.add(
                    doc,
                    sourceEntries,
                    "entry",
                    {"excluding": i, "flags": "VALUE_WORKSPACE_PATH|RESOLVED", "kind": "sourcePath", "name": ""},
                )
                self.add(
                    doc,
                    sourceEntries,
                    "entry",
                    {"flags": "VALUE_WORKSPACE_PATH|RESOLVED", "kind": "sourcePath", "name": i},
                )

        storageModule = self.add(doc, cconf, "storageModule", {"moduleId": cdt_mk + ".buildtargets"})
        buildTargets = self.add(doc, storageModule, "buildTargets")

        def addTargetWrap(name, runAll):
            return self.addTarget(doc, buildTargets, executable, name, '"%s" %s' % (waf, name), runAll)

        addTargetWrap("configure", True)
        addTargetWrap("dist", False)
        addTargetWrap("install", False)
        addTargetWrap("check", False)

        storageModule = self.add(doc, cproject, "storageModule", {"moduleId": "cdtBuildSystem", "version": "4.0.0"})

        project = self.add(doc, storageModule, "project", {"id": "%s.null.1" % appname, "name": appname})

        doc.appendChild(cproject)
        return doc
Beispiel #23
0
class BaseGraph:
    """Abstract base class for all diagramKinds providing base functionallity.
    """

    __computed_results__ = None
    specialAttribName = None

    def __init__(self,
                 data=None,
                 legend=None,
                 colnames=None,
                 title=None,
                 stylesheet=None,
                 errortext=None,
                 otherParams={}):
        "See IDiagramKind.__init__"
        self.data = data
        self.width = otherParams.get('width', 0)
        self.height = otherParams.get('height', 0)
        self.legend = legend
        self.colnames = colnames
        self.gridlines = otherParams.get('gridlines')
        self.fillgaps = otherParams.get('fillgaps')
        self.intcaption = otherParams.get('intcaption')
        self.title = title
        self.stylesheet = stylesheet
        self.errortext = errortext
        self.result = ''

        ##      Achtung: die Koordinaten 0,0 sind im SVG links oben!
        ##        gridbasey   unteres Ende in y-Richtung
        ##        gridboundy  oberes  Ende in y-Richtung
        ##        gridbasey groesser gridboundy!
        ##        gridbasex   unteres (linkes) Ende in x-Richtung
        ##        gridboundx  oberes (rechtes) Ende in x-Richtung
        ##        gridbasex kleiner gridboundx!

        self.gridbasey = self.height - 20
        self.gridboundy = 20
        self.gridbasex = 40
        if self.hasLegend():
            self.gridboundx = self.width - 120
        else:
            self.gridboundx = self.width - 12

    def setSpecialAttrib(self, value):
        """Set the value of the special attribute."""
        self.specialAttrib = value

    def hasLegend(self):
        "Has the graph a legend?"
        return (type(self.legend) in (type([]), type({}))) and self.legend

    def getDom(self):
        self.xmldoc = Document()
        # XXX minidom kann keine customisierte xml-processing instruction
        # XXX also mit umlauten testen, ob 'encoding="UTF-8"' nötig
        ##        xml = self.xmldoc.createProcessingInstruction(
        ##            'xml',
        ##            'version="1.0" encoding="UTF-8"')
        ##        self.xmldoc.appendChild(xml)
        if self.stylesheet:
            style = self.xmldoc.createProcessingInstruction(
                'xml-stylesheet',
                'href="%s" type="text/css"' % self.stylesheet)
            self.xmldoc.appendChild(style)
        svg = self.xmldoc.appendChild(self.xmldoc.createElement("svg"))
        svg.setAttribute('xmlns', "http://www.w3.org/2000/svg")
        svg.setAttribute('xmlns:xlink', "http://www.w3.org/1999/xlink")
        svg.setAttribute('width', str(self.width))
        svg.setAttribute('height', str(self.height))

    def svgHeader(self):
        res = u"""<?xml version="1.0" encoding="UTF-8" ?>\n"""
        if self.stylesheet:
            res += u"""<?xml-stylesheet href="%s" type="text/css"?>\n""" % (
                self.stylesheet)
        return res + """<svg xmlns="http://www.w3.org/2000/svg"
                             xmlns:xlink="http://www.w3.org/1999/xlink"
                             width="%i"
                             height="%i">
                             """ % (self.width, self.height)

    def svgFooter(self):
        return "</svg>"

    def minX(self):
        return self._computeMinMax('minX')

    def realMinX(self):
        return self._computeMinMax('realMinX')

    def minY(self):
        return self._computeMinMax('minY')

    def realMinY(self):
        return self._computeMinMax('realMinY')

    def maxX(self):
        return self._computeMinMax('maxX')

    def realMaxX(self):
        return self._computeMinMax('realMaxX')

    def maxY(self):
        return self._computeMinMax('maxY')

    def realMaxY(self):
        return self._computeMinMax('realMaxY')

    def distValsX(self):
        return self._computeMinMax('distValsX')

    def distValsY(self):
        return self._computeMinMax('distValsY')

    def allX(self):
        return self._computeMinMax('allX')

    def allY(self):
        return self._computeMinMax('allY')

    def numgraphs(self):
        return len(self.data)

    def _compRoundedValMax(self, val):
        """Compute a rounded maximum value."""
        if val == 0:
            return 0
        valBase = 10**(int(log10(abs(val))))
        return valBase * ceil((float(val + valBase / 10.0) / valBase))

    def _compRoundedValMin(self, val):
        """Compute a rounded minimum value."""
        if val == 0:
            return 0
        valBase = 10**(int(log10(abs(val))))
        return valBase * floor((float(val) / valBase) - 1)

    def _getDistinctValues(self, list):
        """Make a list having only distinct values."""
        if not len(list):
            return []
        if type(list[0]) == type(self):  # objects in list
            tmp = list[:]
            res = []
            while (tmp):
                if not tmp[0] in tmp[1:]:
                    res.append(tmp[0])
                del tmp[0]
            return res
        else:
            return dict([(x, 1) for x in list]).keys()

    def _computeMinMax(self, key):
        if self.__computed_results__:
            return self.__computed_results__[key]

        self._testFormatOfData()
        self.__computed_results__ = {}
        cr = self.__computed_results__

        allX = []
        allY = []
        allXfloat = []
        allYfloat = []
        stringInX = stringInY = False
        for dataset in self.data:
            for value in dataset:
                allX.append(value[0])
                if not stringInX:
                    try:
                        allXfloat.append(float(value[0]))
                    except ValueError:
                        stringInX = True
                    if isinstance(value[0], basestring):
                        stringInX = True

                allY.append(value[1])
                if not stringInY:
                    try:
                        allYfloat.append(float(value[1]))
                    except ValueError:
                        stringInY = True
                    if isinstance(value[1], basestring):
                        stringInY = True

        if stringInX:
            cr['realMaxX'] = None
            cr['maxX'] = None
            cr['realMinX'] = None
            cr['minX'] = None
        else:
            cr['realMaxX'] = max(allX)
            cr['maxX'] = self._compRoundedValMax(cr['realMaxX'])
            cr['realMinX'] = min(allX)
            cr['minX'] = self._compRoundedValMin(cr['realMinX'])
            if self.fillgaps:
                cr['distValsX'] = range(cr['realMinX'], cr['realMaxX'] + 1)
            allX = allXfloat

        if stringInY:
            cr['realMaxY'] = None
            cr['maxY'] = None
            cr['realMinY'] = None
            cr['minY'] = None
        else:
            cr['realMaxY'] = max(allY)
            cr['maxY'] = self._compRoundedValMax(cr['realMaxY'])
            cr['realMinY'] = min(allY)
            cr['minY'] = self._compRoundedValMin(cr['realMinY'])
            if self.fillgaps:
                cr['distValsY'] = range(cr['realMinY'], cr['realMaxY'] + 1)
            allY = allYfloat

        cr['allX'] = allX
        cr['allY'] = allY
        if cr.get('distValsX') is None:
            cr['distValsX'] = self._getDistinctValues(allX)
        if cr.get('distValsY') is None:
            cr['distValsY'] = self._getDistinctValues(allY)
        return cr[key]

    def _change_computed_result(self, key, value):
        """Set the value of key in __computed_results__ after computation.

        Use with caution!
        """
        self._computeMinMax(key)
        self.__computed_results__[key] = value

    def _testFormatOfData(self):
        if self.data is None:
            raise RuntimeError, config.SVGrafZ_empty_dataset
        if type(self.data) != ListType:
            raise RuntimeError, 'Data is not a list. Maybe wrong converter.'
        if len(self.data) == 0:
            raise RuntimeError, 'Data is empty.'
        i = 0
        for dataset in self.data:
            i = i + 1
            if type(dataset) != ListType:
                raise RuntimeError, 'Dataset %i is no List.' % i
            if len(dataset) == 0:
                raise RuntimeError, 'Dataset %i is empty.' % i

            j = 0
            for dataItem in dataset:
                j = j + 1
                if type(dataItem) != ListType:
                    raise RuntimeError, 'DataItem %i in Dataset %i is no List.'\
                          % (i,j)
                if len(dataItem) != 2:
                    raise RuntimeError,\
                          'DataItem %i in Dataset %i: More than 2 dimensions.'\
                          % (j,i)
                k = 0
                for dim in dataItem:
                    k = k + 1
                    if type(dim) not in [
                            IntType,
                            LongType,
                            FloatType,
                            StringType,
                            UnicodeType,
                            InstanceType,
                    ]:
                        raise RuntimeError,\
                              'Dimension %i of DataItem %i in Dataset %i: \
                              Not allowed Type of %s.' \
                              % (k,j,i,type(dim))
        return 1

    def _computeGridLines(self, minVal, maxVal, lines, rtype):
        """Compute the variable values for the gridlines.

        minVal ... first grid value
        maxVal ... last grid value
        lines  ... number of lines in grid
        rtype  ... <type 'int'> or <type 'float'> for type of the result values
        """
        if (rtype == int) and ((maxVal - minVal) < lines):
            lines = maxVal - minVal
        ystep = (maxVal - minVal) / rtype(abs(lines) + 1)
        return [rtype(minVal + (y * ystep)) for y in range(1, abs(lines) + 1)]

    def drawXGridLines(self):
        """Draw gridlines in parallel to the y-axis."""
        if not self.gridlines:
            return ''
        if self.intcaption:
            rtype = int
        else:
            rtype = float

        grid = self._computeGridLines(self.minX(), self.maxX(), self.gridlines,
                                      rtype)
        res = '<g id="xGrid">\n'
        for xval in grid:
            res += '<line x1="%s" x2="%s" y1="%s" y2="%s"/>\n' % (
                self.gridbasex + xval * self.xScale, self.gridbasex +
                xval * self.xScale, self.gridbasey, self.gridboundy)
            res += '<text x="%s" y="%s" style="text-anchor: middle;">%s</text>'\
                   % (self.gridbasex + xval * self.xScale,
                      self.gridbasey + 15,
                      self.confLT(xval))
            res += '\n'
        return res + '</g>\n'

    def drawYGridLines(self):
        """Draw gridlines in parallel to the x-axis."""
        if not self.gridlines:
            return ''
        if self.intcaption:
            rtype = int
        else:
            rtype = float

        grid = self._computeGridLines(self.minY(), self.maxY(), self.gridlines,
                                      rtype)
        res = '<g id="yGrid">\n'
        for yval in grid:
            res += '<line x1="%s" x2="%s" y1="%s" y2="%s"/>\n' % (
                self.gridbasex, self.gridboundx, self.gridbasey -
                yval * self.yScale, self.gridbasey - yval * self.yScale)
            res += '<text x="3" y="%s" style="text-anchor: start;">%s</text>'\
                   % (self.gridbasey - yval * self.yScale + 5,
                      self.confLT(yval))
            res += '\n'
        return res + '</g>\n'

    def drawYGridLinesDiscrete(self):
        """Draw gridlines in parallel to the x-axis label it with the discrete values."""
        if not self.gridlines:
            return ''
        if self.intcaption:
            rtype = int
        else:
            rtype = float

        distY = self.distValsY()
        distY.sort()
        grid = self._computeGridLines(self.minY(), self.maxY(), self.gridlines,
                                      rtype)
        res = '<g id="yGrid">\n'
        for yval in grid:
            if yval == 0:
                text = ''
            else:
                text = distY[yval - 1]
            res += '<line x1="%s" x2="%s" y1="%s" y2="%s"/>\n' % (
                self.gridbasex, self.gridboundx, self.gridbasey -
                yval * self.yScale, self.gridbasey - yval * self.yScale)
            res += '<text x="3" y="%s" style="text-anchor: start;">%s</text>'\
                   % (self.gridbasey - yval * self.yScale + 5,
                      self.confLT(text))
            res += '\n'
        return res + '</g>\n'

    def drawXYAxis(self):
        """Draw the x- and y-axis."""
        res = '<g id="xyaxis" style="stroke:#000000; stroke-opacity:1;">\n'
        res += '<line x1="%s" x2="%s" y1="%s" y2="%s"/>\n' % (
            self.gridbasex - 10, self.gridboundx, self.gridbasey,
            self.gridbasey)
        res += '<line x1="%s" x2="%s" y1="%s" y2="%s"/>\n' % (
            self.gridbasex, self.gridbasex, self.gridbasey + 10,
            self.gridboundy)
        return res + '</g>\n'

    def drawTitle(self):
        if not self.title:
            return ''
        res = '<g id="title">\n'
        res += '<text x="%s" y="%s" style="text-anchor: middle;">%s</text>'\
                   % (self.width / 2,
                      self.gridboundy - 4,
                      self.confLT(self.title))
        return res + '\n</g>\n'

    def drawLegend(self):
        """Draw the Legend."""
        if not self.legend:
            return ''
        res = """<g id="legend">
        <text x="%s" y="%s" style="%s">%s</text>
        """ % ((self.gridboundx + self.width) / 2, self.gridboundy + 10,
               'text-anchor: middle; font-weight: bold;',
               config.SVGrafZ_legend_name)
        for i in range(len(self.legend)):
            res += """<line class="%s" x1="%s" x2="%s" y1="%s" y2="%s" stroke-width="10" stroke-linecap="round" stroke="%s" />
            """ % ('dataset%s' %
                   (i), self.width - 5, self.width - 15, self.gridboundy + 26 +
                   (15 * i), self.gridboundy + 26 +
                   (15 * i), config.SVGrafZ_default_Color)
            res += """<text x="%s" y="%s" style="text-anchor:end;">%s</text>"""\
                   % (self.width - 25,
                      self.gridboundy + 30 + (15 * i),
                      self.confLT(self.legend[i]),
                      )
        return res + "\n</g>"

    def printError(self):
        """Print the textual description of an error."""
        res = '''
<g id="SVGrafZicon" transform="translate(%s,%s) scale(2)">
  <g id="icondata">
    <rect style="fill: #ef2715;" x="1" y="11.332" height="2.7" width="8.76864"/>
    <rect style="fill: #ef2715;" x="1" y="4.8" height="2.7" width="4.38432"/>
    <rect style="fill: #131ef4;" x="1" y="8.6328" height="2.7" width="11.6915"/>
    <rect style="fill: #131ef4;" x="1" y="2" height="2.7" width="8.76864"/>
  </g>
  <g id="iconxyaxis" style="stroke:#000000; stroke-opacity:1;">
    <line x1="0" x2="15.68" y1="16" y2="16"/>
    <line x1="1" x2="1" y1="17" y2="0.5328"/>
  </g>
</g>''' % (self.width / 2, (self.gridbasey - self.gridboundy) / 4)

        step = 0
        print ` self.errortext `
        err_txt = u"%s: %s" % (config.SVGrafZ_error_name, self.errortext)
        for errortext in split(self.confLT(err_txt), '\n'):
            res += '<text x="%s" y="%s" font-size="12pt" text-anchor="middle" fill="red">%s</text>' % (
                self.width / 2,
                (self.gridbasey - self.gridboundy) / 2 + step, errortext)
            step += 20
        return res

    def xAxis_verticalLabels(self, labels, firstWidth, xWidth):
        """Print the labels on x-axis vertically.

        labels     ... list of strings with labelnames, if self.colnames
                         exists, then it is taken instead
        firstWidth ... float points from self.gridbasex to first label
        xWidth     ... float points between labels
        """
        if self.colnames:  # use colnames, if given
            labels = self.colnames
        res = ''
        for i in range(len(labels)):
            label = labels[i]
            res += '''<defs>
            <path d="M %s %s V 15" id="xAxisLabel%s"/>
            </defs>\n
            <text>
            <textPath xlink:href="#xAxisLabel%s">%s</textPath>
            </text>\n''' % (firstWidth + i * xWidth + 2, self.height - 2, i, i,
                            self.confLT(str(label)))
        return res

    def xAxis_diagonalLabels(self, labels, firstWidth, xWidth, withLines=0):
        """Print labels on x-axis diagonally from bottom-left to upper-right.

        labels     ... list of strings with labelnames, if self.colnames
                         exists, then it is taken instead
        firstWidth ... float points from self.gridbasex to first label
        xWidth     ... float points between labels
        withLines  ... if withLines: draw lines in parallel to y-axis
        """
        if self.colnames:  # use colnames, if given
            labels = self.colnames
        res = ''
        diff = self.height - self.gridbasey
        for i in range(len(labels)):
            label = labels[i]
            res += '''<defs>
            <path d="M %s %s l 600 600" id="xAxisLabel%s"/>
            </defs>\n
            <text style="text-anchor: start;">
            <textPath xlink:href="#xAxisLabel%s">%s</textPath>
            </text>\n''' % (firstWidth + i * xWidth - 7, self.gridbasey + 7, i,
                            i, self.confLT(str(label)))
            ##            res += '<line x1="%s" x2="%s" y1="%s" y2="%s" />\n' % (
            ##                firstWidth + i * xWidth - 7,
            ##                firstWidth + i * xWidth + 600 -7 ,
            ##                self.gridbasey + 7,
            ##                self.gridbasey + 607,
            ##                )
            if withLines:
                res += '<line x1="%s" x2="%s" y1="%s" y2="%s" />\n' % (
                    firstWidth + i * xWidth,
                    firstWidth + i * xWidth,
                    self.gridbasey,
                    self.gridboundy,
                )
        return res

    def yAxis_horizontalLabels(self, labels, firstHeight, yHeight):
        """Print horizontal Labels on yAxis.

        labels      ... list: of strings with labelnames, if self.colnames
                         exists, then it is taken instead
        firstHeight ... float: points from self.gridbasey to first label
        yHeight     ... float: points between labels
        """
        res = ''
        if self.colnames:  # use colnames, if given
            labels = self.colnames
        for i in range(len(labels)):
            label = labels[i]
            res += '''<text x="5" y="%s" style="text-anchor:start;">
                        <tspan baseline-shift="sub">%s</tspan>
                       </text>\n''' % (self.gridbasey - i * yHeight -
                                       firstHeight, self.confLT(label))
        return res

    def compute(self):
        """Compute the Diagram."""
        if self.result:
            return self.result

        if usedom:
            self.getDom()
            return self.xmldoc.toxml()
        # else: not usedom
        self.result = self.svgHeader()
        if self.errortext:
            self.result += self.printError()
        else:
            try:
                for action in self.getDrawingActions():
                    self.result += action()
            except RuntimeError:
                import sys
                self.errortext = sys.exc_info()[1].args[0]
                self.result = self.svgHeader() + self.printError()

        self.result += self.svgFooter()
        return self.result

    def computeYScale(self):
        """Compute scaling factor for y-direction."""
        if self.maxY() is None:
            raise RuntimeError, 'All values on y-axis must be numbers!'
        self.specialAttribHook()

        difY = float(self.maxY() - self.minY())
        if difY:
            self.yScale = float((self.gridbasey - self.gridboundy) / difY)
        else:
            self.yScale = 1.0
        return ''

    def computeXScale(self):
        """Compute scaling factor for x-direction."""
        if self.maxX() is None:
            raise RuntimeError, 'All values on x-axis must be numbers!'
        self.specialAttribHook()

        difX = float(self.maxX() - self.minX())
        if difX:
            self.xScale = float((self.gridboundx - self.gridbasex) / difX)
        else:
            self.xScale = 1.0
        return ''

    def confLT(self, text):
        """Convert the less than symbols in text ('<') to &lt;."""
        if type(text) in StringTypes:
            return text.replace("<", "&lt;")
        return text

    def getDrawingActions(self):
        """Returns the methods which are used to draw the graph."""
        return [
            self.drawGraph, self.drawXYAxis, self.drawLegend, self.drawTitle
        ]

    def drawGraph(self):
        "Abstract Method: Draw the the graph and name the columns."
        raise RuntimeError, "Can't use the abstract method drawGraph!"
Beispiel #24
0
    def impl_create_cproject(self,
                             executable,
                             waf_executable,
                             appname,
                             workspace_includes,
                             cpppath,
                             source_dirs=[]):
        doc = Document()
        doc.appendChild(doc.createProcessingInstruction(
            "fileVersion", "4.0.0"))
        cconf_id = cdt_core + ".default.config.1"
        cproject = doc.createElement("cproject")
        storageModule = self.add(doc, cproject, "storageModule",
                                 {"moduleId": cdt_core + ".settings"})
        cconf = self.add(doc, storageModule, "cconfiguration",
                         {"id": cconf_id})

        storageModule = self.add(
            doc,
            cconf,
            "storageModule",
            {
                "buildSystemId":
                oe_cdt + ".managedbuilder.core.configurationDataProvider",
                "id": cconf_id,
                "moduleId": cdt_core + ".settings",
                "name": "Default",
            },
        )

        self.add(doc, storageModule, "externalSettings")

        extensions = self.add(doc, storageModule, "extensions")
        extension_list = """
			VCErrorParser
			MakeErrorParser
			GCCErrorParser
			GASErrorParser
			GLDErrorParser
		""".split()
        self.add(
            doc,
            extensions,
            "extension",
            {
                "id": cdt_core + ".ELF",
                "point": cdt_core + ".BinaryParser"
            },
        )
        for e in extension_list:
            self.add(
                doc,
                extensions,
                "extension",
                {
                    "id": cdt_core + "." + e,
                    "point": cdt_core + ".ErrorParser"
                },
            )

        storageModule = self.add(doc, cconf, "storageModule", {
            "moduleId": "cdtBuildSystem",
            "version": "4.0.0"
        })
        config = self.add(
            doc,
            storageModule,
            "configuration",
            {
                "artifactName": appname,
                "id": cconf_id,
                "name": "Default",
                "parent": cdt_bld + ".prefbase.cfg",
            },
        )
        folderInfo = self.add(doc, config, "folderInfo", {
            "id": cconf_id + ".",
            "name": "/",
            "resourcePath": ""
        })

        toolChain = self.add(
            doc,
            folderInfo,
            "toolChain",
            {
                "id": cdt_bld + ".prefbase.toolchain.1",
                "name": "No ToolChain",
                "resourceTypeBasedDiscovery": "false",
                "superClass": cdt_bld + ".prefbase.toolchain",
            },
        )

        self.add(
            doc,
            toolChain,
            "targetPlatform",
            {
                "binaryParser": "org.eclipse.cdt.core.ELF",
                "id": cdt_bld + ".prefbase.toolchain.1",
                "name": "",
            },
        )

        waf_build = f'"{waf_executable}" {eclipse.fun}'
        waf_clean = '"%s" clean' % (waf_executable)
        self.add(
            doc,
            toolChain,
            "builder",
            {
                "autoBuildTarget": waf_build,
                "command": executable,
                "enableAutoBuild": "false",
                "cleanBuildTarget": waf_clean,
                "enableIncrementalBuild": "true",
                "id": cdt_bld + ".settings.default.builder.1",
                "incrementalBuildTarget": waf_build,
                "managedBuildOn": "false",
                "name": "Gnu Make Builder",
                "superClass": cdt_bld + ".settings.default.builder",
            },
        )

        tool_index = 1
        for tool_name in ("Assembly", "GNU C++", "GNU C"):
            tool = self.add(
                doc,
                toolChain,
                "tool",
                {
                    "id": cdt_bld + ".settings.holder." + str(tool_index),
                    "name": tool_name,
                    "superClass": cdt_bld + ".settings.holder",
                },
            )
            if cpppath or workspace_includes:
                incpaths = cdt_bld + ".settings.holder.incpaths"
                option = self.add(
                    doc,
                    tool,
                    "option",
                    {
                        "id": incpaths + "." + str(tool_index),
                        "name": "Include Paths",
                        "superClass": incpaths,
                        "valueType": "includePath",
                    },
                )
                for i in workspace_includes:
                    self.add(
                        doc,
                        option,
                        "listOptionValue",
                        {
                            "builtIn": "false",
                            "value": f'"${{workspace_loc:/{appname}/{i}}}"'
                        },
                    )
                for i in cpppath:
                    self.add(doc, option, "listOptionValue", {
                        "builtIn": "false",
                        "value": '"%s"' % (i)
                    })
            if tool_name == "GNU C++" or tool_name == "GNU C":
                self.add(
                    doc,
                    tool,
                    "inputType",
                    {
                        "id":
                        "org.eclipse.cdt.build.core.settings.holder.inType." +
                        str(tool_index),
                        "languageId":
                        "org.eclipse.cdt.core.gcc" if tool_name == "GNU C" else
                        "org.eclipse.cdt.core.g++",
                        "languageName":
                        tool_name,
                        "sourceContentType":
                        "org.eclipse.cdt.core.cSource,org.eclipse.cdt.core.cHeader",
                        "superClass":
                        "org.eclipse.cdt.build.core.settings.holder.inType",
                    },
                )
            tool_index += 1

        if source_dirs:
            sourceEntries = self.add(doc, config, "sourceEntries")
            for i in source_dirs:
                self.add(
                    doc,
                    sourceEntries,
                    "entry",
                    {
                        "excluding": i,
                        "flags": "VALUE_WORKSPACE_PATH|RESOLVED",
                        "kind": "sourcePath",
                        "name": "",
                    },
                )
                self.add(
                    doc,
                    sourceEntries,
                    "entry",
                    {
                        "flags": "VALUE_WORKSPACE_PATH|RESOLVED",
                        "kind": "sourcePath",
                        "name": i
                    },
                )

        storageModule = self.add(doc, cconf, "storageModule",
                                 {"moduleId": cdt_mk + ".buildtargets"})
        buildTargets = self.add(doc, storageModule, "buildTargets")

        def addTargetWrap(name, runAll):
            return self.addTarget(doc, buildTargets, executable, name,
                                  f'"{waf_executable}" {name}', runAll)

        addTargetWrap("configure", True)
        addTargetWrap("dist", False)
        addTargetWrap("install", False)
        addTargetWrap("check", False)

        storageModule = self.add(doc, cproject, "storageModule", {
            "moduleId": "cdtBuildSystem",
            "version": "4.0.0"
        })

        self.add(doc, storageModule, "project", {
            "id": "%s.null.1" % appname,
            "name": appname
        })

        doc.appendChild(cproject)
        return doc
Beispiel #25
0
class Xul(object):
    """This is the base xul element which all
    other elements inherit from. Also is used
    as the base container for the document
    >>> x = Xul(); x+=Window(); print x
    <?xml version="1.0" ?>
    <?xml-stylesheet type="text/css" href="chrome://global/skin"?>
    <window height="600" title="Xul Application" width="800" xmlns="\
http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" \
xmlns:html="http://www.w3.org/1999/xhtml"/>
    <BLANKLINE>
    """
    def __init__(self, element=None, kwargs=None, addprop=None):
        """This is a init function that is used to initilize common
        thing across the different children.
        """
        self._properties = { "align": "string", "allowevents": "string", 
        "allownegativeassertions": "string", "eclass": "string", 
        "class": "string", "coalesceduplicatearcs": "string", 
        "collapsed": "string", "container": "string", 
        "containment": "string", "context": "string", 
        "contextmenu": "string", "datasources": "string", 
        "dir": "string", "edir": "string", "empty": "string", 
        "equalsize": "string", "flags": "string", "flex": "string", 
        "height": "string", "hidden": "string", "eid": "string", 
        "id": "string", "insertafter": "string", "insertbefore": "string", 
        "left": "string", "maxheight": "string", "maxwidth": "string", 
        "menu": "string", "minheight": "string", "minwidth": "string", 
        "mousethrough": "string", "observes": "string", "ordinal": "string",
        "orient": "string", "pack": "string", "persist": "string", 
        "popup": "string", "position": "string", 
        "preference-editable": "string", "querytype": "string", 
        "ref": "string", "removeelement": "string", 
        "sortDirection": "string", "sortResource": "string", 
        "sortResource2": "string", "statustext": "string", "style": "string", 
        "template": "string", "tooltip": "string", "tooltiptext": "string", 
        "top": "string", "uri": "string", "wait-cursor": "string", 
        "width": "string", "xmlns": "string", "xmlns:html": "string" } 
        if(addprop):
            self._properties = dict(self._properties, **addprop)
        self._doc = Document()
        type(self).__name__="xulelement"
        if(element):
            self._element = self._doc.createElement(element)
        else:
            self._element = self._doc
            self._doc.appendChild(self._doc.createProcessingInstruction(\
            "xml-stylesheet","type=\"text/css\" href=\"chrome://global/skin\""))
        if(kwargs):
            for key in kwargs:
                if(key=="eid"):
                    self.__setattr__("id", kwargs[key])
                elif(key=="eclass"):
                    self.__setattr__("class", kwargs[key])
                elif(key=="eopen"):
                    self.__setattr__("open", kwargs[key])
                elif(key=="etype"):
                    self.__setattr__("type", kwargs[key])
                elif(key=="edir"):
                    self.__setattr__("dir", kwargs[key])
                else:
                    self.__setattr__(key, kwargs[key])
    def __setattr__(self, name, value):
        if name in self.__dict__ or name in ["_element", "_doc", 
                                             "_properties"]:
            super(Xul, self).__setattr__(name, value)
        else:
            element = self.getelement() 
            if STRICT:
                if name in self._properties:
                    element.setAttribute(str(name), str(value))
                else:
                    raise StrictError("Your trying to add an attribute that \
is not supported by the element")
            else:
                element.setAttribute(str(name), str(value))

    def __getattr__(self, name):
        if name in self.__dict__:
            super(Xul, self).__getattr__(name)
        else:
            element = self.getelement()
            ret = Attribute(name, element.getAttribute(name))
            return ret
    def _adder(self, other, parent):
        """This is a helper function so it's possible to go
        recursively through adding elements"""
        if(self == other):
            raise SelfReference('Your adding your self') 
        if type(other).__name__=="list" or type(other).__name__=="List":
            last = None
            for other_element in other:
                if type(other_element).__name__=="list":
                    if(last):
                        self._adder(other_element, last)
                        last = List(other_element)
                        last.parent = parent
                    else:
                        raise EmptyList("You cant start with two lists")
                elif type(other_element).__name__=="str" or \
                     type(other).__name__=="int":
                    cdata = CDATASection()
                    cdata.data = str(other_element)
                    element = parent.getelement()
                    element.appendChild(cdata)
                    last = other_element
                elif type(other_element).__name__=="xulelement":
                    if type(parent).__name__=="List":
                        if parent.parent:
                            element = parent.parent.getelement()
                            eelement = other_element.getelement()
                            element.appendChild(eelement)
                            last = other_element 
                        else:
                            raise ParentList(\
                                  "You can't have list as an parent")
                    elif type(parent).__name__=="list":
                        raise ParentList(\
                              "You can't have list as an parent")
                    else:
                        element = parent.getelement()
                        eelement = other_element.getelement()
                        element.appendChild(eelement)
                        last = other_element
                else:
                    print("What is happening")
                    print("type: "+type(other).__name__)
        elif type(other).__name__=="str" or type(other).__name__=="int":
            cdata = CDATASection()
            cdata.data = str(other)
            element = parent.getelement() 
            element.appendChild(cdata)
        elif type(other).__name__=="xulelement":
            element = parent.getelement()
            oelement = other.getelement()
            element.appendChild(oelement)
        else:
            print("What is happening")
            print("type: "+type(other).__name__)

    def __iadd__(self, other):
        self._adder(other, self)
        return self
    def __str__(self):
        element = self.getelement()
        return element.toprettyxml(indent="  ")
    def __repr__(self):
        return self.__str__()
    def getelement(self):
        """This returns the xml element to you
        so you can change it.
        """
        return self._element
Beispiel #26
0
    def impl_create_cproject(self,
                             executable,
                             waf,
                             appname,
                             workspace_includes,
                             cpppath,
                             source_dirs=[]):
        doc = Document()
        doc.appendChild(doc.createProcessingInstruction(
            'fileVersion', '4.0.0'))
        cconf_id = cdt_core + '.default.config.1'
        cproject = doc.createElement('cproject')
        storageModule = self.add(doc, cproject, 'storageModule',
                                 {'moduleId': cdt_core + '.settings'})
        cconf = self.add(doc, storageModule, 'cconfiguration',
                         {'id': cconf_id})

        storageModule = self.add(
            doc, cconf, 'storageModule', {
                'buildSystemId':
                oe_cdt + '.managedbuilder.core.configurationDataProvider',
                'id': cconf_id,
                'moduleId': cdt_core + '.settings',
                'name': 'Default'
            })

        self.add(doc, storageModule, 'externalSettings')

        extensions = self.add(doc, storageModule, 'extensions')
        extension_list = """
			VCErrorParser
			MakeErrorParser
			GCCErrorParser
			GASErrorParser
			GLDErrorParser
		""".split()
        ext = self.add(doc, extensions, 'extension', {
            'id': cdt_core + '.ELF',
            'point': cdt_core + '.BinaryParser'
        })
        for e in extension_list:
            ext = self.add(doc, extensions, 'extension', {
                'id': cdt_core + '.' + e,
                'point': cdt_core + '.ErrorParser'
            })

        storageModule = self.add(doc, cconf, 'storageModule', {
            'moduleId': 'cdtBuildSystem',
            'version': '4.0.0'
        })
        config = self.add(
            doc, storageModule, 'configuration', {
                'artifactName': appname,
                'id': cconf_id,
                'name': 'Default',
                'parent': cdt_bld + '.prefbase.cfg'
            })
        folderInfo = self.add(doc, config, 'folderInfo', {
            'id': cconf_id + '.',
            'name': '/',
            'resourcePath': ''
        })

        toolChain = self.add(
            doc, folderInfo, 'toolChain', {
                'id': cdt_bld + '.prefbase.toolchain.1',
                'name': 'No ToolChain',
                'resourceTypeBasedDiscovery': 'false',
                'superClass': cdt_bld + '.prefbase.toolchain'
            })

        targetPlatform = self.add(
            doc, toolChain, 'targetPlatform', {
                'binaryParser': 'org.eclipse.cdt.core.ELF',
                'id': cdt_bld + '.prefbase.toolchain.1',
                'name': ''
            })

        waf_build = 'waf %s' % (eclipse.fun)
        waf_clean = 'waf clean'
        builder = self.add(
            doc, toolChain, 'builder', {
                'autoBuildTarget': waf_build,
                'command': executable,
                'enableAutoBuild': 'false',
                'cleanBuildTarget': waf_clean,
                'enableIncrementalBuild': 'true',
                'id': cdt_bld + '.settings.default.builder.1',
                'incrementalBuildTarget': waf_build,
                'managedBuildOn': 'false',
                'name': 'Gnu Make Builder',
                'superClass': cdt_bld + '.settings.default.builder'
            })

        for tool_name in ("Assembly", "GNU C", "GNU C++"):
            tool = self.add(
                doc, toolChain, 'tool', {
                    'id': cdt_bld + '.settings.holder.1',
                    'name': tool_name,
                    'superClass': cdt_bld + '.settings.holder'
                })
            if cpppath or workspace_includes:
                incpaths = cdt_bld + '.settings.holder.incpaths'
                option = self.add(
                    doc, tool, 'option', {
                        'id': incpaths + '.1',
                        'name': 'Include Paths',
                        'superClass': incpaths,
                        'valueType': 'includePath'
                    })
                for i in workspace_includes:
                    self.add(
                        doc, option, 'listOptionValue', {
                            'builtIn': 'false',
                            'value': '"${workspace_loc:/%s}"' % (i)
                        })
                for i in cpppath:
                    self.add(doc, option, 'listOptionValue', {
                        'builtIn': 'false',
                        'value': '"%s"' % (i)
                    })

            if tool_name == "Assembly":
                input_type = self.add(
                    doc, tool, 'inputType', {
                        'id': cdt_bld + '.settings.holder.inType.1',
                        'languageId': 'org.eclipse.cdt.core.assembly',
                        'languageName': 'Assembly',
                        'sourceContentType': 'org.eclipse.cdt.core.asmSource',
                        'superClass': cdt_bld + 'settings.holder.inType'
                    })

            if tool_name == "GNU C":
                input_type = self.add(
                    doc, tool, 'inputType', {
                        'id': cdt_bld + '.settings.holder.inType.2',
                        'languageId': 'org.eclipse.cdt.core.gcc',
                        'languageName': 'GNU C',
                        'sourceContentType':
                        'org.eclipse.cdt.core.cSource,org.eclipse.cdt.core.cHeader',
                        'superClass': cdt_bld + 'settings.holder.inType'
                    })

            if tool_name == "GNU C++":
                input_type = self.add(
                    doc, tool, 'inputType', {
                        'id': cdt_bld + '.settings.holder.inType.3',
                        'languageId': 'org.eclipse.cdt.core.g++',
                        'languageName': 'GNU C++',
                        'sourceContentType':
                        'org.eclipse.cdt.core.cxxSource,org.eclipse.cdt.core.cxxHeader',
                        'superClass': cdt_bld + 'settings.holder.inType'
                    })

        if source_dirs:
            sourceEntries = self.add(doc, config, 'sourceEntries')
            for i in source_dirs:
                self.add(
                    doc, sourceEntries, 'entry', {
                        'excluding': i,
                        'flags': 'VALUE_WORKSPACE_PATH|RESOLVED',
                        'kind': 'sourcePath',
                        'name': ''
                    })
                self.add(
                    doc, sourceEntries, 'entry', {
                        'flags': 'VALUE_WORKSPACE_PATH|RESOLVED',
                        'kind': 'sourcePath',
                        'name': i
                    })

        storageModule = self.add(doc, cconf, 'storageModule',
                                 {'moduleId': cdt_mk + '.buildtargets'})
        buildTargets = self.add(doc, storageModule, 'buildTargets')

        def addTargetWrap(name, runAll):
            return self.addTarget(doc, buildTargets, executable, name,
                                  'waf %s' % (name), runAll)

        addTargetWrap('configure', True)
        addTargetWrap('dist', False)
        addTargetWrap('install', False)
        addTargetWrap('check', False)

        storageModule = self.add(doc, cproject, 'storageModule', {
            'moduleId': 'cdtBuildSystem',
            'version': '4.0.0'
        })

        project = self.add(doc, storageModule, 'project', {
            'id': '%s.null.1' % appname,
            'name': appname
        })
        # Add DoxyGen comment parser
        storageModule = self.add(
            doc, cproject, 'storageModule', {
                'moduleId':
                'org.eclipse.cdt.internal.ui.text.commentOwnerProjectMappings'
            })
        docCommentOwner = self.add(doc, storageModule, 'doc-comment-owner',
                                   {'id': 'org.eclipse.cdt.ui.doxygen'})
        path = self.add(doc, docCommentOwner, 'path', {'value': ''})

        # Add scanner info generator
        storageModule = self.add(doc, cproject, 'storageModule',
                                 {'moduleId': 'scannerConfiguration'})
        self.add(
            doc, storageModule, 'autodiscovery', {
                'enabled':
                'true',
                'problemReportingEnabled':
                'true',
                'selectedProfileId':
                'org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile'
            })
        scannerConfigBuildInfo = self.add(doc, storageModule,
                                          'scannerConfigBuildInfo',
                                          {'instanceId': cconf_id})
        self.add(
            doc, scannerConfigBuildInfo, 'autodiscovery', {
                'enabled':
                'true',
                'problemReportingEnabled':
                'true',
                'selectedProfileId':
                'org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile'
            })
        profile = self.add(doc, scannerConfigBuildInfo, 'profile', {
            'id':
            'org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile'
        })
        buildOutputProvider = self.add(doc, profile, 'buildOutputProvider', {})
        self.add(doc, buildOutputProvider, 'openAction', {
            'enabled': 'true',
            'filePath': ''
        })
        self.add(doc, buildOutputProvider, 'parser', {'enabled': 'true'})
        scannerInfoProvider = self.add(doc, profile, 'scannerInfoProvider',
                                       {'id': 'specsFile'})

        # Generate compiler string
        if type(self.env.CC) == list:
            cc_str = self.env.CC[0]
        else:
            cc_str = self.env.CC

        # Generate CFLAGS
        ccflags_str = ''
        for flag in self.env.CFLAGS:
            ccflags_str = ccflags_str + ' ' + flag

        self.add(
            doc, scannerInfoProvider, 'runAction', {
                'arguments': ccflags_str +
                ' -E -P -v -dD ${plugin_state_location}/${specs_file}',
                'command': cc_str,
                'useDefault': 'true'
            })
        self.add(doc, scannerInfoProvider, 'parser', {'enabled': 'true'})

        # Generate list of sources
        sources = list()
        for group in self.groups:
            for task in group:
                #print(task)
                #print(task.source)
                sources += task.source

        files = self.srcnode.ant_glob('**/*.c', excl='/build')
        files = filter(lambda x: x not in sources, files)

        #print(sources)
        #print(len(sources))
        #print(files)
        #print(len(files))

        excludes = '|'.join([fil.nice_path() for fil in files])

        sourceEntries = self.add(doc, config, 'sourceEntries', {})
        self.add(
            doc, sourceEntries, 'entry', {
                'excluding': excludes,
                'flags': 'VALUE_WORKSPACE_PATH',
                'kind': 'sourcePath',
                'name': ''
            })

        doc.appendChild(cproject)
        return doc