add: improvement of template parsing
[gigi.git] / src / org / cacert / gigi / output / template / Template.java
1 package org.cacert.gigi.output.template;
2
3 import java.io.File;
4 import java.io.FileInputStream;
5 import java.io.IOException;
6 import java.io.InputStreamReader;
7 import java.io.PrintWriter;
8 import java.io.Reader;
9 import java.net.URISyntaxException;
10 import java.net.URL;
11 import java.text.SimpleDateFormat;
12 import java.util.Arrays;
13 import java.util.Collection;
14 import java.util.Date;
15 import java.util.LinkedList;
16 import java.util.Map;
17 import java.util.regex.Matcher;
18 import java.util.regex.Pattern;
19
20 import org.cacert.gigi.localisation.Language;
21 import org.cacert.gigi.output.DateSelector;
22 import org.cacert.gigi.util.DayDate;
23 import org.cacert.gigi.util.EditDistance;
24 import org.cacert.gigi.util.HTMLEncoder;
25
26 /**
27  * Represents a loaded template file.
28  */
29 public class Template implements Outputable {
30
31     protected static class ParseResult {
32
33         TemplateBlock block;
34
35         String endType;
36
37         public ParseResult(TemplateBlock block, String endType) {
38             this.block = block;
39             this.endType = endType;
40         }
41
42         public String getEndType() {
43             return endType;
44         }
45
46         public TemplateBlock getBlock(String reqType) {
47             if (endType == null && reqType == null) {
48                 return block;
49             }
50             if (endType == null || reqType == null) {
51                 throw new Error("Invalid block type: " + endType);
52             }
53             if (endType.equals(reqType)) {
54                 return block;
55             }
56             throw new Error("Invalid block type: " + endType);
57         }
58     }
59
60     private TemplateBlock data;
61
62     private long lastLoaded;
63
64     private File source;
65
66     private static final Pattern CONTROL_PATTERN = Pattern.compile(" ?([a-zA-Z]+)\\(\\$([^)]+)\\) ?\\{ ?");
67
68     private static final Pattern ELSE_PATTERN = Pattern.compile(" ?\\} ?else ?\\{ ?");
69
70     private static final String[] POSSIBLE_CONTROL_PATTERNS = new String[] {
71             "if", "else", "foreach"
72     };
73
74     private static final String UNKOWN_CONTROL_STRUCTURE_MSG = "Unknown control structure \"%s\", did you mean \"%s\"?";
75
76     /**
77      * Creates a new template by parsing the contents from the given URL. This
78      * constructor will fail on syntax error. When the URL points to a file,
79      * {@link File#lastModified()} is monitored for changes of the template.
80      * 
81      * @param u
82      *            the URL to load the template from. UTF-8 is chosen as charset.
83      */
84     public Template(URL u) {
85         try (Reader r = new InputStreamReader(u.openStream(), "UTF-8")) {
86             try {
87                 if (u.getProtocol().equals("file")) {
88                     source = new File(u.toURI());
89                     lastLoaded = source.lastModified() + 1000;
90                 }
91             } catch (URISyntaxException e) {
92                 e.printStackTrace();
93             }
94             data = parse(r).getBlock(null);
95         } catch (IOException e) {
96             throw new Error(e);
97         }
98     }
99
100     /**
101      * Creates a new template by parsing the contents from the given reader.
102      * This constructor will fail on syntax error.
103      * 
104      * @param r
105      *            the Reader containing the data.
106      */
107     public Template(Reader r) {
108         try {
109             data = parse(r).getBlock(null);
110             r.close();
111         } catch (IOException e) {
112             throw new Error(e);
113         }
114     }
115
116     protected ParseResult parse(Reader r) throws IOException {
117         return parseContent(r);
118     }
119
120     protected ParseResult parseContent(Reader r) throws IOException {
121         ParseContext context = new ParseContext(r);
122         ParseResult result = parseContent(context);
123         if (context.parseException.isEmpty()) {
124             return result;
125         }
126         while (context.curChar != -1) {
127             parseContent(context);
128         }
129         throw context.parseException;
130     }
131
132     protected ParseResult parseContent(ParseContext context) throws IOException {
133         LinkedList<String> splitted = new LinkedList<String>();
134         LinkedList<Translatable> commands = new LinkedList<Translatable>();
135         StringBuffer buf = new StringBuffer();
136         String blockType = null;
137         ParseContext tContext = null;
138         outer:
139         while (true) {
140             if (tContext != null) {
141                 context.merge(tContext);
142             }
143             while ( !endsWith(buf, "<?")) {
144                 int ch = context.read();
145                 if (ch == -1) {
146                     break outer;
147                 }
148                 buf.append((char) ch);
149                 if (endsWith(buf, "\\\n")) {
150                     buf.delete(buf.length() - 2, buf.length());
151                 }
152             }
153             tContext = context.copy();
154             buf.delete(buf.length() - 2, buf.length());
155             splitted.add(buf.toString());
156             buf.delete(0, buf.length());
157             while ( !endsWith(buf, "?>")) {
158                 int ch = context.read();
159                 if (ch == -1) {
160                     context.addError("Expected \"?>\"");
161                     return null;
162                 }
163                 buf.append((char) ch);
164             }
165             buf.delete(buf.length() - 2, buf.length());
166             String com = buf.toString().replace("\n", "");
167             buf.delete(0, buf.length());
168             Matcher m = CONTROL_PATTERN.matcher(com);
169             if (m.matches()) {
170                 String type = m.group(1);
171                 String variable = m.group(2);
172                 ParseContext bodyContext = tContext.copy();
173                 ParseResult body = parseContent(bodyContext);
174                 if (type.equals("if")) {
175                     if ("else".equals(body.getEndType())) {
176                         ParseContext bodyContext2 = bodyContext.copy();
177                         commands.add(new IfStatement(variable, body.getBlock("else"), parseContent(bodyContext).getBlock("}")));
178                         bodyContext.merge(bodyContext2);
179                     } else {
180                         commands.add(new IfStatement(variable, body.getBlock("}")));
181                     }
182                 } else if (type.equals("foreach")) {
183                     commands.add(new ForeachStatement(variable, body.getBlock("}")));
184                 } else {
185                     String bestMatching = EditDistance.getBestMatchingStringByEditDistance(type, POSSIBLE_CONTROL_PATTERNS);
186                     tContext.addError(String.format(UNKOWN_CONTROL_STRUCTURE_MSG, type, bestMatching));
187                 }
188                 tContext.merge(bodyContext);
189                 continue;
190             } else if ((m = ELSE_PATTERN.matcher(com)).matches()) {
191                 blockType = "else";
192                 break;
193             } else if (com.matches(" ?\\} ?")) {
194                 blockType = "}";
195                 break;
196             } else {
197                 commands.add(parseCommand(com, tContext));
198             }
199         }
200         if (tContext != null) {
201             context.merge(tContext);
202         }
203         splitted.add(buf.toString());
204         ParseResult result = new ParseResult(new TemplateBlock(splitted.toArray(new String[splitted.size()]), commands.toArray(new Translatable[commands.size()])), blockType);
205         return result;
206     }
207
208     private boolean endsWith(StringBuffer buf, String string) {
209         return buf.length() >= string.length() && buf.substring(buf.length() - string.length(), buf.length()).equals(string);
210     }
211
212     private Translatable parseCommand(String s2, ParseContext context) {
213         if (s2.startsWith("=_")) {
214             final String raw = s2.substring(2);
215             if ( !s2.contains("$") && !s2.contains("!'")) {
216                 return new TranslateCommand(raw);
217             } else {
218                 return new SprintfCommand(raw);
219             }
220         } else if (s2.startsWith("=$")) {
221             final String raw = s2.substring(2);
222             return new OutputVariableCommand(raw);
223         } else {
224             context.addError("Unknown processing instruction \"" + s2 + "\"," + " did you mean \"" + EditDistance.getBestMatchingStringByEditDistance(s2, new String[] {
225                     "=_", "=$"
226             }) + "\"?");
227             return null;
228         }
229     }
230
231     @Override
232     public void output(PrintWriter out, Language l, Map<String, Object> vars) {
233         tryReload();
234         data.output(out, l, vars);
235     }
236
237     protected void tryReload() {
238         if (source != null && lastLoaded < source.lastModified()) {
239             try {
240                 System.out.println("Reloading template.... " + source);
241                 InputStreamReader r = new InputStreamReader(new FileInputStream(source), "UTF-8");
242                 data = parse(r).getBlock(null);
243                 r.close();
244                 lastLoaded = source.lastModified() + 1000;
245             } catch (IOException e) {
246                 e.printStackTrace();
247             }
248         }
249     }
250
251     protected static void outputVar(PrintWriter out, Language l, Map<String, Object> vars, String varname, boolean unescaped) {
252         if (vars.containsKey(Outputable.OUT_KEY_PLAIN)) {
253             unescaped = true;
254         }
255         Object s = vars.get(varname);
256
257         if (s == null) {
258             System.err.println("Empty variable: " + varname);
259         }
260         if (s instanceof Outputable) {
261             ((Outputable) s).output(out, l, vars);
262         } else if (s instanceof DayDate) {
263             out.print(DateSelector.getDateFormat().format(((DayDate) s).toDate()));
264         } else if (s instanceof Boolean) {
265             out.print(((Boolean) s) ? l.getTranslation("yes") : l.getTranslation("no"));
266         } else if (s instanceof Date) {
267             SimpleDateFormat sdfUI = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
268             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
269             out.print("<time datetime=\"" + sdf.format(s) + "\">");
270             out.print(sdfUI.format(s));
271             out.print(" UTC</time>");
272         } else {
273             out.print(s == null ? "null" : (unescaped ? s.toString() : HTMLEncoder.encodeHTML(s.toString())));
274         }
275     }
276
277     public void addTranslations(Collection<String> s) {
278         data.addTranslations(s);
279     }
280
281     private class ParseContext {
282
283         public static final int CONTEXT_LENGTH = 20;
284
285         private Reader reader;
286
287         public final TemplateParseException parseException = new TemplateParseException(source);
288
289         int line = 1;
290
291         int column = 0;
292
293         private int curChar = -1;
294
295         private int[] charContext = new int[CONTEXT_LENGTH];
296
297         protected int contextPosition = 0;
298
299         public ParseContext(Reader reader) {
300             this.reader = reader;
301         }
302
303         public void addError(String message) {
304             addError(line, column, message);
305         }
306
307         public void addError(int line, int column, String message) {
308             StringBuffer charContextBuffer = new StringBuffer();
309             int j = contextPosition;
310             for (int i = 0; i < CONTEXT_LENGTH; i++) {
311                 if (charContext[j] != 0) {
312                     if (charContext[j] == '\n') {
313                         charContextBuffer.append("\\n");
314                     } else {
315                         charContextBuffer.appendCodePoint(charContext[j]);
316                     }
317                 }
318                 j = (j + 1) % CONTEXT_LENGTH;
319             }
320             parseException.addError(line, column, message, charContextBuffer.toString());
321         }
322
323         public void merge(ParseContext other) {
324             line = other.line;
325             column = other.column;
326             parseException.append(other.parseException);
327         }
328
329         public void append(ParseContext other) {
330             parseException.append(other.parseException);
331         }
332
333         public int read() throws IOException {
334             int ch;
335             while ((ch = reader.read()) == '\r') {
336             }
337             curChar = ch;
338             if (ch == '\n') {
339                 line++;
340                 column = 0;
341             } else {
342                 column++;
343             }
344             if (ch != -1) {
345                 charContext[contextPosition] = ch;
346                 contextPosition = (contextPosition + 1) % CONTEXT_LENGTH;
347             }
348             return ch;
349         }
350
351         public ParseContext copy() {
352             ParseContext newParseContext = new ParseContext(reader);
353             newParseContext.line = line;
354             newParseContext.column = column;
355             newParseContext.charContext = Arrays.copyOf(charContext, charContext.length);
356             newParseContext.contextPosition = contextPosition;
357             return newParseContext;
358         }
359     }
360 }