src/org/cacert/gigi/output/template/Template.java

   1 package org.cacert.gigi.output.template;
   2
   3 import java.io.EOFException;
   4 import java.io.File;
   5 import java.io.FileInputStream;
   6 import java.io.IOException;
   7 import java.io.InputStreamReader;
   8 import java.io.PrintWriter;
   9 import java.io.Reader;
  10 import java.net.URISyntaxException;
  11 import java.net.URL;
  12 import java.util.LinkedList;
  13 import java.util.Map;
  14 import java.util.regex.Matcher;
  15 import java.util.regex.Pattern;
  16
  17 import org.cacert.gigi.DevelLauncher;
  18 import org.cacert.gigi.Language;
  19 import org.cacert.gigi.output.Outputable;
  20
  21 public class Template implements Outputable {
  22         TemplateBlock data;
  23
  24         long lastLoaded;
  25         File source;
  26
  27         private static final Pattern CONTROL_PATTERN = Pattern.compile(" ?([a-z]+)\\(\\$([^)]+)\\) ?\\{ ?");
  28
  29         public Template(URL u) {
  30                 try {
  31                         Reader r = new InputStreamReader(u.openStream(), "UTF-8");
  32                         try {
  33                                 if (u.getProtocol().equals("file") && DevelLauncher.DEVEL) {
  34                                         source = new File(u.toURI());
  35                                         lastLoaded = source.lastModified() + 1000;
  36                                 }
  37                         } catch (URISyntaxException e) {
  38                                 e.printStackTrace();
  39                         }
  40                         data = parse(r);
  41                         r.close();
  42                 } catch (IOException e) {
  43                         throw new Error(e);
  44                 }
  45         }
  46
  47         public Template(Reader r) {
  48                 try {
  49                         data = parse(r);
  50                         r.close();
  51                 } catch (IOException e) {
  52                         throw new Error(e);
  53                 }
  54         }
  55
  56         private TemplateBlock parse(Reader r) throws IOException {
  57                 LinkedList<String> splitted = new LinkedList<String>();
  58                 LinkedList<Outputable> commands = new LinkedList<Outputable>();
  59                 StringBuffer buf = new StringBuffer();
  60                 int ch = r.read();
  61                 outer: while (true) {
  62                         while (!endsWith(buf, "<?")) {
  63                                 if (ch == -1) {
  64                                         break outer;
  65                                 }
  66                                 buf.append((char) ch);
  67                                 ch = r.read();
  68                         }
  69                         buf.delete(buf.length() - 2, buf.length());
  70                         splitted.add(buf.toString());
  71                         buf.delete(0, buf.length());
  72                         while (!endsWith(buf, "?>")) {
  73                                 buf.append((char) ch);
  74                                 ch = r.read();
  75                                 if (ch == -1) {
  76                                         throw new EOFException();
  77                                 }
  78                         }
  79                         buf.delete(buf.length() - 2, buf.length());
  80                         String com = buf.toString().replace("\n", "");
  81                         buf.delete(0, buf.length());
  82                         Matcher m = CONTROL_PATTERN.matcher(com);
  83                         if (m.matches()) {
  84                                 String type = m.group(1);
  85                                 String variable = m.group(2);
  86                                 TemplateBlock body = parse(r);
  87                                 if (type.equals("if")) {
  88                                         commands.add(new IfStatement(variable, body));
  89                                 } else if (type.equals("foreach")) {
  90                                         commands.add(new ForeachStatement(variable, body));
  91                                 } else {
  92                                         throw new IOException("Syntax error: unknown control structure: " + type);
  93                                 }
  94                                 continue;
  95                         }
  96                         if (com.matches(" ?\\} ?")) {
  97                                 break;
  98                         }
  99                         commands.add(parseCommand(com));
 100                 }
 101                 splitted.add(buf.toString());
 102                 String[] contents = splitted.toArray(new String[splitted.size()]);
 103                 Outputable[] vars = commands.toArray(new Outputable[commands.size()]);
 104                 return new TemplateBlock(contents, vars);
 105         }
 106
 107         private boolean endsWith(StringBuffer buf, String string) {
 108                 return buf.length() >= string.length()
 109                         && buf.substring(buf.length() - string.length(), buf.length()).equals(string);
 110         }
 111
 112         private Outputable parseCommand(String s2) {
 113                 if (s2.startsWith("=_")) {
 114                         final String raw = s2.substring(2);
 115                         return new TranslateCommand(raw);
 116                 } else if (s2.startsWith("=$")) {
 117                         final String raw = s2.substring(2);
 118                         return new OutputVariableCommand(raw);
 119                 } else if (s2.startsWith("=s,")) {
 120                         String command = s2.substring(3);
 121                         final LinkedList<String> store = new LinkedList<String>();
 122                         while (command.startsWith("$")) {
 123                                 int idx = command.indexOf(",");
 124                                 store.add(command.substring(0, idx));
 125                                 command = command.substring(idx + 1);
 126                         }
 127                         final String text = command;
 128                         return new SprintfCommand(text, store);
 129                 } else {
 130                         System.out.println("Unknown processing instruction: " + s2);
 131                 }
 132                 return null;
 133         }
 134
 135         public void output(PrintWriter out, Language l, Map<String, Object> vars) {
 136                 if (source != null && DevelLauncher.DEVEL) {
 137                         if (lastLoaded < source.lastModified()) {
 138                                 try {
 139                                         System.out.println("Reloading template.... " + source);
 140                                         InputStreamReader r = new InputStreamReader(new FileInputStream(source), "UTF-8");
 141                                         parse(r);
 142                                         r.close();
 143                                         lastLoaded = source.lastModified() + 1000;
 144                                 } catch (IOException e) {
 145                                         e.printStackTrace();
 146                                 }
 147                         }
 148                 }
 149                 data.output(out, l, vars);
 150         }
 151
 152         protected static void outputVar(PrintWriter out, Language l, Map<String, Object> vars, String varname) {
 153                 Object s = vars.get(varname);
 154
 155                 if (s == null) {
 156                         System.out.println("Empty variable: " + varname);
 157                 }
 158                 if (s instanceof Outputable) {
 159                         ((Outputable) s).output(out, l, vars);
 160                 } else {
 161                         out.print(s);
 162                 }
 163         }
 164 }