def setup(self):
self.__dict__['_nss'] = xml.dom.ext.GetAllNs(self)
mode_attr = self.getAttributeNS(EMPTY_NAMESPACE, 'mode')
if mode_attr == '':
self.__dict__['_mode'] = None
else:
split_name = Util.ExpandQName(mode_attr, namespaces=self._nss)
self.__dict__['_mode'] = split_name
select = self.getAttributeNS(EMPTY_NAMESPACE, 'select')
if select:
parser = XPathParser.XPathParser()
self.__dict__['_expr'] = parser.parseExpression(select)
else:
self.__dict__['_expr'] = None
self.__dict__['_sortSpecs'] = []
self.__dict__['_params'] = []
for child in self.childNodes:
#All children should be sort and with-param
if child.namespaceURI == XSL_NAMESPACE:
if child.localName == 'sort':
self._sortSpecs.append(child)
elif child.localName == 'with-param':
self._params.append(child)
else:
raise XsltException(Error.ILLEGAL_APPLYTEMPLATE_CHILD)
else:
raise XsltException(Error.ILLEGAL_APPLYTEMPLATE_CHILD)
return
def setup(self):
self.__dict__['_test'] = self.getAttributeNS(EMPTY_NAMESPACE, 'test')
if not self._test:
raise XsltException(Error.WHEN_MISSING_TEST)
self.__dict__['_nss'] = xml.dom.ext.GetAllNs(self)
parser = XPathParser.XPathParser()
self.__dict__['_expr'] = parser.parseExpression(self._test)
return
def setup(self):
ApplyTemplatesElement.ApplyTemplatesElement.setup(self)
#Overwrite the mode
mode_attr = self.getAttributeNS(EMPTY_NAMESPACE, 'mode')
if mode_attr != '':
parser = XPathParser.XPathParser()
self.__dict__['_mode'] = parser.parseExpression(mode_attr)
def setup(self):
parser = XPathParser.XPathParser()
self.__dict__['_select'] = self.getAttributeNS(EMPTY_NAMESPACE,
'select')
if not self._select:
raise XsltException(Error.COPYOF_MISSING_SELECT)
self.__dict__['_expr'] = parser.parseExpression(self._select)
self.__dict__['_nss'] = xml.dom.ext.GetAllNs(self)
return
def setup(self):
self.__dict__['_select'] = self.getAttributeNS(EMPTY_NAMESPACE,
'select')
if not self._select:
raise XsltException(Error.VALUEOF_MISSING_SELECT)
self.__dict__['_disable_output_escaping'] = self.getAttributeNS(
EMPTY_NAMESPACE, 'disable-output-escaping') == 'yes'
self.__dict__['_nss'] = xml.dom.ext.GetAllNs(self)
parser = XPathParser.XPathParser()
self.__dict__['_expr'] = parser.parseExpression(self._select)
return
def setup(self):
self._nss = xml.dom.ext.GetAllNs(self)
name_attr = self.getAttributeNS(EMPTY_NAMESPACE, 'name')
split_name = Util.ExpandQName(name_attr, namespaces=self._nss)
self._name = split_name
self._select = self.getAttributeNS(EMPTY_NAMESPACE, 'select')
if self._select:
parser = XPathParser.XPathParser()
self._expr = parser.parseExpression(self._select)
else:
self._expr = None
return
def setup(self):
parser = XPathParser.XPathParser()
self.__dict__['_test'] = self.getAttributeNS(EMPTY_NAMESPACE, 'test')
self.__dict__['_nss'] = xml.dom.ext.GetAllNs(self)
self.__dict__['_expr'] = parser.parseExpression(self._test)
self.__dict__['_elements'] = []
for child in self.childNodes:
if (child.namespaceURI == XSL_NAMESPACE
and child.localName in ['call-template', 'if', 'choose']):
self.__dict__['_elements'].append((1, child))
else:
self.__dict__['_elements'].append((0, child))
return
def _parse(self):
parser = XPathParser.XPathParser()
curr_plain_part = ''
curr_template_part = ''
in_plain_part = 1
split_form = re.split(g_braceSplitPattern, self.source)
skip_flag = 0
for i in range(len(split_form)):
segment = split_form[i]
if skip_flag:
skip_flag = skip_flag - 1
continue
if segment in ['{', '}']:
#Here we are accounting for a possible blank segment in between
try:
next = split_form[i + 1] + split_form[i + 2]
except IndexError:
next = None
if next == segment:
if in_plain_part:
curr_plain_part = curr_plain_part + segment
else:
curr_template_part = curr_template_part + segment
skip_flag = 2
elif segment == '{':
if in_plain_part:
self._plainParts.append(curr_plain_part)
in_plain_part = 0
curr_plain_part = ''
else:
raise XsltException(Error.AVT_SYNTAX)
else:
if not in_plain_part:
parsed = parser.parseExpression(curr_template_part)
self._parsedParts.append(parsed)
in_plain_part = 1
curr_template_part = ''
else:
raise XsltException(Error.AVT_SYNTAX)
else:
if in_plain_part:
curr_plain_part = curr_plain_part + segment
else:
curr_template_part = curr_template_part + segment
if in_plain_part:
self._plainParts.append(curr_plain_part)
else:
raise XsltException(Error.AVT_SYNTAX)
def setup(self):
self.__dict__['_select'] = self.getAttributeNS(EMPTY_NAMESPACE, 'select')
self.__dict__['_nss'] = xml.dom.ext.GetAllNs(self)
if self._select:
parser = XPathParser.XPathParser()
self.__dict__['_expr'] = parser.parseExpression(self._select)
else:
self.__dict__['_expr'] = None
self.__dict__['_sortSpecs'] = []
for child in self.childNodes:
if (child.namespaceURI, child.localName) == (XSL_NAMESPACE, 'sort'):
self._sortSpecs.append(child)
return
def setup(self):
self.__dict__['_select'] = self.getAttributeNS(EMPTY_NAMESPACE,
'select') or '.'
data_type = self.getAttributeNS(EMPTY_NAMESPACE, 'data-type')
self.__dict__[
'_data_type'] = data_type and AttributeValueTemplate.AttributeValueTemplate(
data_type) or None
case_order = self.getAttributeNS(EMPTY_NAMESPACE, 'case-order')
self.__dict__[
'_case_order'] = case_order and AttributeValueTemplate.AttributeValueTemplate(
case_order) or None
order = self.getAttributeNS(EMPTY_NAMESPACE, 'order')
self.__dict__[
'_order'] = order and AttributeValueTemplate.AttributeValueTemplate(
order) or None
self.__dict__['_nss'] = xml.dom.ext.GetAllNs(self)
parser = XPathParser.XPathParser()
self.__dict__['_expr'] = parser.parseExpression(self._select)
return
def setup(self):
self._nss = {}
self._level = None
self._count = None
self._from = None
self._value = None
self._format = None
self._lang = None
self._letter_value = None
self._grouping_separator = None
self._grouping_size = None
self._value_expr = None
self._sibling_expr = None
self._count_prior_doc_order_expr = None
self._count_pattern = None
self._ancorself_expr = None
path_parser = XPathParser.XPathParser()
pattern_parser = XPatternParser.XPatternParser()
self.__dict__['_level'] = self.getAttributeNS(EMPTY_NAMESPACE,
'level') or 'single'
if self._level not in ['single', 'multiple', 'any']:
raise XsltException(Error.ILLEGAL_NUMBER_LEVEL_VALUE)
self.__dict__['_count'] = self.getAttributeNS(EMPTY_NAMESPACE, 'count')
self.__dict__['_from'] = self.getAttributeNS(EMPTY_NAMESPACE, 'from')
self.__dict__['_value'] = self.getAttributeNS(EMPTY_NAMESPACE, 'value')
format = self.getAttributeNS(EMPTY_NAMESPACE, 'format')
self.__dict__[
'_format'] = format and AttributeValueTemplate.AttributeValueTemplate(
format) or None
lang = self.getAttributeNS(EMPTY_NAMESPACE, 'lang')
self.__dict__[
'_lang'] = lang and AttributeValueTemplate.AttributeValueTemplate(
lang) or None
letter_value = self.getAttributeNS(EMPTY_NAMESPACE, 'letter-value')
self.__dict__[
'_letter_value'] = letter_value and AttributeValueTemplate.AttributeValueTemplate(
letter_value) or None
grouping_separator = self.getAttributeNS(EMPTY_NAMESPACE,
'grouping-separator')
self.__dict__[
'_grouping_separator'] = grouping_separator and AttributeValueTemplate.AttributeValueTemplate(
grouping_separator) or None
grouping_size = self.getAttributeNS(EMPTY_NAMESPACE, 'grouping-size')
self.__dict__[
'_grouping_size'] = grouping_size and AttributeValueTemplate.AttributeValueTemplate(
grouping_size) or None
self.__dict__['_nss'] = xml.dom.ext.GetAllNs(self)
#Prep computations
if not self._count:
#FIXME: Handle other node types????
self._count = '*[name()=name(current())]'
self._count_pattern = pattern_parser.parsePattern(self._count)
ancestor_or_self = "ancestor-or-self::node()"
if self._from:
ancestor_or_self = ancestor_or_self + '[ancestor::%s]' % (
self._from)
self._ancorself_expr = path_parser.parseExpression(ancestor_or_self)
if self._value:
self._value_expr = path_parser.parseExpression(self._value)
self._sibling_expr = None
self._count_prior_doc_order_expr = None
else:
self._sibling_expr = path_parser.parseExpression(
'preceding-sibling::node()')
patterns = pattern_parser.parsePattern(self._count)._patterns
count_prior_doc_order = ''
if self._from:
froms = pattern_parser.parsePattern(self._from)._patterns
pred = "["
for fro in froms:
pred = pred + 'ancestor::' + repr(fro)
if fro != froms[-1]:
pred = pred + '|'
pred = pred + ']'
for count in patterns:
if self._from:
count_prior_doc_order = count_prior_doc_order + 'ancestor-or-self::' + repr(
count) + pred + '|preceding::' + repr(count) + pred
else:
count_prior_doc_order = count_prior_doc_order + 'ancestor-or-self::' + repr(
count) + '|preceding::' + repr(count)
if count != patterns[-1]:
count_prior_doc_order = count_prior_doc_order + '|'
self._count_prior_doc_order_expr = path_parser.parseExpression(
count_prior_doc_order)
return