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 self._settings.has_key(key)

    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 info.has_key("Content-Type"):

   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()