path: root/xml/xslt/Stylesheet.py

########################################################################
#
# 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