FCL/sftools/depl/swconfigmdw: comparison configurationengine/source/plugins/symbian/ConeProjectConverterPlugin/projectconvertplugin/convertproject.py

equal deleted inserted replaced

-:87cfa131b535
+:e7e0ae78773e
 import sys
 import logging
 import xml.parsers.expat
 import shutil
 import fnmatch
+import pkg_resources
+import types
 try:
 from cElementTree import ElementTree
 except ImportError:
 try:
 """
 Generate the given implementation.
 """
 #Generating content
-fullOutputPath = self.output
+fullOutputPath = os.path.join(context.output, self.output)
 if self.project_data.has_key("path"):
 targetPath = utils.resourceref.norm(self.project_data["path"])
 if targetPath and targetPath != "":
-fullOutputPath = os.path.join(fullOutputPath, targetPath)
+fullOutputPath = os.path.join(context.output, fullOutputPath, targetPath)
 fs = filestorage.FileStorage(fullOutputPath, "w")
 newProject = api.Project(fs)
 for layer in self.layers:
 layer.generate(newProject, self.configuration.get_storage().get_path())
 class ConvertProjectLayer(object):
 """
 Object presenting layer in convertprojectml file.
 """
-def __init__(self, path):
+def __init__(self, path, configuration):
 if path != None:
 self.path = path
 else:
 self.path = ""
 self.folders = []
 self.files = []
+self.source_configuration = configuration
 def __str__(self):
 retStr = ""
 retStr += "\nPath: %s\n" % self.path
 retStr +="Folders:\n"
 def addFile(self, file):
 self.files.append(file)
 def getProjectPath(self):
 return self.path
+def solve_ref(self, inputdata):
+"""
+Internal function to solve whether input is ref or just normal input string.
+For refs actual ConfML value is resolved and returned. Non-refs are returned
+as such.
+"""
+dview = self.source_configuration.get_default_view()
+if inputdata and isinstance(inputdata, types.StringType):
+return utils.expand_refs_by_default_view(inputdata, dview)
+elif inputdata and isinstance(inputdata, types.DictType):
+retDict = {}
+for key in inputdata:
+retDict[self.solve_ref(key)] = self.solve_ref(inputdata[key])
+return retDict
+else:
+return inputdata
 class ConvertProjectFolder(object):
 """
 Object presenting folder in convertprojectml file.
 """
 def addFilter(self, filter):
 self.filters.append(filter)
 def getProjectPath(self):
 return os.path.join(self.parent.getProjectPath(), self.path)
+def solve_ref(self, inputdata):
+return self.parent.solve_ref(inputdata)
 class ConvertProjectFile(object):
 """
 Object presenting file in convertprojectml file.
 """
 def __init__(self, path, type, parent=None):
 if path != None:
 self.path = path
 else:
 self.path = ""
-if type != None:
+if type != None and type != "none":
 self.type = type
 else:
 self.type = ""
 self.filters = []
 self.parent = parent
 self.meta = []
 self.desc = ""
+self.configuration_name = ""
 def __str__(self):
 retStr = ""
 retStr += "\tPath: %s\n" % self.path
 retStr += "\tType: %s\n" % self.type
 def generate(self, project, old_structure_root):
 for filter in self.filters:
 filter.generate(project, old_structure_root, self.type)
-if self.type == "configuration_root":
+if self.type:
-#Adding metadata
+config = project.get_configuration(utils.resourceref.norm(self.getProjectPath()))
-config = project.get_configuration(utils.resourceref.norm(self.path))
 if self.meta:
 if not config.meta:
 config.meta = []
 for meta in self.meta:
-config.meta.add(meta[0], meta[1], meta[2], meta[3])
+config.meta.set_property_by_tag(self.solve_ref(meta[0]), \
+self.solve_ref(meta[1]), \
+self.solve_ref(meta[2]), \
+self.solve_ref(meta[3]))
 if self.desc:
 config.desc = self.desc
-config.save()
+if self.configuration_name:
+config.set_name(self.configuration_name)
+config.save()
 return
 def addFilter(self, filter):
 self.filters.append(filter)
 def addMeta(self, meta):
 self.meta = meta
 def addDescription(self, desc):
 self.desc = desc
+def addConfigurationName(self, configuration_name):
+self.configuration_name = configuration_name
 def getProjectPath(self):
-return os.path.join(self.parent.getProjectPath(), self.path)
+if self.type == "configuration_root":
+return self.path
+else:
+return os.path.join(self.parent.getProjectPath(), self.path)
+def solve_ref(self, inputdata):
+return self.parent.solve_ref(inputdata)
 class ConvertProjectFilter(object):
 """
 Object presenting filter in convertprojectml file.
 """
 else:
 self.remove_includes = "false"
 if recursive:
 self.recursive = recursive
 else:
 self.recursive = "false"
 def __str__(self):
 retStr = ""
 retStr += "\t\tAction: %s\n" % self.action
 retStr += "\t\tData: %s\n" % self.data
 return os.path.join(project.get_storage().get_path(), self.getProjectPath())
 else:
 retPath = os.path.join(project.get_storage().get_path(), self.getProjectPath())
 startFound = 0
-for item in os.path.normpath(filepath).split("\\"):
+parts = filter(lambda p: p != '',
+os.path.normpath(filepath).replace('\\', '/').split('/'))
+for item in parts:
 if self.data.find(item) != -1:
 startFound = 1
 if startFound and self.data.find(item) == -1:
 retPath = os.path.join(retPath, item)
 return os.path.split(retPath)[0]
 #Need to handle wildcard part
 fullSearchPath = os.path.join(project.get_storage().get_path(), self.getProjectPath(), pathPart)
 filesToProcess = self.getFilesByWildcard(fullSearchPath, wildCardPart, project)
 #Creating rootfile.
 rootFilePath = os.path.join(self.getProjectPath(), self.parent.path)
-config = project.create_configuration(utils.resourceref.norm(rootFilePath))
+if project.is_configuration(utils.resourceref.norm(rootFilePath)):
+config = project.get_configuration(utils.resourceref.norm(rootFilePath))
+else:
+config = project.create_configuration(utils.resourceref.norm(rootFilePath))
 #Adding defined includes.
 for f in filesToProcess:
 source = f["source"]
 #Getting path in configuration project and adding it as include.
 def handleConfigurationRoot(self, project):
 """
 """
 #Always in the root of the project
 configname = utils.resourceref.norm(self.parent.path)
-if configname in project.list_configurations():
+if project.is_configuration(utils.resourceref.norm(self.parent.path)):
 config = project.get_configuration(configname)
 else:
 config = project.create_configuration(utils.resourceref.norm(self.parent.path))
 config.include_configuration(utils.resourceref.norm(self.data))
 config.save()
 if self.recursive == "false" and os.path.normpath(root) != os.path.normpath(folder):
 #No recursive search used and therefore only topmost directory is handled.
 continue
 else:
 for f in files:
+if wildcard and wildcard[0] != "*":
+#Matches path part.
+wildcard = "*%s" % wildcard
 if fnmatch.fnmatch(os.path.join(root, f), wildcard):
 source = os.path.join(root, f)
 targetDir = self.resolveTargetDir(project, source)
 retArray.append({"source": source, "targetDir": targetDir})
 #Some wildcards found. Wildcards are supported only in the last segment.
 pathPart, wildCardPart = os.path.split(data)
 return pathPart, wildCardPart
+def solve_ref(self, inputdata):
+return self.parent.solve_ref(inputdata)
 #=================================================================
 class ConvertProjectReader(plugin.ReaderBase):
 """
 Parses a single convertprojectml  file
 """
 NAMESPACE = 'http://www.s60.com/xml/convertprojectml/1'
+NAMESPACE_ID = 'convertprojectml'
+ROOT_ELEMENT_NAME = 'convertprojectml'
 FILE_EXTENSIONS = ['convertprojectml']
 def __init__(self):
 self.desc = None
 self.output_dir = None
 self.layers = []
 @classmethod
 def read_impl(cls, resource_ref, configuration, etree):
 reader = ConvertProjectReader()
-reader.from_etree(etree, configuration.get_storage().get_path())
+reader.from_etree(etree, configuration, configuration.get_storage().get_path())
 impl = ConvertProjectImpl(resource_ref, configuration)
 impl.project_data   = reader.project_data
 impl.layers         = reader.layers
 return impl
-def from_etree(self, etree, old_structure_root = ""):
+@classmethod
-self.project_data = self.parse_attributes(etree, "targetProject")
+def get_schema_data(cls):
-self.layers = self.parse_layers(etree)
+return pkg_resources.resource_string('projectconvertplugin', 'xsd/convertprojectml.xsd')
-for fe in self.parse_foreach(etree, old_structure_root):
-self.layers.append(fe)
+def from_etree(self, etree, configuration, old_structure_root = ""):
+self.configuration = configuration
-#for l in self.layers:
-#print l
+for element in etree:
-return
+if element.tag == "{http://www.s60.com/xml/convertprojectml/1}targetProject":
+self.project_data = self.parse_attributes(etree, "targetProject")
+elif element.tag == "{http://www.s60.com/xml/convertprojectml/1}layer":
+self.layers.append(self.parse_layer(element))
+elif element.tag == "{http://www.s60.com/xml/convertprojectml/1}foreach":
+for fe in self.parse_foreach(element, old_structure_root):
+self.layers.append(fe)
+return
 def parse_foreach(self, etree, old_structure_root):
 layersTmp = []
-for fe in etree.findall("{%s}foreach" % self.namespaces[0]):
+variable = etree.get("variable")
-variable = fe.get("variable")
+data = self.handleMapping(etree.get("data"), {})
-data = fe.get("data")
+folders = []
-folders = []
+for item in os.listdir(os.path.join(old_structure_root, data)):
-for item in os.listdir(os.path.join(old_structure_root, data)):
+if os.path.isdir(os.path.join(old_structure_root, data, item)) and item != '.svn':
-if os.path.isdir(os.path.join(old_structure_root, data, item)) and item != '.svn':
+folders.append(item)
-folders.append(item)
+for folder in folders:
-for folder in folders:
+mapping_data = {variable: folder}
-mapping_data = {variable: folder}
+for layer in etree.findall("{%s}layer" % self.namespaces[0]):
-for layer in fe.findall("{%s}layer" % self.namespaces[0]):
+layersTmp.append(self.parse_layer(layer, mapping_data))
-layersTmp.append(self.parse_layer(layer, mapping_data))
 return layersTmp
-def parse_layers(self,etree):
-layersTmp = []
-for layer in etree.findall("{%s}layer" % self.namespaces[0]):
-layersTmp.append(self.parse_layer(layer))
-return layersTmp
 def parse_layer(self, etree, mapping_data=None):
 path = self.handleMapping(etree.get("path"), mapping_data)
-layerObject = ConvertProjectLayer(path)
+layerObject = ConvertProjectLayer(path, self.configuration)
 for folder in etree.findall("{%s}folder" % self.namespaces[0]):
 layerObject.addFolder(self.parse_folder(folder, layerObject, mapping_data))
 for f in etree.findall("{%s}file" % self.namespaces[0]):
 layerObject.addFile(self.parse_file(f, layerObject, mapping_data))
 return folderObject
 def parse_file(self, etree, parent, mapping_data=None):
 path = self.handleMapping(etree.get("path"), mapping_data)
 type = self.handleMapping(etree.get("type"), mapping_data)
+configuration_name = self.handleMapping(etree.get("configuration_name"), mapping_data)
 fileObject = ConvertProjectFile(path, type, parent)
 for filter in etree.findall("{%s}filter" % self.namespaces[0]):
 fileObject.addFilter(self.parse_filter(filter, fileObject, mapping_data))
 description = ""
 if descElement != None:
 description = descElement.text
 fileObject.addMeta(metaArray)
 fileObject.addDescription(description)
+fileObject.addConfigurationName(configuration_name)
 return fileObject
 def parse_filter(self, etree, parent, mapping_data=None):
 """
 """
 tmpDict[attribute] = tmpElement.get(attribute)
 return tmpDict
 def handleMapping(self, data, mapping):
 """
 """
 retStr = data
+if not mapping: mapping = {}
-if mapping != None and data != None:
+if data != None:
-for key in mapping.keys():
+merged = dict(mapping.items() + self._get_env_variables().items())
-retStr = retStr.replace(key, mapping[key])
+for key in merged.keys():
+retStr = retStr.replace(key, merged[key])
 return retStr
+def _get_env_variables(self):
+if not hasattr(self, '_env_dict'):
+#Making dictionary only once because of performance.
+self._env_dict = {}
+for var in os.environ:
+self._env_dict["%%%s%%" % var] = os.environ[var]
+return self._env_dict

changeset 3	e7e0ae78773e
parent 0	2e8eeb919028
child 4	0951727b8815