1 """Implementation of the DOM Level 3 'LS-Load' feature.""" 2 3 import copy 4 import xml.dom 5 6 from xml.dom.NodeFilter import NodeFilter 7 8 9 __all__ = ["DOMBuilder", "DOMEntityResolver", "DOMInputSource"] 10 11 12 class Options: 13 """Features object that has variables set for each DOMBuilder feature. 14 15 The DOMBuilder class uses an instance of this class to pass settings to 16 the ExpatBuilder class. 17 """ 18 19 # Note that the DOMBuilder class in LoadSave constrains which of these 20 # values can be set using the DOM Level 3 LoadSave feature. 21 22 namespaces = 1 23 namespace_declarations = True 24 validation = False 25 external_parameter_entities = True 26 external_general_entities = True 27 external_dtd_subset = True 28 validate_if_schema = False 29 validate = False 30 datatype_normalization = False 31 create_entity_ref_nodes = True 32 entities = True 33 whitespace_in_element_content = True 34 cdata_sections = True 35 comments = True 36 charset_overrides_xml_encoding = True 37 infoset = False 38 supported_mediatypes_only = False 39 40 errorHandler = None 41 filter = None 42 43 44 class DOMBuilder: 45 entityResolver = None 46 errorHandler = None 47 filter = None 48 49 ACTION_REPLACE = 1 50 ACTION_APPEND_AS_CHILDREN = 2 51 ACTION_INSERT_AFTER = 3 52 ACTION_INSERT_BEFORE = 4 53 54 _legal_actions = (ACTION_REPLACE, ACTION_APPEND_AS_CHILDREN, 55 ACTION_INSERT_AFTER, ACTION_INSERT_BEFORE) 56 57 def __init__(self): 58 self._options = Options() 59 60 def _get_entityResolver(self): 61 return self.entityResolver 62 def _set_entityResolver(self, entityResolver): 63 self.entityResolver = entityResolver 64 65 def _get_errorHandler(self): 66 return self.errorHandler 67 def _set_errorHandler(self, errorHandler): 68 self.errorHandler = errorHandler 69 70 def _get_filter(self): 71 return self.filter 72 def _set_filter(self, filter): 73 self.filter = filter 74 75 def setFeature(self, name, state): 76 if self.supportsFeature(name): 77 state = state and 1 or 0 78 try: 79 settings = self._settings[(_name_xform(name), state)] 80 except KeyError: 81 raise xml.dom.NotSupportedErr( 82 "unsupported feature: %r" % (name,)) 83 else: 84 for name, value in settings: 85 setattr(self._options, name, value) 86 else: 87 raise xml.dom.NotFoundErr("unknown feature: " + repr(name)) 88 89 def supportsFeature(self, name): 90 return hasattr(self._options, _name_xform(name)) 91 92 def canSetFeature(self, name, state): 93 key = (_name_xform(name), state and 1 or 0) 94 return key in self._settings 95 96 # This dictionary maps from (feature,value) to a list of 97 # (option,value) pairs that should be set on the Options object. 98 # If a (feature,value) setting is not in this dictionary, it is 99 # not supported by the DOMBuilder. 100 # 101 _settings = { 102 ("namespace_declarations", 0): [ 103 ("namespace_declarations", 0)], 104 ("namespace_declarations", 1): [ 105 ("namespace_declarations", 1)], 106 ("validation", 0): [ 107 ("validation", 0)], 108 ("external_general_entities", 0): [ 109 ("external_general_entities", 0)], 110 ("external_general_entities", 1): [ 111 ("external_general_entities", 1)], 112 ("external_parameter_entities", 0): [ 113 ("external_parameter_entities", 0)], 114 ("external_parameter_entities", 1): [ 115 ("external_parameter_entities", 1)], 116 ("validate_if_schema", 0): [ 117 ("validate_if_schema", 0)], 118 ("create_entity_ref_nodes", 0): [ 119 ("create_entity_ref_nodes", 0)], 120 ("create_entity_ref_nodes", 1): [ 121 ("create_entity_ref_nodes", 1)], 122 ("entities", 0): [ 123 ("create_entity_ref_nodes", 0), 124 ("entities", 0)], 125 ("entities", 1): [ 126 ("entities", 1)], 127 ("whitespace_in_element_content", 0): [ 128 ("whitespace_in_element_content", 0)], 129 ("whitespace_in_element_content", 1): [ 130 ("whitespace_in_element_content", 1)], 131 ("cdata_sections", 0): [ 132 ("cdata_sections", 0)], 133 ("cdata_sections", 1): [ 134 ("cdata_sections", 1)], 135 ("comments", 0): [ 136 ("comments", 0)], 137 ("comments", 1): [ 138 ("comments", 1)], 139 ("charset_overrides_xml_encoding", 0): [ 140 ("charset_overrides_xml_encoding", 0)], 141 ("charset_overrides_xml_encoding", 1): [ 142 ("charset_overrides_xml_encoding", 1)], 143 ("infoset", 0): [], 144 ("infoset", 1): [ 145 ("namespace_declarations", 0), 146 ("validate_if_schema", 0), 147 ("create_entity_ref_nodes", 0), 148 ("entities", 0), 149 ("cdata_sections", 0), 150 ("datatype_normalization", 1), 151 ("whitespace_in_element_content", 1), 152 ("comments", 1), 153 ("charset_overrides_xml_encoding", 1)], 154 ("supported_mediatypes_only", 0): [ 155 ("supported_mediatypes_only", 0)], 156 ("namespaces", 0): [ 157 ("namespaces", 0)], 158 ("namespaces", 1): [ 159 ("namespaces", 1)], 160 } 161 162 def getFeature(self, name): 163 xname = _name_xform(name) 164 try: 165 return getattr(self._options, xname) 166 except AttributeError: 167 if name == "infoset": 168 options = self._options 169 return (options.datatype_normalization 170 and options.whitespace_in_element_content 171 and options.comments 172 and options.charset_overrides_xml_encoding 173 and not (options.namespace_declarations 174 or options.validate_if_schema 175 or options.create_entity_ref_nodes 176 or options.entities 177 or options.cdata_sections)) 178 raise xml.dom.NotFoundErr("feature %s not known" % repr(name)) 179 180 def parseURI(self, uri): 181 if self.entityResolver: 182 input = self.entityResolver.resolveEntity(None, uri) 183 else: 184 input = DOMEntityResolver().resolveEntity(None, uri) 185 return self.parse(input) 186 187 def parse(self, input): 188 options = copy.copy(self._options) 189 options.filter = self.filter 190 options.errorHandler = self.errorHandler 191 fp = input.byteStream 192 if fp is None and options.systemId: 193 import urllib2 194 fp = urllib2.urlopen(input.systemId) 195 return self._parse_bytestream(fp, options) 196 197 def parseWithContext(self, input, cnode, action): 198 if action not in self._legal_actions: 199 raise ValueError("not a legal action") 200 raise NotImplementedError("Haven't written this yet...") 201 202 def _parse_bytestream(self, stream, options): 203 import xml.dom.expatbuilder 204 builder = xml.dom.expatbuilder.makeBuilder(options) 205 return builder.parseFile(stream) 206 207 208 def _name_xform(name): 209 return name.lower().replace('-', '_') 210 211 212 class DOMEntityResolver(object): 213 __slots__ = '_opener', 214 215 def resolveEntity(self, publicId, systemId): 216 assert systemId is not None 217 source = DOMInputSource() 218 source.publicId = publicId 219 source.systemId = systemId 220 source.byteStream = self._get_opener().open(systemId) 221 222 # determine the encoding if the transport provided it 223 source.encoding = self._guess_media_encoding(source) 224 225 # determine the base URI is we can 226 import posixpath, urlparse 227 parts = urlparse.urlparse(systemId) 228 scheme, netloc, path, params, query, fragment = parts 229 # XXX should we check the scheme here as well? 230 if path and not path.endswith("/"): 231 path = posixpath.dirname(path) + "/" 232 parts = scheme, netloc, path, params, query, fragment 233 source.baseURI = urlparse.urlunparse(parts) 234 235 return source 236 237 def _get_opener(self): 238 try: 239 return self._opener 240 except AttributeError: 241 self._opener = self._create_opener() 242 return self._opener 243 244 def _create_opener(self): 245 import urllib2 246 return urllib2.build_opener() 247 248 def _guess_media_encoding(self, source): 249 info = source.byteStream.info() 250 if "Content-Type" in info: 251 for param in info.getplist(): 252 if param.startswith("charset="): 253 return param.split("=", 1)[1].lower() 254 255 256 class DOMInputSource(object): 257 __slots__ = ('byteStream', 'characterStream', 'stringData', 258 'encoding', 'publicId', 'systemId', 'baseURI') 259 260 def __init__(self): 261 self.byteStream = None 262 self.characterStream = None 263 self.stringData = None 264 self.encoding = None 265 self.publicId = None 266 self.systemId = None 267 self.baseURI = None 268 269 def _get_byteStream(self): 270 return self.byteStream 271 def _set_byteStream(self, byteStream): 272 self.byteStream = byteStream 273 274 def _get_characterStream(self): 275 return self.characterStream 276 def _set_characterStream(self, characterStream): 277 self.characterStream = characterStream 278 279 def _get_stringData(self): 280 return self.stringData 281 def _set_stringData(self, data): 282 self.stringData = data 283 284 def _get_encoding(self): 285 return self.encoding 286 def _set_encoding(self, encoding): 287 self.encoding = encoding 288 289 def _get_publicId(self): 290 return self.publicId 291 def _set_publicId(self, publicId): 292 self.publicId = publicId 293 294 def _get_systemId(self): 295 return self.systemId 296 def _set_systemId(self, systemId): 297 self.systemId = systemId 298 299 def _get_baseURI(self): 300 return self.baseURI 301 def _set_baseURI(self, uri): 302 self.baseURI = uri 303 304 305 class DOMBuilderFilter: 306 """Element filter which can be used to tailor construction of 307 a DOM instance. 308 """ 309 310 # There's really no need for this class; concrete implementations 311 # should just implement the endElement() and startElement() 312 # methods as appropriate. Using this makes it easy to only 313 # implement one of them. 314 315 FILTER_ACCEPT = 1 316 FILTER_REJECT = 2 317 FILTER_SKIP = 3 318 FILTER_INTERRUPT = 4 319 320 whatToShow = NodeFilter.SHOW_ALL 321 322 def _get_whatToShow(self): 323 return self.whatToShow 324 325 def acceptNode(self, element): 326 return self.FILTER_ACCEPT 327 328 def startContainer(self, element): 329 return self.FILTER_ACCEPT 330 331 del NodeFilter 332 333 334 class DocumentLS: 335 """Mixin to create documents that conform to the load/save spec.""" 336 337 async = False 338 339 def _get_async(self): 340 return False 341 def _set_async(self, async): 342 if async: 343 raise xml.dom.NotSupportedErr( 344 "asynchronous document loading is not supported") 345 346 def abort(self): 347 # What does it mean to "clear" a document? Does the 348 # documentElement disappear? 349 raise NotImplementedError( 350 "haven't figured out what this means yet") 351 352 def load(self, uri): 353 raise NotImplementedError("haven't written this yet") 354 355 def loadXML(self, source): 356 raise NotImplementedError("haven't written this yet") 357 358 def saveXML(self, snode): 359 if snode is None: 360 snode = self 361 elif snode.ownerDocument is not self: 362 raise xml.dom.WrongDocumentErr() 363 return snode.toxml() 364 365 366 class DOMImplementationLS: 367 MODE_SYNCHRONOUS = 1 368 MODE_ASYNCHRONOUS = 2 369 370 def createDOMBuilder(self, mode, schemaType): 371 if schemaType is not None: 372 raise xml.dom.NotSupportedErr( 373 "schemaType not yet supported") 374 if mode == self.MODE_SYNCHRONOUS: 375 return DOMBuilder() 376 if mode == self.MODE_ASYNCHRONOUS: 377 raise xml.dom.NotSupportedErr( 378 "asynchronous builders are not supported") 379 raise ValueError("unknown value for mode") 380 381 def createDOMWriter(self): 382 raise NotImplementedError( 383 "the writer interface hasn't been written yet!") 384 385 def createDOMInputSource(self): 386 return DOMInputSource() 387
