NavigationParser.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2020 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.parser;
 
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.turro.string.ObjectString;
import org.turro.string.Strings;
import org.turro.annotation.ExternalParser;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.impl.navigation.Navigator;
import org.turro.elephant.impl.navigation.NavigatorType;
import org.turro.elephant.impl.navigation.WebMap;
import org.turro.elephant.web.ElContext;
import org.turro.elephant.web.ElContextMap;
import org.turro.html.HTMLHelper;
 
@ExternalParser
public class NavigationParser  extends AbstractParser {
 
  @Override
  public String getParserName() {
    return "Navigation";
  }
 
  @Override
  protected boolean doExecute() {
    boolean done = false;
    if("list".equals(getMacroName()) || "anchor".equals(getMacroName())) {
      int currToken = 1;
      boolean verbosePath = false;
      boolean hidden = false;
      boolean external = false;
      ElContext root = ElContextMap.getContext(constructor.getRenderingContext().getPath());
      List<ElContext> result = null;
      String clickAction = "", cssClass = "";
      while(currToken < tokens.length && root != null) {
        if("popup".equals(tokens[currToken])) {
          clickAction = "popupElement('" + ElephantContext.getRootWebPath() + "', $(this)); return false;";
          cssClass = "popup";
        }
        else if("verbose".equals(tokens[currToken])) {
          verbosePath = true;
        }
        else if("hidden".equals(tokens[currToken])) {
          hidden = true;
        }
        else if("external".equals(tokens[currToken])) {
          external = true;
        }
        else if("parent".equals(tokens[currToken])) {
          root = root.getParent();
        }
        else if("root".equals(tokens[currToken])) {
          root = ElContextMap.getContext("/");
        }
        else if("locate".equals(tokens[currToken])) {
          if(tokens.length > currToken + 1) {
            root = ElContextMap.getContext(tokens[currToken + 1].replace("*", constructor.getRenderingContext().getPath()));
            currToken++;
          }
        }
        else if("match".equals(tokens[currToken])) {
          if(tokens.length > currToken + 1) {
            root = getSingleContextFrom(root, tokens[currToken + 1]);
            currToken++;
          }
        }
        else if("level".equals(tokens[currToken])) {
          if(tokens.length > currToken + 1) {
            root = getLevelContextFrom(root, tokens[currToken + 1]);
            currToken++;
          }
        }
        else if("children".equals(tokens[currToken])) {
          result = new ArrayList(root.getChildren());
          break;
        }
        else if("all".equals(tokens[currToken])) {
          result = getAllFrom(root, false);
          break;
        }
        else if("leaf".equals(tokens[currToken])) {
          result = getAllFrom(root, true);
          break;
        }
        else if("ancestors".equals(tokens[currToken])) {
          result = new ArrayList(root.getAncestors());
          break;
        }
        else if("siblings".equals(tokens[currToken])) {
          result = new ArrayList(root.getSiblings());
          break;
        }
        else if("search".equals(tokens[currToken])) {
          if(tokens.length > currToken + 1) {
            result = getContextsFrom(root, tokens[currToken + 1]);
            break;
          }
        }
        else if("self".equals(tokens[currToken])) {
          result = new ArrayList<>();
          result.add(root);
          break;
        }
        currToken++;
      }
      HTMLHelper hh = new HTMLHelper(out);
      boolean list = "list".equals(tokens[0]);
      if(result != null && !result.isEmpty()) {
        if(list) {
          hh.startTag("ul", "class='m_list'");
        } else if(result.size() > 1) {
          hh.write("[ ");
        }
        for(ElContext ctx : result) {
          if(hidden || ctx.canDisplay()) {
            if(list) {
              hh.startTag("li");
            }
            if(external) {
              hh.startExtAnchor(ctx.getWebPath(), null);
            } else {
              if(Strings.isBlank(ctx.getTarget()) || !Strings.isBlank(clickAction)) {
                hh.startAnchor(ctx.getWebPath(), null, cssClass, clickAction);
              } else {
                hh.startTargetAnchor(ctx.getWebPath(), ctx.getTarget(), null);
              }
            }
            if(verbosePath) {
              hh.write(ctx.getVerbosePath(root));
            } else {
              hh.write(ctx.getName());
            }
            hh.endTag();
            if(list) {
              hh.endTag();
            } else if(result.lastIndexOf(ctx) < result.size() - 1) {
              hh.write(", ");
            }
          }
        }
        if(!list && result.size() > 1) {
          hh.write(" ]");
        }
        hh.endAllTags();
      } else {
        hh.startTag((list ? "div" : "span"), "class='m_error'");
        hh.write(getMacroName());
        hh.endTag();
      }
      done = true;
    } else if("navigator".equals(getMacroName())) {
      ElContext root = constructor.getRenderingContext();
      Navigator navigator = new Navigator(root);
      navigator.setDynamicLoad("dynamic".equals(ElephantContext.getContextLoad()));
      if("location".equals(getToken(1))) {
        try {
          navigator.setType(NavigatorType.LOCATION);
          navigator.initialize();
          navigator.draw();
        } catch (IOException ex) {
          Logger.getLogger(NavigationParser.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
        }
      } else if("traversal".equals(getToken(1))) {
        try {
          navigator.setType(NavigatorType.TRAVERSAL);
          navigator.setShowTitle((Boolean) ObjectString.parseNativeString(getToken(2), Boolean.class, true));
          navigator.initialize();
          navigator.draw();
        } catch (IOException ex) {
          Logger.getLogger(NavigationParser.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
        }
      } else if("options".equals(getToken(1))) {
        navigator.setType(NavigatorType.OPTIONS);
        navigator.setDrawDecorators((Boolean) ObjectString.parseNativeString(getToken(2), Boolean.class, true));
        navigator.setLevel((Integer) ObjectString.parseNativeString(getToken(3), Integer.class, true));
        navigator.setPreloaded((Integer) ObjectString.parseNativeString(getToken(4), Integer.class, true));
        navigator.setShowCurrent((Boolean) ObjectString.parseNativeString(getToken(5), Boolean.class, true));
        navigator.initialize();
        try {
          navigator.draw();
        } catch (IOException ex) {
          Logger.getLogger(NavigationParser.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
        }
      } else if("tabulator".equals(getToken(1))) {
        try {
          navigator.setType(NavigatorType.TABULATOR);
          navigator.setLevel((Integer) ObjectString.parseNativeString(getToken(2), Integer.class, true));
          navigator.initialize();
          navigator.draw();
        } catch (IOException ex) {
          Logger.getLogger(NavigationParser.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
        }
      }
      done = true;
    } else if("webmap".equals(getMacroName())) {
      WebMap wm = new WebMap(constructor);
      try {
        wm.draw((Integer) ObjectString.parseNativeString(getToken(1), Integer.class, true));
      } catch (IOException ex) {
        Logger.getLogger(CoreParser.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
      done = true;
    }
    return done;
  }
 
  @Override
  protected void explainMacros(ParserMacroSet macros) {
    macros.addMacro("navigator")
            .addParameter("location", false);
    macros.addMacro("navigator")
            .addParameter("traversal", false)
            .addParameter("show-title", true, "false");
    macros.addMacro("navigator")
            .addParameter("options", false)
            .addParameter("decorators", false)
            .addParameter("level", false)
            .addParameter("preloaded", false)
            .addParameter("show-current", true, "true");
    macros.addMacro("navigator")
            .addParameter("tabulator", false)
            .addParameter("level", false);
    macros.addMacro("webmap")
             .addParameter("level", true, "1");
    macros.addMacro("list")
            .addParameter("behavioural_keywords", false, null, true)
            .addPossibleValue("verbose")
            .addPossibleValue("popup")
            .addPossibleValue("hidden")
            .addPossibleValue("external")
            .addParameter("navigational_keywords", false, null, true)
            .addPossibleValue("parent")
            .addPossibleValue("root")
            .addPossibleValue("level")
            .addPossibleValue("locate")
            .addPossibleValue("match")
            .addParameter("selection_keywords", false, null, true)
            .addPossibleValue("self")
            .addPossibleValue("children")
            .addPossibleValue("all")
            .addPossibleValue("leaf")
            .addPossibleValue("ancestors")
            .addPossibleValue("siblings")
            .addPossibleValue("search");
    macros.addMacro("anchor")
            .copyParametersFrom("list", macros);
  }
 
  private static List<ElContext> getAllFrom(ElContext root, boolean leaf) {
    ArrayList v = new ArrayList();
    processContext(root, v, leaf, false);
    return v;
  }
  
  private static void processContext(ElContext root, Collection v, boolean leaf, boolean addRoot) {
    Set<ElContext> children = root.getChildren();
    if(addRoot && (!leaf || (leaf && children.isEmpty()))) {
      v.add(root);
    }
    for(ElContext c : children) {
      processContext(c, v, leaf, true);
    }
  }
  
  private static ElContext getLevelContextFrom(ElContext root, String level) {
    ElContext[] ctxs = root.getAncestors().toArray(new ElContext[0]);
    int idx = Integer.valueOf(level);
    if(idx < ctxs.length) {
      return ctxs[idx];
    } else if(ctxs.length > 0) {
      return ctxs[ctxs.length - 1];
    } else {
      return root;
    }
  }
  
  private static List<ElContext> getContextsFrom(ElContext root, String regExp) {
    ArrayList v = new ArrayList();
    processSearchFrom(root, regExp, v);
    return v;
  }
  
  private static ElContext getSingleContextFrom(ElContext root, String regExp) {
    return processSingleSearchFrom(root, regExp);
  }
  
  private static void processSearchFrom(ElContext root, String regExp, Collection v) {
    for(ElContext ctx : root.getChildren()) {
      if(ctx.getId().matches(regExp)) {
        v.add(ctx);
      }
      processSearchFrom(ctx, regExp, v);
    }
  }
 
  private static ElContext processSingleSearchFrom(ElContext root, String regExp) {
    for(ElContext ctx : root.getChildren()) {
      if(ctx.getId().matches(regExp)) {
        return ctx;
      }
      ctx = processSingleSearchFrom(ctx, regExp);
      if(ctx != null) return ctx;
    }
    return null;
  }
  
  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();
  }
 
}