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

   1 package org.cacert.gigi.output;
   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
  20 public class Template implements Outputable {
  21         static class TemplateBlock implements Outputable {
  22                 String[] contents;
  23                 Outputable[] vars;
  24
  25                 public TemplateBlock(String[] contents, Outputable[] vars) {
  26                         this.contents = contents;
  27                         this.vars = vars;
  28                 }
  29
  30                 @Override
  31                 public void output(PrintWriter out, Language l, Map<String, Object> vars) {
  32                         for (int i = 0; i < contents.length; i++) {
  33                                 out.print(contents[i]);
  34                                 if (i < this.vars.length) {
  35                                         this.vars[i].output(out, l, vars);
  36                                 }
  37                         }
  38                 }
  39
  40         }
  41
  42         TemplateBlock data;
  43
  44         long lastLoaded;
  45         File source;
  46
  47         private static final Pattern IF_PATTERN = Pattern.compile(" ?if\\(\\$([^)]+)\\) ?\\{ ?");
  48
  49         public Template(URL u) {
  50                 try {
  51                         Reader r = new InputStreamReader(u.openStream(), "UTF-8");
  52                         try {
  53                                 if (u.getProtocol().equals("file") && DevelLauncher.DEVEL) {
  54                                         source = new File(u.toURI());
  55                                         lastLoaded = source.lastModified() + 1000;
  56                                 }
  57                         } catch (URISyntaxException e) {
  58                                 e.printStackTrace();
  59                         }
  60                         data = parse(r);
  61                         r.close();
  62                 } catch (IOException e) {
  63                         throw new Error(e);
  64                 }
  65         }
  66
  67         public Template(Reader r) {
  68                 try {
  69                         data = parse(r);
  70                         r.close();
  71                 } catch (IOException e) {
  72                         throw new Error(e);
  73                 }
  74         }
  75
  76         private TemplateBlock parse(Reader r) throws IOException {
  77                 LinkedList<String> splitted = new LinkedList<String>();
  78                 LinkedList<Outputable> commands = new LinkedList<Outputable>();
  79                 StringBuffer buf = new StringBuffer();
  80                 int ch = r.read();
  81                 outer: while (true) {
  82                         while (!endsWith(buf, "<?")) {
  83                                 if (ch == -1) {
  84                                         break outer;
  85                                 }
  86                                 buf.append((char) ch);
  87                                 ch = r.read();
  88                         }
  89                         buf.delete(buf.length() - 2, buf.length());
  90                         splitted.add(buf.toString());
  91                         buf.delete(0, buf.length());
  92                         while (!endsWith(buf, "?>")) {
  93                                 buf.append((char) ch);
  94                                 ch = r.read();
  95                                 if (ch == -1) {
  96                                         throw new EOFException();
  97                                 }
  98                         }
  99                         buf.delete(buf.length() - 2, buf.length());
 100                         String com = buf.toString().replace("\n", "");
 101                         buf.delete(0, buf.length());
 102                         Matcher m = IF_PATTERN.matcher(com);
 103                         if (m.matches()) {
 104                                 final String variable = m.group(1);
 105                                 final TemplateBlock body = parse(r);
 106                                 commands.add(new Outputable() {
 107
 108                                         @Override
 109                                         public void output(PrintWriter out, Language l, Map<String, Object> vars) {
 110                                                 Object o = vars.get(variable);
 111                                                 if (o instanceof Boolean && o == Boolean.TRUE) {
 112                                                         body.output(out, l, vars);
 113                                                 }
 114                                         }
 115                                 });
 116                                 continue;
 117                         }
 118                         if (com.matches(" ?\\} ?")) {
 119                                 break;
 120                         }
 121                         commands.add(parseCommand(com));
 122                 }
 123                 splitted.add(buf.toString());
 124                 String[] contents = splitted.toArray(new String[splitted.size()]);
 125                 Outputable[] vars = commands.toArray(new Outputable[commands.size()]);
 126                 return new TemplateBlock(contents, vars);
 127         }
 128
 129         private boolean endsWith(StringBuffer buf, String string) {
 130                 return buf.length() >= string.length()
 131                         && buf.substring(buf.length() - string.length(), buf.length()).equals(string);
 132         }
 133
 134         private Outputable parseCommand(String s2) {
 135                 if (s2.startsWith("=_")) {
 136                         final String raw = s2.substring(2);
 137                         return new Outputable() {
 138
 139                                 @Override
 140                                 public void output(PrintWriter out, Language l, Map<String, Object> vars) {
 141                                         out.print(l.getTranslation(raw));
 142                                 }
 143                         };
 144                 } else if (s2.startsWith("=$")) {
 145                         final String raw = s2.substring(2);
 146                         return new Outputable() {
 147
 148                                 @Override
 149                                 public void output(PrintWriter out, Language l, Map<String, Object> vars) {
 150                                         outputVar(out, l, vars, raw);
 151                                 }
 152                         };
 153                 } else if (s2.startsWith("=s,")) {
 154                         String command = s2.substring(3);
 155                         final LinkedList<String> store = new LinkedList<String>();
 156                         while (command.startsWith("$")) {
 157                                 int idx = command.indexOf(",");
 158                                 store.add(command.substring(0, idx));
 159                                 command = command.substring(idx + 1);
 160                         }
 161                         final String text = command;
 162                         return new Outputable() {
 163
 164                                 @Override
 165                                 public void output(PrintWriter out, Language l, Map<String, Object> vars) {
 166                                         String[] parts = l.getTranslation(text).split("%s");
 167                                         String[] myvars = store.toArray(new String[store.size()]);
 168                                         out.print(parts[0]);
 169                                         for (int j = 1; j < parts.length; j++) {
 170                                                 outputVar(out, l, vars, myvars[j - 1].substring(1));
 171                                                 out.print(parts[j]);
 172                                         }
 173                                 }
 174                         };
 175                 } else {
 176                         System.out.println("Unknown processing instruction: " + s2);
 177                 }
 178                 return null;
 179         }
 180
 181         public void output(PrintWriter out, Language l, Map<String, Object> vars) {
 182                 if (source != null && DevelLauncher.DEVEL) {
 183                         if (lastLoaded < source.lastModified()) {
 184                                 try {
 185                                         System.out.println("Reloading template.... " + source);
 186                                         InputStreamReader r = new InputStreamReader(new FileInputStream(source), "UTF-8");
 187                                         parse(r);
 188                                         r.close();
 189                                         lastLoaded = source.lastModified() + 1000;
 190                                 } catch (IOException e) {
 191                                         e.printStackTrace();
 192                                 }
 193                         }
 194                 }
 195                 data.output(out, l, vars);
 196         }
 197
 198         private void outputVar(PrintWriter out, Language l, Map<String, Object> vars, String varname) {
 199                 Object s = vars.get(varname);
 200
 201                 if (s == null) {
 202                         System.out.println("Empty variable: " + varname);
 203                 }
 204                 if (s instanceof Outputable) {
 205                         ((Outputable) s).output(out, l, vars);
 206                 } else {
 207                         out.print(s);
 208                 }
 209         }
 210 }