archive/util/rspec.py

   1 import sys
   2 import pprint
   3 import os
   4 from xml.dom import minidom
   5 from types import StringTypes
   6
   7 class Rspec():
   8
   9     def __init__(self, xml = None, xsd = None):
  10         self.xsd = xsd # schema
  11         self.rootNode = None # root of the dom
  12         self.dict = {} # dict of the rspec.
  13         if xml:
  14             if type(xml) == file:
  15                 self.parseFile(xml)
  16             if type(xml) == str:
  17                 self.parseString(xml)
  18             self.dict = self.toDict()
  19
  20     def _getText(self, nodelist):
  21         rc = ""
  22         for node in nodelist:
  23             if node.nodeType == node.TEXT_NODE:
  24                 rc = rc + node.data
  25         return rc
  26
  27     # The rspec is comprised of 2 parts, and 1 reference:
  28     # attributes/elements describe individual resources
  29     # complexTypes are used to describe a set of attributes/elements
  30     # complexTypes can include a reference to other complexTypes.
  31
  32
  33     def _getName(self, node):
  34         '''Gets name of node. If tag has no name, then return tag's localName'''
  35         name = None
  36         if not node.nodeName.startswith("#"):
  37             if node.localName:
  38                 name = node.localName
  39             elif node.attributes.has_key("name"):
  40                 name = node.attributes.get("name").value
  41         return name
  42
  43
  44     # Attribute.  {name : nameofattribute, {items: values})
  45     def _attributeDict(self, attributeDom):
  46         '''Traverse single attribute node.  Create a dict {attributename : {name: value,}]}'''
  47         node = {} # parsed dict
  48         for attr in attributeDom.attributes.keys():
  49             node[attr] = attributeDom.attributes.get(attr).value
  50         return node
  51
  52
  53     def toDict(self, nodeDom = None):
  54         """
  55         convert this rspec to a dict and return it.
  56         """
  57         node = {}
  58         if not nodeDom:
  59              nodeDom = self.rootNode
  60
  61         elementName = nodeDom.nodeName
  62         if elementName and not elementName.startswith("#"):
  63             # attributes have tags and values.  get {tag: value}, else {type: value}
  64             node[elementName] = self._attributeDict(nodeDom)
  65             #node.update(self._attributeDict(nodeDom))
  66             # resolve the child nodes.
  67             if nodeDom.hasChildNodes():
  68                 for child in nodeDom.childNodes:
  69                     childName = self._getName(child)
  70                     if not childName:
  71                         continue
  72                     if not node[elementName].has_key(childName):
  73                         node[elementName][childName] = []
  74                         #node[childName] = []
  75                     childdict = self.toDict(child)
  76                     for value in childdict.values():
  77                         node[elementName][childName].append(value)
  78                     #node[childName].append(self.toDict(child))
  79         return node
  80
  81
  82     def toxml(self):
  83         """
  84         convert this rspec to an xml string and return it.
  85         """
  86         return self.rootNode.toxml()
  87
  88
  89     def toprettyxml(self):
  90         """
  91         print this rspec in xml in a pretty format.
  92         """
  93         return self.rootNode.toprettyxml()
  94
  95
  96     def parseFile(self, filename):
  97         """
  98         read a local xml file and store it as a dom object.
  99         """
 100         dom = minidom.parse(filename)
 101         self.rootNode = dom.childNodes[0]
 102
 103
 104     def parseString(self, xml):
 105         """
 106         read an xml string and store it as a dom object.
 107         """
 108         xml = xml.replace('\n', '').replace('\t', '').strip()
 109         dom = minidom.parseString(xml)
 110         self.rootNode = dom.childNodes[0]
 111
 112
 113     def dict2dom(self, rdict, include_doc = False):
 114         """
 115         convert a dict object into a dom object.
 116         """
 117
 118     def elementNode(tagname, rd):
 119         element = minidom.Element(tagname)
 120         for key in rd.keys():
 121             if isinstance(rd[key], StringTypes):
 122                 element.setAttribute(key, rd[key])
 123             elif isinstance(rd[key], dict):
 124                  child = elementNode(key, rd[key])
 125                  element.appendChild(child)
 126             elif isinstance(rd[key], list):
 127                  for item in rd[key]:
 128                      child = elementNode(key, item)
 129                      element.appendChild(child)
 130         return element
 131
 132         node = elementNode(rdict.keys()[0], rdict.values()[0])
 133         if include_doc:
 134             rootNode = minidom.Document()
 135             rootNode.appendChild(node)
 136         else:
 137             rootNode = node
 138         return rootNode
 139
 140
 141     def parseDict(self, rdict, include_doc = True):
 142         """
 143         Convert a dictionary into a dom object and store it.
 144         """
 145         self.rootNode = self.dict2dom(rdict, include_doc)
 146
 147
 148     def getDictsByTagName(self, tagname, dom = None):
 149         """
 150         Search the dom for all elements with the specified tagname
 151         and return them as a list of dicts
 152         """
 153         if not dom:
 154             dom = self.rootNode
 155         dicts = []
 156         doms = dom.getElementsByTagName(tagname)
 157         dictlist = [self.toDict(d) for d in doms]
 158         for item in dictlist:
 159             for value in item.values():
 160                 dicts.append(value)
 161         return dicts
 162
 163 # vim:ts=4:expandtab