Dome/Path.py

   1 from xml.dom import Node
   2
   3 def literal_match(node):
   4         return "[ext:match('%s')]" % node.nodeValue
   5
   6 # Return a string that will match this node in an XPath.
   7 # ns is updated with any new namespace required.
   8 def match_name(node, ns):
   9         if node.nodeType == Node.TEXT_NODE:
  10                 return 'text()'
  11         elif node.nodeType == Node.COMMENT_NODE:
  12                 return 'comment()'
  13         elif node.nodeType == Node.ELEMENT_NODE:
  14                 if node.namespaceURI:
  15                         for x in ns.keys():
  16                                 if ns[x] == node.namespaceURI:
  17                                         return '%s:%s' % (x, node.localName)
  18                         n = 1
  19                         while 1:
  20                                 key = '_ns_%d' % n
  21                                 if not ns.has_key(key):
  22                                         break
  23                                 n += 1
  24                         ns[key] = node.namespaceURI
  25                         return '%s:%s' % (key, node.localName)
  26                 return node.nodeName
  27         else:
  28                 return node.nodeName
  29
  30 def jump_to_sibling(src, dst, ns):
  31         "Return an XPath which, given a context 'src' will move to sibling 'dst'."
  32         "Namespace 'ns' may be updated if new names are required"
  33
  34         if dst.nodeType == Node.ATTRIBUTE_NODE:
  35                 return 'attribute::%s/' % dst.nodeName
  36
  37         # Search forwards for 'dst', counting how many matching nodes we pass.
  38         count = 0
  39         check = src
  40         while check != dst:
  41                 check = check.nextSibling
  42                 if not check:
  43                         break
  44                 if check.nodeName == dst.nodeName:
  45                         count += 1
  46         if check:
  47                 return 'following-sibling::%s[%d]/' % (match_name(dst, ns), count)
  48
  49         # Not found - search backwards for 'dst', counting how many matching nodes we pass.
  50         count = 0
  51         check = src
  52         while check != dst:
  53                 check = check.previousSibling
  54                 if not check:
  55                         return                  # Error!
  56                 if check.nodeName == dst.nodeName:
  57                         count += 1
  58         return 'preceding-sibling::%s[%d]/' % (match_name(dst, ns), count)
  59
  60 def make_relative_path(src_node, dst_node, lit, ns):
  61         "Return an XPath string which will move us from src to dst."
  62         "If 'lit' then the text of the (data) node must match too."
  63         "Namespace 'ns' is updated with any required namespaces."
  64
  65         if src_node == dst_node:
  66                 return '.'
  67
  68         def path_to(node):
  69                 "Returns a path to the node in the form [root, ... , node]"
  70                 ps = [node]
  71                 while node.parentNode:
  72                         node = node.parentNode
  73                         ps.insert(0, node)
  74                 return ps
  75
  76         src_parents = path_to(src_node)
  77         dst_parents = path_to(dst_node)
  78
  79         # Trim off all the common path elements...
  80         # Note that this may leave either path empty, if one node is an ancestor of the other.
  81         while src_parents and dst_parents and src_parents[0] == dst_parents[0]:
  82                 del src_parents[0]
  83                 del dst_parents[0]
  84
  85         # Now, the initial context node is 'src_node'.
  86         # Build the path from here...
  87         path = ''
  88
  89         # We need to go up one level for each element left in src_parents, less one
  90         # (so we end up as a child of the lowest common parent, on the src side).
  91         # If src is an ancestor of dst then this does nothing.
  92         # If dst is an ancestor of src then go up an extra level, because we don't jump
  93         # across in the next step.
  94         for p in range(0, len(src_parents) - 1):
  95                 path += '../'
  96         if not dst_parents:
  97                 path += '../'
  98
  99         # We then jump across to the correct sibling and head back down the tree...
 100         # If src is an ancestor of dst or the other way round we do nothing.
 101         if src_parents and dst_parents:
 102                 path += jump_to_sibling(src_parents[0], dst_parents[0], ns)
 103                 del dst_parents[0]
 104
 105         # dst_parents is now a list of nodes to visit to get to dst.
 106         for node in dst_parents:
 107                 prev = 1
 108
 109                 p = node
 110                 while p.previousSibling:
 111                         p = p.previousSibling
 112                         if p.nodeName == node.nodeName:
 113                                 prev += 1
 114
 115                 path += 'child::%s[%d]/' % (match_name(node, ns), prev)
 116
 117         path = path[:-1]
 118         if lit:
 119                 path += literal_match(dst_node)
 120         #print "%s [%s]" % (path, ns)
 121         return path