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