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