Premiere version : mise en route du suivi.
[auf_roundup.git] / roundup / cgi / TAL / TALDefs.py
1 ##############################################################################
2 #
3 # Copyright (c) 2001, 2002 Zope Corporation and Contributors.
4 # All Rights Reserved.
5 #
6 # This software is subject to the provisions of the Zope Public License,
7 # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
8 # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
9 # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10 # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
11 # FOR A PARTICULAR PURPOSE.
12 #
13 ##############################################################################
14 # Modifications for Roundup:
15 # 1. commented out ITALES references
16 """
17 Common definitions used by TAL and METAL compilation an transformation.
18 """
19
20 from types import ListType, TupleType
21
22 #from ITALES import ITALESErrorInfo
23
24 TAL_VERSION = "1.4"
25
26 XML_NS = "http://www.w3.org/XML/1998/namespace" # URI for XML namespace
27 XMLNS_NS = "http://www.w3.org/2000/xmlns/" # URI for XML NS declarations
28
29 ZOPE_TAL_NS = "http://xml.zope.org/namespaces/tal"
30 ZOPE_METAL_NS = "http://xml.zope.org/namespaces/metal"
31 ZOPE_I18N_NS = "http://xml.zope.org/namespaces/i18n"
32
33 # This RE must exactly match the expression of the same name in the
34 # zope.i18n.simpletranslationservice module:
35 NAME_RE = "[a-zA-Z_][-a-zA-Z0-9_]*"
36
37 KNOWN_METAL_ATTRIBUTES = [
38 "define-macro",
39 "use-macro",
40 "define-slot",
41 "fill-slot",
42 "slot",
43 ]
44
45 KNOWN_TAL_ATTRIBUTES = [
46 "define",
47 "condition",
48 "content",
49 "replace",
50 "repeat",
51 "attributes",
52 "on-error",
53 "omit-tag",
54 "tal tag",
55 ]
56
57 KNOWN_I18N_ATTRIBUTES = [
58 "translate",
59 "domain",
60 "target",
61 "source",
62 "attributes",
63 "data",
64 "name",
65 ]
66
67 class TALError(Exception):
68
69 def __init__(self, msg, position=(None, None)):
70 assert msg != ""
71 self.msg = msg
72 self.lineno = position[0]
73 self.offset = position[1]
74 self.filename = None
75
76 def setFile(self, filename):
77 self.filename = filename
78
79 def __str__(self):
80 result = self.msg
81 if self.lineno is not None:
82 result = result + ", at line %d" % self.lineno
83 if self.offset is not None:
84 result = result + ", column %d" % (self.offset + 1)
85 if self.filename is not None:
86 result = result + ', in file %s' % self.filename
87 return result
88
89 class METALError(TALError):
90 pass
91
92 class TALESError(TALError):
93 pass
94
95 class I18NError(TALError):
96 pass
97
98
99 class ErrorInfo:
100
101 #__implements__ = ITALESErrorInfo
102
103 def __init__(self, err, position=(None, None)):
104 if isinstance(err, Exception):
105 self.type = err.__class__
106 self.value = err
107 else:
108 self.type = err
109 self.value = None
110 self.lineno = position[0]
111 self.offset = position[1]
112
113
114
115 import re
116 _attr_re = re.compile(r"\s*([^\s]+)\s+([^\s].*)\Z", re.S)
117 _subst_re = re.compile(r"\s*(?:(text|structure)\s+)?(.*)\Z", re.S)
118 del re
119
120 def parseAttributeReplacements(arg, xml):
121 dict = {}
122 for part in splitParts(arg):
123 m = _attr_re.match(part)
124 if not m:
125 raise TALError("Bad syntax in attributes: " + `part`)
126 name, expr = m.group(1, 2)
127 if not xml:
128 name = name.lower()
129 if dict.has_key(name):
130 raise TALError("Duplicate attribute name in attributes: " + `part`)
131 dict[name] = expr
132 return dict
133
134 def parseSubstitution(arg, position=(None, None)):
135 m = _subst_re.match(arg)
136 if not m:
137 raise TALError("Bad syntax in substitution text: " + `arg`, position)
138 key, expr = m.group(1, 2)
139 if not key:
140 key = "text"
141 return key, expr
142
143 def splitParts(arg):
144 # Break in pieces at undoubled semicolons and
145 # change double semicolons to singles:
146 arg = arg.replace(";;", "\0")
147 parts = arg.split(';')
148 parts = [p.replace("\0", ";") for p in parts]
149 if len(parts) > 1 and not parts[-1].strip():
150 del parts[-1] # It ended in a semicolon
151 return parts
152
153 def isCurrentVersion(program):
154 version = getProgramVersion(program)
155 return version == TAL_VERSION
156
157 def getProgramMode(program):
158 version = getProgramVersion(program)
159 if (version == TAL_VERSION and isinstance(program[1], TupleType) and
160 len(program[1]) == 2):
161 opcode, mode = program[1]
162 if opcode == "mode":
163 return mode
164 return None
165
166 def getProgramVersion(program):
167 if (len(program) >= 2 and
168 isinstance(program[0], TupleType) and len(program[0]) == 2):
169 opcode, version = program[0]
170 if opcode == "version":
171 return version
172 return None
173
174 import re
175 _ent1_re = re.compile('&(?![A-Z#])', re.I)
176 _entch_re = re.compile('&([A-Z][A-Z0-9]*)(?![A-Z0-9;])', re.I)
177 _entn1_re = re.compile('&#(?![0-9X])', re.I)
178 _entnx_re = re.compile('&(#X[A-F0-9]*)(?![A-F0-9;])', re.I)
179 _entnd_re = re.compile('&(#[0-9][0-9]*)(?![0-9;])')
180 del re
181
182 def attrEscape(s):
183 """Replace special characters '&<>' by character entities,
184 except when '&' already begins a syntactically valid entity."""
185 s = _ent1_re.sub('&amp;', s)
186 s = _entch_re.sub(r'&amp;\1', s)
187 s = _entn1_re.sub('&amp;#', s)
188 s = _entnx_re.sub(r'&amp;\1', s)
189 s = _entnd_re.sub(r'&amp;\1', s)
190 s = s.replace('<', '&lt;')
191 s = s.replace('>', '&gt;')
192 s = s.replace('"', '&quot;')
193 return s