Viewing file:  Stylesheet.py (21.92 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
########################################################################
#
# File Name: Stylesheet.py
#
#
"""
Implement all the stylesheet internals
WWW: http://4suite.com/4XSLT e-mail: support@4suite.com
Copyright (c) 1999-2001 Fourthought Inc, USA. All Rights Reserved.
See http://4suite.com/COPYRIGHT for license and copyright information
"""
import string, types
from xml.dom import EMPTY_NAMESPACE
import xml.dom.ext
from xml import xpath, xslt
from xml.dom import Node
from xml.dom.NodeFilter import NodeFilter
from xml.xslt import XsltElement, XsltException, InternalException, Error
from xml.xslt import XPatternParser, XsltContext
from xml.xslt import XSL_NAMESPACE, OutputParameters, ReleaseNode
from xml.xpath import CoreFunctions, Util, XPathParser, Conversions
class PatternInfo:
"""Indexes into the tuple for pattern information"""
PATTERN = 0
AXIS_TYPE = 1
PRIORITY = 2
MODE = 3
NSS = 4
TEMPLATE = 5
SPECIAL_RE_CHARS = ['.', '^', '$', '*', '+', '?']
def MatchTree(patterns, context):
'''Select all nodes from node on down that match the pattern'''
matched = map(lambda x, c=context, n=context.node: [n]*x.match(c,n),
patterns)
counter = 1
size = len(context.node.childNodes)
origState = context.copyNodePosSize()
for child in context.node.childNodes:
context.setNodePosSize((child, counter, size))
map(lambda x, y: x.extend(y), matched, MatchTree(patterns, context))
context.setNodePosSize(origState)
counter = counter + 1
if context.node.nodeType == Node.ELEMENT_NODE:
counter = 1
size = len(context.node.attributes)
for attr in context.node.attributes.values():
context.setNodePosSize((attr, counter, size))
map(lambda x, y: x.extend(y),
matched, MatchTree(patterns, context))
context.setNodePosSize(origState)
counter = counter + 1
return matched
class StylesheetElement(XsltElement):
legalAttrs = ('id', 'extension-element-prefixes',
'exclude-result-prefixes', 'version')
def __init__(self, doc, uri=xml.xslt.XSL_NAMESPACE, localName='stylesheet',
prefix='xsl', baseUri=''):
XsltElement.__init__(self, doc, uri, localName, prefix, baseUri)
self._imports = []
self.extensionNss = []
self._primedContext = None
self._lres = []
return
def _updateKeys(self, doc, processor):
context = XsltContext.XsltContext(doc, 1, 1,
processorNss=self.namespaces,
processor=processor)
patterns = map(lambda x: x[1], self._kelems)
if not patterns:
return
match_lists = MatchTree(patterns, context)
ctr = 0
for (name, match_pattern, use_expr) in self._kelems:
match_list = match_lists[ctr]
if not self.keys.has_key(name):
self.keys[name] = {}
for node in match_list:
context.stylesheet = self
origState = context.copy()
context.node = node
key_value_list = use_expr.evaluate(context)
#NOTE: use attrs can't contain var refs, so result can't
#be RTF So use CoreFunc StringValue, not ExtFunc version
if type(key_value_list) != type([]):
key_value_list = [key_value_list]
for obj in key_value_list:
keystr = Conversions.StringValue(obj)
if not self.keys[name].has_key(keystr):
self.keys[name][keystr] = []
self.keys[name][keystr].append(node)
context.set(origState)
ctr = ctr + 1
context.release()
return
def setup(self):
'''
Called only once, at the first initialization
'''
self.namespaces = xml.dom.ext.GetAllNs(self)
self.spaceRules = {}
self._topLevelVarNodes = {}
self.namespaceAliases = ({}, {})
self.decimalFormats = {'': ('.', ',', 'Infinity', '-', 'NaN', '%', '?', '0', '#', ';')}
self.keys = {}
self.outputParams = OutputParameters()
excluded_prefixes = self.getAttributeNS(EMPTY_NAMESPACE, 'exclude-result-prefixes')
self.excludedNss = []
if excluded_prefixes:
excluded_prefixes = string.splitfields(excluded_prefixes)
for prefix in excluded_prefixes:
if prefix == '#default': prefix = ''
self.excludedNss.append(self.namespaces[prefix])
self._setupNamespaceAliases()
self._setupChildNodes()
self._setupDecimalFormats()
self._setupWhitespaceRules()
self._setupOutput()
self._setupTemplates()
self._setupKeys()
self._setupTopLevelVarParams()
return
def _setupNamespaceAliases(self):
#Namespace aliases
ns_aliases = filter(lambda x: x.nodeType == Node.ELEMENT_NODE and (x.namespaceURI, x.localName) == (XSL_NAMESPACE, 'namespace-alias'), self.childNodes)
for nsa in ns_aliases:
stylesheet_prefix = nsa.getAttributeNS(EMPTY_NAMESPACE, 'stylesheet-prefix')
result_prefix = nsa.getAttributeNS(EMPTY_NAMESPACE, 'result-prefix')
if not (stylesheet_prefix and result_prefix):
raise XsltException(Error.INVALID_NAMESPACE_ALIAS)
if stylesheet_prefix == '#default':
stylesheet_prefix == ''
if result_prefix == '#default':
result_prefix == ''
sty_ns = self.namespaces[stylesheet_prefix]
res_ns = self.namespaces[result_prefix]
self.namespaceAliases[0][stylesheet_prefix] = result_prefix
self.namespaceAliases[1][sty_ns] = res_ns
return
def _setupChildNodes(self):
snit = self.ownerDocument.createNodeIterator(self, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT, None,0)
curr_node = snit.nextNode()
curr_node = snit.nextNode()
while curr_node:
try:
curr_node.setup()
except (xpath.SyntaxException, xpath.InternalException, xslt.SyntaxException, xslt.InternalException), e:
#import traceback
#traceback.print_exc(1000)
if not hasattr(e, 'stylesheetUri'):
e.stylesheetUri = curr_node.baseUri
raise e
curr_node = snit.nextNode()
return
def _setupDecimalFormats(self):
dec_formats = filter(lambda x: x.nodeType == Node.ELEMENT_NODE and (x.namespaceURI, x.localName) == (XSL_NAMESPACE, 'decimal-format'), self.childNodes)
for dc in dec_formats:
format_settings = (
(dc.getAttributeNS(EMPTY_NAMESPACE, 'decimal-separator') or '.'),
(dc.getAttributeNS(EMPTY_NAMESPACE, 'grouping-separator') or ','),
(dc.getAttributeNS(EMPTY_NAMESPACE, 'infinity') or 'Infinity'),
(dc.getAttributeNS(EMPTY_NAMESPACE, 'minus-sign') or '-'),
(dc.getAttributeNS(EMPTY_NAMESPACE, 'NaN') or 'NaN'),
(dc.getAttributeNS(EMPTY_NAMESPACE, 'percent') or '%'),
(dc.getAttributeNS(EMPTY_NAMESPACE, 'per-mille') or '?'),
(dc.getAttributeNS(EMPTY_NAMESPACE, 'zero-digit') or '0'),
(dc.getAttributeNS(EMPTY_NAMESPACE, 'digit') or '#'),
(dc.getAttributeNS(EMPTY_NAMESPACE, 'pattern-separator') or ';')
)
nfs = []
for fc in format_settings:
if fc in SPECIAL_RE_CHARS:
nfs.append('\\'+fc)
else:
nfs.append(fc)
name = dc.getAttributeNS(EMPTY_NAMESPACE, 'name')
name = name and Util.ExpandQName(name, dc)
self.decimalFormats[name] = tuple(nfs)
return
def _setupWhitespaceRules(self):
#Whitespace rules
space_rules = filter(lambda x: x.nodeType == Node.ELEMENT_NODE and (x.namespaceURI, x.localName) in [(XSL_NAMESPACE, 'preserve-space'), (XSL_NAMESPACE, 'strip-space')], self.childNodes)
for sr in space_rules:
args = string.splitfields(sr.getAttributeNS(EMPTY_NAMESPACE, 'elements'))
for an_arg in args:
#FIXME: watch out! ExpandQName doesn't handle ns defaulting
split_name = Util.ExpandQName(an_arg, sr)
self.spaceRules[split_name] = string.splitfields(sr.localName, '-')[0]
return
def _setupOutput(self):
#Output
output = filter(lambda x: x.nodeType == Node.ELEMENT_NODE and (x.namespaceURI, x.localName) == (XSL_NAMESPACE, 'output'), self.childNodes)
for out in output:
method = out.getAttributeNS(EMPTY_NAMESPACE, 'method')
if method: self.outputParams.method = method
version = out.getAttributeNS(EMPTY_NAMESPACE, 'version')
if version: self.outputParams.version = version
encoding = out.getAttributeNS(EMPTY_NAMESPACE, 'encoding')
if encoding: self.outputParams.encoding = encoding
omit_xml_decl = out.getAttributeNS(EMPTY_NAMESPACE, 'omit-xml-declaration')
if omit_xml_decl: self.outputParams.omitXmlDeclaration = omit_xml_decl
standalone = out.getAttributeNS(EMPTY_NAMESPACE, 'standalone')
if standalone: self.outputParams.standalone = standalone
doctype_system = out.getAttributeNS(EMPTY_NAMESPACE, 'doctype-system')
if doctype_system: self.outputParams.doctypeSystem = doctype_system
doctype_public = out.getAttributeNS(EMPTY_NAMESPACE, 'doctype-public')
if doctype_public: self.outputParams.doctypePublic = doctype_public
media_type = out.getAttributeNS(EMPTY_NAMESPACE, 'media-type')
if media_type: self.outputParams.mediaType = media_type
#cdata_sec_elem = out.getAttributeNS(EMPTY_NAMESPACE, 'cdata-section-elements')
self.outputParams.cdataSectionElements = []
qnames = string.splitfields(out.getAttributeNS(EMPTY_NAMESPACE, 'cdata-section-elements'))
for qname in qnames:
self.outputParams.cdataSectionElements.append(Util.ExpandQName(qname, namespaces=self.namespaces))
indent = out.getAttributeNS(EMPTY_NAMESPACE, 'indent')
if indent: self.outputParams.indent = indent
return
def _setupTemplates(self):
templates = filter(lambda x: x.nodeType == Node.ELEMENT_NODE and (x.namespaceURI, x.localName) == (XSL_NAMESPACE, 'template'), self.childNodes)
#Preprocess all of the templates with names
match_tpls = filter(lambda x: x._name != '', templates)
self._call_templates = {}
for m in match_tpls:
if not self._call_templates.has_key(m._name):
self._call_templates[m._name] = m
#Preprocess the patterns from all templates
patterns = []
for tpl in templates:
(patternInfo, mode, nss) = tpl.getMatchInfo()
for pi in patternInfo:
patterns.append(pi+(mode, nss, tpl))
patterns.reverse()
patterns.sort(lambda x, y:
cmp(y[PatternInfo.PRIORITY], x[PatternInfo.PRIORITY]))
patternDict = {}
for p in patterns:
m = p[PatternInfo.MODE]
if not patternDict.has_key(m):
patternDict[m] = []
patternDict[m].append(p)
self._patterns = patternDict
return
def _setupKeys(self):
self._kelems = []
pattern_parser = XPatternParser.XPatternParser()
path_parser = XPathParser.XPathParser()
kelems = filter(lambda x: x.nodeType == Node.ELEMENT_NODE and (x.namespaceURI, x.localName) == (XSL_NAMESPACE, 'key'), self.childNodes)
for kelem in kelems:
name = Util.ExpandQName(kelem.getAttributeNS(EMPTY_NAMESPACE, 'name'), kelem)
match = kelem.getAttributeNS(EMPTY_NAMESPACE, 'match')
match_pattern = pattern_parser.parsePattern(match)
use = kelem.getAttributeNS(EMPTY_NAMESPACE, 'use')
use_expr = path_parser.parseExpression(use)
self._kelems.append((name, match_pattern, use_expr))
self.reset()
return
def _setupTopLevelVarParams(self):
#Is there a more efficient way to zip two sequences into a dict?
vars = filter(lambda x: x.nodeType == Node.ELEMENT_NODE and x.namespaceURI == XSL_NAMESPACE and x.localName == 'variable', self.childNodes)
self._topVariables = {}
for var in vars:
#FIXME: First check multiple variable errors
self._topVariables[var._name] = var
params = filter(lambda x: x.nodeType == Node.ELEMENT_NODE and x.namespaceURI == XSL_NAMESPACE and x.localName == 'param', self.childNodes)
for param in params:
#FIXME: First check multiple variable errors
self._topVariables[param._name] = param
return
def newSource(self, doc, processor):
"""
Called whenever there's a new source document registed to the processor
"""
self._updateKeys(doc, processor)
return
def reset(self):
"""
Called whenever the processor is reset, i.e. after each run
"""
self.keys = {}
if self._primedContext:
self._primedContext.release()
self._primedContext = None
return
def _fixupAliases(self):
for lre in self._lres:
lre.fixupAliases()
return
def processImports(self, contextNode, processor, topLevelParams):
#Import precedence rules can be taken care of by having parent
self._imports = filter(lambda x: x.nodeType == Node.ELEMENT_NODE and (x.namespaceURI, x.localName) == (XSL_NAMESPACE, 'import'), self.childNodes)
#Style-sheet dictionaries override imported values
for imp in self._imports:
imp.setup()
#FIXME: Extension elements?
imp.stylesheet = processor._styReader.fromUri(imp.href, baseUri=imp.baseUri)
sheet = imp.stylesheet
sheet.processImports(contextNode, processor, topLevelParams)
sheet.prime(contextNode, processor, topLevelParams)
self.spaceRules.update(sheet.spaceRules)
self.namespaceAliases[0].update(sheet.namespaceAliases[0])
self.namespaceAliases[1].update(sheet.namespaceAliases[1])
self._fixupAliases()
return
def _computeVar(self, vname, context, processed, deferred,
overriddenParams, topLevelParams, processor):
vnode = self._topVariables[vname]
if vnode in deferred:
raise XsltException(Error.CIRCULAR_VAR, vname[0], vname[1])
if vnode in processed:
return
if vnode.localName[0] == 'p':
if overriddenParams.has_key(vname):
context.varBindings[vname] = overriddenParams[vname]
else:
try:
context = vnode.instantiate(context, processor)[0]
except xpath.RuntimeException, e:
deferred.append(vnode)
self._computeVar((e.args[0], e.args[1]), context,
processed, deferred, overriddenParams,
topLevelParams, processor)
deferred.remove(vnode)
context = vnode.instantiate(context, processor)[0]
#Set up so that later stylesheets will get overridden by
#parameter values set in higher-priority stylesheets
topLevelParams[vname] = context.varBindings[vname]
else:
try:
context = vnode.instantiate(context, processor)[0]
except xpath.RuntimeException, e:
deferred.append(vnode)
self._computeVar((e.args[0], e.args[1]), context,
processed, deferred, overriddenParams,
topLevelParams, processor)
deferred.remove(vnode)
context = vnode.instantiate(context, processor)[0]
processed.append(vnode)
return
def prime(self, contextNode, processor, topLevelParams):
self._primedContext = context = XsltContext.XsltContext(contextNode.ownerDocument, 1, 1, processorNss=self.namespaces, stylesheet=self, processor=processor)
self._docReader = processor._docReader
#Attribute sets
attribute_sets = filter(lambda x: x.nodeType == Node.ELEMENT_NODE and (x.namespaceURI, x.localName) == (XSL_NAMESPACE, 'attribute-set'), self.childNodes)
for as in attribute_sets:
as.instantiate(context, processor)
overridden_params = {}
for k in topLevelParams.keys():
if type(k) != types.TupleType:
try:
split_name = Util.ExpandQName(k, namespaces=context.processorNss)
except KeyError:
continue
else:
split_name = k
overridden_params[split_name] = topLevelParams[k]
for vname in self._topVariables.keys():
self._computeVar(vname, context, [], [], overridden_params,
topLevelParams, processor)
self._primedContext = context
#Note: key expressions can't have var refs, so we needn't worry about imports
self._updateKeys(contextNode, processor)
for imp in self._imports:
self._primedContext.varBindings.update(imp.stylesheet._primedContext.varBindings)
return topLevelParams
########################## Run-time methods ########################
def getNamedTemplates(self):
templates = {}
for name,tpl in self._call_templates.items():
templates[name] = (self, tpl)
for imported in self._imports:
imp_tpl = imported.stylesheet.getNamedTemplates()
for name, (sty, tpl) in imp_tpl.items():
if not templates.has_key(name):
templates[name] = (sty, tpl)
return templates
def getTopLevelVariables(self):
return self._primedContext.varBindings.copy()
def applyTemplates(self, context, mode, processor, params=None):
params = params or {}
origState = context.copyStylesheet()
context.setStylesheet((self._primedContext.varBindings,self.namespaces, self))
#Set the current node for this template application
context.currentNode = context.node
matched = 1
for patternInfo in self._patterns.get(mode,[]):
context.processorNss = patternInfo[PatternInfo.NSS]
pattern = patternInfo[PatternInfo.PATTERN]
if pattern.match(context, context.node, patternInfo[PatternInfo.AXIS_TYPE]):
patternInfo[PatternInfo.TEMPLATE].instantiate(context, processor, params)
break
else:
for imported in self._imports:
if imported.stylesheet.applyTemplates(context, mode,
processor, params):
break
else:
matched = 0
context.setStylesheet(origState)
return matched
def applyImports(self, context, mode, processor, params=None):
params = params or {}
for imp in self._imports:
matched = imp.stylesheet.applyTemplates(context, mode, processor, params)
if matched: return 1
return 0
def callTemplate(self, processor, name, context, params, new_level=1):
vars = self._primedContext.varBindings.copy()
vars.update(params)
origState = context.copyStylesheet()
context.setStylesheet((vars, self.namespaces, self))
matched = 0
rec_tpl_params = None
tpl = self._call_templates.get(name)
if tpl:
rec_tpl_params = tpl.instantiate(context, processor, params, new_level)[1]
else:
for child in self._imports:
(matched, rec_tpl_params) = child.stylesheet.callTemplate(processor, name, context, params, new_level)
if matched: break
context.setStylesheet(origState)
return (matched, rec_tpl_params)
def reclaim(self):
self.__dict__['_primedContext'] = None
for imp in self._imports:
imp.stylesheet.reclaim()
ReleaseNode(imp.stylesheet.ownerDocument)
self.namespaces = xml.dom.ext.GetAllNs(self)
self.spaceRules = {}
self.namespaceAliases = ({}, {})
self.decimalFormats = {'': ('.', ',', 'Infinity', '-', 'NaN', '%', '?', '0', '#', ';')}
self.keys = {}
self.outputParams = OutputParameters()
excluded_prefixes = self.getAttributeNS(EMPTY_NAMESPACE, 'exclude-result-prefixes')
self.excludedNss = []
self._lres = []
return
def __getinitargs__(self):
return (None, self.namespaceURI, self.localName, self.prefix,
self.baseUri)
def __getstate__(self):
base_state = XsltElement.__getstate__(self)
new_state = (base_state, self.namespaces, self.spaceRules,
self.namespaceAliases, self.decimalFormats,
self.keys, self.outputParams, self.excludedNss,
self._patterns, self._call_templates, self._kelems, self.extensionNss,
self._topVariables)
return new_state
def __setstate__(self, state):
XsltElement.__setstate__(self, state[0])
self.namespaces = state[1]
self.spaceRules = state[2]
self.namespaceAliases = state[3]
self.decimalFormats = state[4]
self.keys = state[5]
self.outputParams = state[6]
self.excludedNss = state[7]
self._patterns = state[8]
self._call_templates = state[9]
self._kelems = state[10]
self.extensionNss = state[11]
self._topVariables = state[12]
return
|