Parser.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.turro.elephant.impl.util;
 
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.servlet.ServletException;
import org.turro.string.Strings;
import org.jsoup.Jsoup;
import org.turro.annotation.ExternalParser;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.html.HtmlWhitelist;
import org.turro.i18n.I_;
import org.turro.parser.IParser;
import org.turro.parser.processor.MacroProcessors;
import org.turro.reflection.Instances;
import org.turro.syntax.parser.ExternalResolver;
import org.turro.syntax.parser.HtmlParser;
import org.turro.syntax.wiki.WikiDef;
 
public class Parser implements ExternalResolver {
 
  private IConstructor constructor;
  private StringBuffer buffer;
  private ExternalResolver resolver;
  
  public Parser(String text) {
    this(text, null);
  }
  
  public Parser(String text, String end) {
    int p = -1;
    if(end != null) {
      p = text.indexOf(end);
    }
    if(p > -1) {
      buffer = new StringBuffer(text.substring(0, p));
    }
    else {
      buffer = new StringBuffer(text);
    }
    // Correct lists
    if(text.startsWith("$wiki\n * ") || text.startsWith("$wiki\n 1 ")) {
      buffer.insert(6, "\n");
    }
  }
  
  public static String toWiki(String text) {
    text = Jsoup.clean(text, HtmlWhitelist.wikiSafe());
    return new HtmlParser(text).parse();
  }
  
  public void setResolver(ExternalResolver resolver) {
    this.resolver = resolver;
  }
  
  public String parse() {
    return parse(null);
  }
  
  public String parse(IConstructor constructor) {
    this.constructor = constructor;
    WikiDef wikiDef = new WikiDef();
    if(resolver != null) wikiDef.addResolver(resolver);
    wikiDef.addResolver(this);
    return wikiDef.parseBuffer(buffer);
  }
  
  public String simpleParse() {
    WikiDef wikiDef = new WikiDef();
    return wikiDef.parseBuffer(buffer);
  }
  
  public String parseThumb(String line) {
    if(constructor == null || line.indexOf("[thumb") == -1) return line;
    Pattern pat = Pattern.compile("\\[thumb (.+?)\\:([0-9]+?)(\\:[RL])?\\]");
    Matcher mat = pat.matcher(line);
    StringBuffer result = new StringBuffer();
    int dim = 0;
    while(mat.find()) {
      try {
        dim = Integer.parseInt(mat.group(2));
      } catch(Exception ex) {}
      mat.appendReplacement(
        result, 
        "<a target=\"_blank\" href=\"" + mat.group(1) + "\">" +
          "<img border=\"0\" src=\"" +
            escapeGrouping(
              new Thumbs(constructor.getRequest()).getThumb(
                mat.group(1), 
                dim, 
                mat.group(3)
              )
            ) +
          "\"/>" +
        "</a>"
      );
    }
    mat.appendTail(result);
    return result.toString();
  }
 
  public String parseMacros(String line) {
    if(constructor == null || line.indexOf("macro") == -1) return line;
    Pattern pat = Pattern.compile("macro ?\\((.*?)\\)");
    Matcher mat = pat.matcher(line);
    StringBuffer result = new StringBuffer();
    String tmp;
    while(mat.find()) {
      tmp = I_.get(mat.group(1));
      if(tmp == null) tmp = mat.group(1);
      mat.appendReplacement(result, tmp);
    }
    mat.appendTail(result);
    return result.toString();
  }
 
  @Override
  public String resolve(String text) {
    if(!constructor.isInRole("inc:new")) {
      text = text.replaceAll("\\{\\@inc", "{@---");
    }
    text = text.replaceAll(
            "grepository ?\\((.*?)\\)", 
            ElephantContext.getRootResourcePath() + 
            "/_internal/repository$1"
            );
    if(constructor.getParameter("context") != null) {
      text = text.replaceAll(
              "repository ?\\((.*?)\\)", 
              ElephantContext.getRootResourcePath() + 
              constructor.getParameter("context") + 
              "/_internal/repository$1"
              );
    }
    text = text.replaceAll(
            "pubimage ?\\((.*?)\\)", 
            ElephantContext.getRootResourcePath() + 
            "/_internal/UserFiles/Image$1"
            );
    text = text.replaceAll(
            "pubflash ?\\((.*?)\\)", 
            ElephantContext.getRootResourcePath() + 
            "/_internal/UserFiles/Flash$1"
            );
    text = text.replaceAll(
            "download ?\\((.*?)\\)",
            ElephantContext.getRootWebPath() + "/Download?down_path=$1"
            );
    text = text.replaceAll("<verbatim>", "<pre>");
    text = text.replaceAll("</verbatim>", "</pre>");
//    text = text.replaceAll("\\[download \\[(.*?)\\]\\[(.*?)\\]\\]", "<a href='" + context + "/Download?path=$1'>$2</a>");
//    text = text.replaceAll("\\[download \\[(.*?)\\](.*?)\\]", "<a href='" + context + "/Download?path=$1'>$2</a>");
    text = text.replaceAll("\\[\\[(.*?)\\]\\[(.*?)\\]\\]", "<a href='$1'>$2</a>");
    text = text.replaceAll("\\[new\\[(.*?)\\]\\[(.*?)\\]\\]", "<a class='newwindow' target='_blank' href='$1'>$2</a>");
    text = text.replaceAll("\\[ext\\[(.*?)\\]\\[(.*?)\\]\\]", "<a class='externallink' target='_blank' href='$1'>$2</a>");
    text = text.replaceAll("\\[\\[(.*?)\\]\\]", "<a href='$1'>$1</a>");
    text = text.replaceAll("\\[\\[(.*?)\\](.*?)\\]", "<a href='$1'>$2</a>");
    text = text.replaceAll("\\[new\\[(.*?)\\](.*?)\\]", "<a class='newwindow' target='_blank' href='$1'>$2</a>");
    text = text.replaceAll("\\[new\\[(.*?)\\]\\]", "<a class='newwindow' target='_blank' href='$1'>$1</a>");
    text = text.replaceAll("\\[ext\\[(.*?)\\](.*?)\\]", "<a class='externallink' target='_blank' href='$1'>$2</a>");
    text = text.replaceAll("\\[ext\\[(.*?)\\]\\]", "<a class='externallink' target='_blank' href='$1'>$1</a>");
    text = text.replaceAll("\\[color\\((.*?)\\) (.*?)\\]", "<span style='color:$1'>$2</span>");
    text = parseThumb(text);
    text = text.replaceAll("\\[frame ([^,]*?),([^,]*?),(.*?)\\]", "<iframe src='$1' style='width:$2;height:$3;border:0px solid gray'></iframe>");
    text = text.replaceAll("\\%BR\\%", "<br/>\n");
    text = Emoticons.replaceEmoticons(constructor, text);
    return text;
  }
  
  public static void processMacros(IConstructor constructor, PrintWriter out, String text) throws ServletException, IOException {
    text = MacroProcessors.full().constructor(constructor).process(text);
    if(text.indexOf("{@") > -1) {
      text = processNestedMacros(constructor, text);
      int p = 0, e = 0;
      String tmp;
      while((p = text.indexOf("{@")) > -1) {
        e = text.indexOf('}', p + 2);
        if(e > -1) {
          tmp = text.substring(p + 2, e);
          out.write(text.substring(0, p));
          Parser.processMacro(constructor, out, tmp);
          text = text.substring(e + 1);
        }
      }
    }
    out.write(text);
    out.flush();
  }
  
  
  private static String processNestedMacros(IConstructor constructor, String text) throws ServletException, IOException {
    List<String> l = Strings.extractAll(text, "\\{\\@[^\\{\\@]*(\\{\\@[^\\}]*\\})");
    for(String s : l) {
      text = text.replaceAll(Strings.literal(s), processMacroString(constructor, s.substring(2, s.length() - 1)));
    }
    return text;
  }
  
  public static String processMacroString(IConstructor constructor, String macro) throws ServletException, IOException {
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    processMacro(constructor, pw, macro);
    return sw.toString();
  }
  
  public static void processMacro(IConstructor constructor, PrintWriter out, String macro) throws ServletException, IOException {
    String tokens[] = macro.split("(?<!\\/)(\\:)");
    executeExternalParsers(constructor, out, tokens);
  }
  
  public static String escapeGrouping(String sequence) {
    if(sequence == null || !sequence.contains("$")) return sequence;
    StringBuilder sb = new StringBuilder(sequence);
    int start = 0, p;
    while((p = sb.indexOf("$", start)) > -1) {
      sb.insert(p, '\\');
      start = p + 2;
    }
    return sb.toString();
  }
  
  /* External Parsers */
  
  public static void executeExternalParsers(IConstructor constructor, PrintWriter out, String[] tokens) {
    for(IParser iParser : Instances.cached().byAnnotation(ExternalParser.class, IParser.class)) {
      if(iParser.execute(constructor, out, tokens)) {
        break;
      }
    }
  }
  
}