DefaultRenderingContext.java

/*
 * Copyright (C) 2010 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.clearsilver.jsilver.template;

import com.google.clearsilver.jsilver.autoescape.AutoEscapeContext;
import com.google.clearsilver.jsilver.autoescape.AutoEscapeOptions;
import com.google.clearsilver.jsilver.autoescape.EscapeMode;
import com.google.clearsilver.jsilver.data.DataContext;
import com.google.clearsilver.jsilver.data.UniqueStack;
import com.google.clearsilver.jsilver.exceptions.JSilverAutoEscapingException;
import com.google.clearsilver.jsilver.exceptions.JSilverIOException;
import com.google.clearsilver.jsilver.exceptions.JSilverInterpreterException;
import com.google.clearsilver.jsilver.functions.FunctionExecutor;
import com.google.clearsilver.jsilver.resourceloader.ResourceLoader;
import com.google.clearsilver.jsilver.values.Value;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;

/**
 * Default implementation of RenderingContext.
 */
public class DefaultRenderingContext implements RenderingContext, FunctionExecutor {

  public static final Logger logger = Logger.getLogger(DefaultRenderingContext.class.getName());
  private final DataContext dataContext;
  private final ResourceLoader resourceLoader;
  private final Appendable out;
  private final FunctionExecutor globalFunctionExecutor;
  private final AutoEscapeOptions autoEscapeOptions;
  private final UniqueStack<String> includeStack;

  private List<String> escaperStack = new ArrayList<String>(8); // seems like a reasonable initial
                                                                // capacity.
  private String currentEscaper; // optimization to reduce List lookup.

  private List<Template> executionStack = new ArrayList<Template>(8);

  private Map<String, Macro> macros = new HashMap<String, Macro>();
  private List<EscapeMode> autoEscapeStack = new ArrayList<EscapeMode>();
  private EscapeMode autoEscapeMode;
  private AutoEscapeContext autoEscapeContext;
  private int line;
  private int column;
  private AutoEscapeContext.AutoEscapeState startingAutoEscapeState;

  public DefaultRenderingContext(DataContext dataContext, ResourceLoader resourceLoader,
      Appendable out, FunctionExecutor globalFunctionExecutor, AutoEscapeOptions autoEscapeOptions) {
    this.dataContext = dataContext;
    this.resourceLoader = resourceLoader;
    this.out = out;
    this.globalFunctionExecutor = globalFunctionExecutor;
    this.autoEscapeOptions = autoEscapeOptions;
    this.autoEscapeMode = EscapeMode.ESCAPE_NONE;
    this.autoEscapeContext = null;
    this.includeStack = new UniqueStack<String>();
  }

  /**
   * Lookup a function by name, execute it and return the results.
   */
  @Override
  public Value executeFunction(String name, Value... args) {
    return globalFunctionExecutor.executeFunction(name, args);
  }

  @Override
  public void escape(String name, String input, Appendable output) throws IOException {
    globalFunctionExecutor.escape(name, input, output);
  }

  @Override
  public boolean isEscapingFunction(String name) {
    return globalFunctionExecutor.isEscapingFunction(name);
  }

  @Override
  public void pushEscapingFunction(String name) {
    escaperStack.add(currentEscaper);
    if (name == null || name.equals("")) {
      currentEscaper = null;
    } else {
      currentEscaper = name;
    }
  }

  @Override
  public void popEscapingFunction() {
    int len = escaperStack.size();
    if (len == 0) {
      throw new IllegalStateException("No more escaping functions to pop.");
    }
    currentEscaper = escaperStack.remove(len - 1);
  }

  @Override
  public void writeEscaped(String text) {
    // If runtime auto escaping is enabled, only apply it if
    // we are not going to do any other default escaping on the variable.
    boolean applyAutoEscape = isRuntimeAutoEscaping() && (currentEscaper == null);
    if (applyAutoEscape) {
      autoEscapeContext.setCurrentPosition(line, column);
      pushEscapingFunction(autoEscapeContext.getEscapingFunctionForCurrentState());
    }
    try {
      if (shouldLogEscapedVariables()) {
        StringBuilder tmp = new StringBuilder();
        globalFunctionExecutor.escape(currentEscaper, text, tmp);
        if (!tmp.toString().equals(text)) {
          logger.warning(new StringBuilder(getLoggingPrefix()).append(" Auto-escape changed [")
              .append(text).append("] to [").append(tmp.toString()).append("]").toString());
        }
        out.append(tmp);
      } else {
        globalFunctionExecutor.escape(currentEscaper, text, out);
      }
    } catch (IOException e) {
      throw new JSilverIOException(e);
    } finally {
      if (applyAutoEscape) {
        autoEscapeContext.insertText();
        popEscapingFunction();
      }
    }
  }

  private String getLoggingPrefix() {
    return "[" + getCurrentResourceName() + ":" + line + ":" + column + "]";
  }

  private boolean shouldLogEscapedVariables() {
    return (autoEscapeOptions != null && autoEscapeOptions.getLogEscapedVariables());
  }

  @Override
  public void writeUnescaped(CharSequence text) {
    if (isRuntimeAutoEscaping() && (currentEscaper == null)) {
      autoEscapeContext.setCurrentPosition(line, column);
      autoEscapeContext.parseData(text.toString());
    }
    try {
      out.append(text);
    } catch (IOException e) {
      throw new JSilverIOException(e);
    }
  }

  @Override
  public void pushExecutionContext(Template template) {
    executionStack.add(template);
  }

  @Override
  public void popExecutionContext() {
    executionStack.remove(executionStack.size() - 1);
  }

  @Override
  public void setCurrentPosition(int line, int column) {
    // TODO: Should these be saved in executionStack as part
    // of pushExecutionContext?
    this.line = line;
    this.column = column;
  }

  @Override
  public void registerMacro(String name, Macro macro) {
    macros.put(name, macro);
  }

  @Override
  public Macro findMacro(String name) {
    Macro macro = macros.get(name);
    if (macro == null) {
      throw new JSilverInterpreterException("No such macro: " + name);
    }
    return macro;
  }

  @Override
  public DataContext getDataContext() {
    return dataContext;
  }

  @Override
  public ResourceLoader getResourceLoader() {
    return resourceLoader;
  }

  @Override
  public AutoEscapeOptions getAutoEscapeOptions() {
    return autoEscapeOptions;
  }

  @Override
  public EscapeMode getAutoEscapeMode() {
    if (isRuntimeAutoEscaping() || (currentEscaper != null)) {
      return EscapeMode.ESCAPE_NONE;
    } else {
      return autoEscapeMode;
    }
  }

  @Override
  public void pushAutoEscapeMode(EscapeMode mode) {
    if (isRuntimeAutoEscaping()) {
      throw new JSilverInterpreterException(
          "cannot call pushAutoEscapeMode while runtime auto escaping is in progress");
    }
    autoEscapeStack.add(autoEscapeMode);
    autoEscapeMode = mode;
  }

  @Override
  public void popAutoEscapeMode() {
    int len = autoEscapeStack.size();
    if (len == 0) {
      throw new IllegalStateException("No more auto escaping modes to pop.");
    }
    autoEscapeMode = autoEscapeStack.remove(autoEscapeStack.size() - 1);
  }

  @Override
  public boolean isRuntimeAutoEscaping() {
    return autoEscapeContext != null;
  }

  /**
   * {@inheritDoc}
   * 
   * @throws JSilverInterpreterException if startRuntimeAutoEscaping is called while runtime
   *         autoescaping is already in progress.
   */
  @Override
  public void startRuntimeAutoEscaping() {
    if (isRuntimeAutoEscaping()) {
      throw new JSilverInterpreterException("startRuntimeAutoEscaping() is not re-entrant at "
          + getCurrentResourceName());
    }
    if (!autoEscapeMode.equals(EscapeMode.ESCAPE_NONE)) {
      // TODO: Get the resourceName as a parameter to this function
      autoEscapeContext = new AutoEscapeContext(autoEscapeMode, getCurrentResourceName());
      startingAutoEscapeState = autoEscapeContext.getCurrentState();
    } else {
      autoEscapeContext = null;
    }
  }

  private String getCurrentResourceName() {
    if (executionStack.size() == 0) {
      return "";
    } else {
      return executionStack.get(executionStack.size() - 1).getDisplayName();
    }
  }

  @Override
  public void stopRuntimeAutoEscaping() {
    if (autoEscapeContext != null) {
      if (!startingAutoEscapeState.equals(autoEscapeContext.getCurrentState())) {
        // We do not allow a macro call to change context of the rest of the template.
        // Since the rest of the template has already been auto-escaped at parse time
        // with the assumption that the macro call will not modify the context.
        throw new JSilverAutoEscapingException("Macro starts in context " + startingAutoEscapeState
            + " but ends in different context " + autoEscapeContext.getCurrentState(),
            autoEscapeContext.getResourceName());
      }
    }
    autoEscapeContext = null;
  }

  @Override
  public boolean pushIncludeStackEntry(String templateName) {
    return includeStack.push(templateName);
  }

  @Override
  public boolean popIncludeStackEntry(String templateName) {
    return templateName.equals(includeStack.pop());
  }

  @Override
  public Iterable<String> getIncludedTemplateNames() {
    return includeStack;
  }
}