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

   1 package org.cacert.gigi.output;
   2
   3 import java.io.PrintWriter;
   4 import java.io.Reader;
   5 import java.util.LinkedList;
   6 import java.util.Map;
   7 import java.util.Scanner;
   8 import java.util.regex.Pattern;
   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                 LinkedList<String> splitted = new LinkedList<String>();
  18                 LinkedList<Outputable> commands = new LinkedList<Outputable>();
  19                 Scanner sc = new Scanner(r);
  20                 Pattern p1 = Pattern.compile("([^<]|<[^?])*<\\?");
  21                 Pattern p2 = Pattern.compile("([^<]|<[^?])*\\?>");
  22                 while (true) {
  23                         String s1 = sc.findWithinHorizon(p1, 0);
  24                         if (s1 == null) {
  25                                 break;
  26                         }
  27                         s1 = s1.substring(0, s1.length() - 2);
  28                         splitted.add(s1);
  29                         String s2 = sc.findWithinHorizon(p2, 0);
  30                         s2 = s2.substring(0, s2.length() - 2);
  31                         commands.add(parseCommand(s2));
  32                 }
  33                 sc.useDelimiter("\0");
  34                 if (sc.hasNext()) {
  35                         splitted.add(sc.next());
  36                 }
  37                 sc.close();
  38                 contents = splitted.toArray(new String[splitted.size()]);
  39                 vars = commands.toArray(new Outputable[commands.size()]);
  40         }
  41         private Outputable parseCommand(String s2) {
  42                 if (s2.startsWith("=_")) {
  43                         final String raw = s2.substring(2);
  44                         return new Outputable() {
  45
  46                                 @Override
  47                                 public void output(PrintWriter out, Language l,
  48                                                 Map<String, Object> vars) {
  49                                         out.print(l.getTranslation(raw));
  50                                 }
  51                         };
  52                 } else if (s2.startsWith("=$")) {
  53                         final String raw = s2.substring(2);
  54                         return new Outputable() {
  55
  56                                 @Override
  57                                 public void output(PrintWriter out, Language l,
  58                                                 Map<String, Object> vars) {
  59                                         outputVar(out, l, vars, raw);
  60                                 }
  61                         };
  62                 } else if (s2.startsWith("=s,")) {
  63                         String command = s2.substring(3);
  64                         final LinkedList<String> store = new LinkedList<String>();
  65                         while (command.startsWith("$")) {
  66                                 int idx = command.indexOf(",");
  67                                 store.add(command.substring(0, idx));
  68                                 command = command.substring(idx + 1);
  69                         }
  70                         final String text = command;
  71                         return new Outputable() {
  72
  73                                 @Override
  74                                 public void output(PrintWriter out, Language l,
  75                                                 Map<String, Object> vars) {
  76                                         String[] parts = l.getTranslation(text).split("%s");
  77                                         String[] myvars = store.toArray(new String[store.size()]);
  78                                         out.print(parts[0]);
  79                                         for (int j = 1; j < parts.length; j++) {
  80                                                 outputVar(out, l, vars, myvars[j - 1].substring(1));
  81                                                 out.print(parts[j]);
  82                                         }
  83                                 }
  84                         };
  85                 } else {
  86                         System.out.println("Unknown processing instruction: " + s2);
  87                 }
  88                 return null;
  89         }
  90         public void output(PrintWriter out, Language l, Map<String, Object> vars) {
  91                 for (int i = 0; i < contents.length; i++) {
  92                         out.print(contents[i]);
  93                         if (i < this.vars.length) {
  94                                 this.vars[i].output(out, l, vars);
  95                         }
  96                 }
  97         }
  98         private void outputVar(PrintWriter out, Language l,
  99                         Map<String, Object> vars, String varname) {
 100                 Object s = vars.get(varname);
 101
 102                 if (s == null) {
 103                         System.out.println("Empty variable: " + varname);
 104                 }
 105                 if (s instanceof Outputable) {
 106                         ((Outputable) s).output(out, l, vars);
 107                 } else {
 108                         out.print(s);
 109                 }
 110         }
 111 }