FCL/sftools/dev/build: comparison buildframework/helium/tools/common/python/lib/configuration.py

equal deleted inserted replaced

-:be27ed110b50
+:d8ac696cc51f
 _logger = logging.getLogger('configuration')
 logging.basicConfig(level=logging.INFO)
 class Configuration(object, UserDict.DictMixin):
-""" Base Configuration objects. """
+""" Base Configuration object. """
 key_re = re.compile(r'\${(?P<name>[._a-zA-Z0-9]+)}', re.M)
 def __init__(self, data=None):
 """ Initialization. """
-if data == None:
+#super(UserDict.DictMixin, self).__init__(data)
-data = {}
 self.name = None
-self.data = data
+self.data = {}
+if data is not None:
+self.data.update(data)
 def __contains__(self, key):
 """ Check if a keys is defined in the dict. """
 return self.data.__contains__(key)
 del self.data[key]
 def keys(self):
 """ Get the list of item keys. """
 return self.data.keys()
+def has_key(self, key):
+""" Check if key exists. """
+return self.data.has_key(key)
 def match_name(self, name):
 """ See if the given name matches the name of this configuration. """
 return self.name == name
 return self.__getitem__(key)
 except KeyError:
 return default_value
 def get_list(self, key, default_value):
+""" Get a value as a list. """
 try:
 itemlist = self.__getitem__(key)
 if not isinstance(itemlist, types.ListType):
 itemlist = [itemlist]
 return itemlist
 except KeyError:
 return default_value
 def get_int(self, key, default_value):
+""" Get a value as an int. """
 try:
 value = self.__getitem__(key)
 return int(value)
 except KeyError:
 return default_value
 def get_boolean(self, key, default_value):
+""" Get a value as a boolean. """
 try:
 value = self.__getitem__(key)
 return value == "true" or value == "yes" or value == "1"
 except KeyError:
 return default_value
 isinstance(value, types.UnicodeType) or \
 isinstance(value, types.ListType):
 for match in self.key_re.finditer(value):
 for property_name in match.groups():
 if self.has_key(property_name):
+# See if interpolation may cause infinite recursion
+raw_property_value = self.__getitem__(property_name, False)
+#print 'raw_property_value: ' + raw_property_value
+if raw_property_value == None:
+raw_property_value = ''
+if isinstance(raw_property_value, types.ListType):
+for prop in raw_property_value:
+if re.search('\${' + property_name + '}', prop) != None:
+raise Exception("Key '%s' will cause recursive interpolation with value %s" % (property_name, raw_property_value))
+else:
+if re.search('\${' + property_name + '}', raw_property_value) != None:
+raise Exception("Key '%s' will cause recursive interpolation with value %s" % (property_name, raw_property_value))
+# Get the property value
 property_value = self.__getitem__(property_name)
 if isinstance(property_value, types.ListType):
 property_value = ",".join(property_value)
 else:
 property_value = re.sub(r'\\', r'\\\\', property_value, re.M)
 value = re.sub('\${' + property_name + '}', property_value, value, re.M)
 return value
 def __str__(self):
+""" A string representation. """
 return self.__class__.__name__ + '[' + str(self.name) + ']'
 def __cmp__(self, other):
+""" Compare with another object. """
 return cmp(self.__str__, other.__str__)
 class PropertiesConfiguration(Configuration):
 """ A Configuration that parses a plain text properties file.
 except IOError, e:
 raise
 class NestedConfiguration(Configuration):
+""" A nested configuration that may have a parent or child configurations. """
 def __init__(self):
 """ Initialization. """
 Configuration.__init__(self, None)
 self.parent = None
 self.type = None
 self.abstract = None
 def isBuildable(self):
+""" Is this a buildable configuration? """
 return self.abstract == None
 def _addPropertyValue(self, key, value, parseList=True):
 """Adds a property value to the configuration.
 self.data[key] = currentValue
 else:
 self.data[key] = value
 def __getitem__(self, key, interpolate=True):
+""" Get an item. """
 #print "__getitem__(%s, %s)" % (self.name, key)
 if self.data.has_key(key):
 value = super(NestedConfiguration, self).__getitem__(key, False)
 if interpolate:
 return self.interpolate(value)
 return self.interpolate(value)
 return value
 raise KeyError('Cannot find key: ' + key)
 def __setitem__(self, key, item):
+""" Set the value of an item. """
 self.data[key] = item
 def __delitem__(self, key):
+""" Remove an item. """
 del self.data[key]
 def __contains__(self, key):
 """ Check if a keys is defined in the dict. """
 if self.data.__contains__(key):
 elif self.parent:
 return self.parent.__contains__(key)
 return False
 def keys(self):
+""" Get the list of item keys. """
 myKeys = self.data.keys()
 if self.parent != None:
 parentKeys = self.parent.keys()
 for key in parentKeys:
 if not key in myKeys:
 myKeys.append(key)
 return myKeys
+def has_key(self, key):
+""" Check if key exists. """
+if self.data.has_key(key):
+return True
+if self.parent != None:
+return self.parent.has_key(key)
+return False
 def match_name(self, name):
+""" See if the configuration name matches the argument. """
 if self.name == name:
 return True
 if self.parent != None:
 return self.parent.match_name(name)
 return False
 elif self._constructors.has_key(child.nodeName):
 configChildNodes.append(child)
 else:
 raise Exception('Bad configuration xml element: ' + child.nodeName)
-for childConfigNode in configChildNodes:
-self.parseConfiguration(childConfigNode, configs, config)
 # Only save the buildable configurations
 if config.isBuildable():
 _logger.debug('Adding config to buildable set: ' + str(config))
 configs.append(config)
+for childConfigNode in configChildNodes:
+self.parseConfiguration(childConfigNode, configs, config)
 def getNodeByReference(self, refName):
 """ Find a node based on a reference to it. """
 for child in self.rootNode.childNodes:
 if child.nodeType == xml.dom.Node.ELEMENT_NODE:
 value = ','.join(values)
 if interpolate:
 value = self.interpolate(value)
 return value
+def has_key(self, key):
+""" Check if key exists. """
+elements = self._root.xpath(_Key(key).to_xpath())
+if len(elements) > 0:
+return True
+return False
 class _Key(object):
 """ A hierarchical configuration key. """
 def __init__(self, string):
 """ Initialization. """
 self.string = string
 def to_xpath(self):
+""" Convert the key to XPath syntax. """
 return self.string.replace('.', '/')
 class XMLConfiguration(HierarchicalConfiguration):
 """ A XML-based hierarchical configuration. """

changeset 179	d8ac696cc51f
parent 1	be27ed110b50