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

   1 package org.cacert.gigi.output;
   2
   3 import java.io.EOFException;
   4 import java.io.IOException;
   5 import java.io.PrintWriter;
   6 import java.io.Reader;
   7 import java.util.LinkedList;
   8 import java.util.Map;
   9
  10 import org.cacert.gigi.Language;
  11
  12 public class Template implements Outputable {
  13         String[] contents;
  14         Outputable[] vars;
  15
  16         public Template(Reader r) {
  17                 try {
  18                         LinkedList<String> splitted = new LinkedList<String>();
  19                         LinkedList<Outputable> commands = new LinkedList<Outputable>();
  20                         StringBuffer buf = new StringBuffer();
  21                         int ch = r.read();
  22                         outer : while (true) {
  23                                 while (!endsWith(buf, "<?")) {
  24                                         if (ch == -1) {
  25                                                 break outer;
  26                                         }
  27                                         buf.append((char) ch);
  28                                         ch = r.read();
  29                                 }
  30                                 buf.delete(buf.length() - 2, buf.length());
  31                                 splitted.add(buf.toString());
  32                                 buf.delete(0, buf.length());
  33                                 while (!endsWith(buf, "?>")) {
  34                                         buf.append((char) ch);
  35                                         ch = r.read();
  36                                         if (ch == -1) {
  37                                                 throw new EOFException();
  38                                         }
  39                                 }
  40                                 buf.delete(buf.length() - 2, buf.length());
  41                                 commands.add(parseCommand(buf.toString()));
  42                                 buf.delete(0, buf.length());
  43                         }
  44                         splitted.add(buf.toString());
  45                         contents = splitted.toArray(new String[splitted.size()]);
  46                         vars = commands.toArray(new Outputable[commands.size()]);
  47                         r.close();
  48                 } catch (IOException e) {
  49                         throw new Error(e);
  50                 }
  51         }
  52         private boolean endsWith(StringBuffer buf, String string) {
  53                 return buf.length() >= string.length()
  54                                 && buf.substring(buf.length() - string.length(), buf.length())
  55                                                 .equals(string);
  56         }
  57         private Outputable parseCommand(String s2) {
  58                 s2 = s2.replace("\n", "");
  59                 if (s2.startsWith("=_")) {
  60                         final String raw = s2.substring(2);
  61                         return new Outputable() {
  62
  63                                 @Override
  64                                 public void output(PrintWriter out, Language l,
  65                                                 Map<String, Object> vars) {
  66                                         out.print(l.getTranslation(raw));
  67                                 }
  68                         };
  69                 } else if (s2.startsWith("=$")) {
  70                         final String raw = s2.substring(2);
  71                         return new Outputable() {
  72
  73                                 @Override
  74                                 public void output(PrintWriter out, Language l,
  75                                                 Map<String, Object> vars) {
  76                                         outputVar(out, l, vars, raw);
  77                                 }
  78                         };
  79                 } else if (s2.startsWith("=s,")) {
  80                         String command = s2.substring(3);
  81                         final LinkedList<String> store = new LinkedList<String>();
  82                         while (command.startsWith("$")) {
  83                                 int idx = command.indexOf(",");
  84                                 store.add(command.substring(0, idx));
  85                                 command = command.substring(idx + 1);
  86                         }
  87                         final String text = command;
  88                         return new Outputable() {
  89
  90                                 @Override
  91                                 public void output(PrintWriter out, Language l,
  92                                                 Map<String, Object> vars) {
  93                                         String[] parts = l.getTranslation(text).split("%s");
  94                                         String[] myvars = store.toArray(new String[store.size()]);
  95                                         out.print(parts[0]);
  96                                         for (int j = 1; j < parts.length; j++) {
  97                                                 outputVar(out, l, vars, myvars[j - 1].substring(1));
  98                                                 out.print(parts[j]);
  99                                         }
 100                                 }
 101                         };
 102                 } else {
 103                         System.out.println("Unknown processing instruction: " + s2);
 104                 }
 105                 return null;
 106         }
 107         public void output(PrintWriter out, Language l, Map<String, Object> vars) {
 108                 for (int i = 0; i < contents.length; i++) {
 109                         out.print(contents[i]);
 110                         if (i < this.vars.length) {
 111                                 this.vars[i].output(out, l, vars);
 112                         }
 113                 }
 114         }
 115         private void outputVar(PrintWriter out, Language l,
 116                         Map<String, Object> vars, String varname) {
 117                 Object s = vars.get(varname);
 118
 119                 if (s == null) {
 120                         System.out.println("Empty variable: " + varname);
 121                 }
 122                 if (s instanceof Outputable) {
 123                         ((Outputable) s).output(out, l, vars);
 124                 } else {
 125                         out.print(s);
 126                 }
 127         }
 128 }