src/com/google/clearsilver/jsilver/compiler/VariableTranslator.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.compiler;

import static com.google.clearsilver.jsilver.compiler.JavaExpression.StringExpression;
import static com.google.clearsilver.jsilver.compiler.JavaExpression.Type;
import static com.google.clearsilver.jsilver.compiler.JavaExpression.literal;
import com.google.clearsilver.jsilver.syntax.analysis.DepthFirstAdapter;
import com.google.clearsilver.jsilver.syntax.node.ADecNumberVariable;
import com.google.clearsilver.jsilver.syntax.node.ADescendVariable;
import com.google.clearsilver.jsilver.syntax.node.AExpandVariable;
import com.google.clearsilver.jsilver.syntax.node.AHexNumberVariable;
import com.google.clearsilver.jsilver.syntax.node.ANameVariable;
import com.google.clearsilver.jsilver.syntax.node.PVariable;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

/**
 * Translates a variable name (e.g. search.results.3.title) into the Java code for use as a key in
 * looking up a variable (e.g. "search.results.3.title").
 * 
 * While it is possible to reuse an instance of this class repeatedly, it is not thread safe or
 * reentrant. Evaluating an expression such as: <code>a.b[c.d]</code> would require two instances.
 */
public class VariableTranslator extends DepthFirstAdapter {

  private List<JavaExpression> components;

  private final ExpressionTranslator expressionTranslator;

  public VariableTranslator(ExpressionTranslator expressionTranslator) {
    this.expressionTranslator = expressionTranslator;
  }

  /**
   * See class description.
   * 
   * @param csVariable Variable node in template's AST.
   * @return Appropriate code (as JavaExpression).
   */
  public JavaExpression translate(PVariable csVariable) {
    try {
      assert components == null;
      components = new ArrayList<JavaExpression>();
      csVariable.apply(this);
      components = joinComponentsWithDots(components);
      components = combineAdjacentStrings(components);
      return concatenate(components);
    } finally {
      components = null;
    }
  }

  @Override
  public void caseANameVariable(ANameVariable node) {
    components.add(new StringExpression(node.getWord().getText()));
  }

  @Override
  public void caseADecNumberVariable(ADecNumberVariable node) {
    components.add(new StringExpression(node.getDecNumber().getText()));
  }

  @Override
  public void caseAHexNumberVariable(AHexNumberVariable node) {
    components.add(new StringExpression(node.getHexNumber().getText()));
  }

  @Override
  public void caseADescendVariable(ADescendVariable node) {
    node.getParent().apply(this);
    node.getChild().apply(this);
  }

  @Override
  public void caseAExpandVariable(AExpandVariable node) {
    node.getParent().apply(this);
    components.add(expressionTranslator.translateToString(node.getChild()));
  }

  /**
   * Inserts dots between each component in the path.
   * 
   * e.g. from: "a", "b", something, "c" to: "a", ".", "b", ".", something, ".", "c"
   */
  private List<JavaExpression> joinComponentsWithDots(List<JavaExpression> in) {
    List<JavaExpression> out = new ArrayList<JavaExpression>(in.size() * 2);
    for (JavaExpression component : in) {
      if (!out.isEmpty()) {
        out.add(DOT);
      }
      out.add(component);
    }
    return out;
  }

  private static final JavaExpression DOT = new StringExpression(".");

  /**
   * Combines adjacent strings.
   * 
   * e.g. from: "a", ".", "b", ".", something, ".", "c" to : "a.b.", something, ".c"
   */
  private List<JavaExpression> combineAdjacentStrings(List<JavaExpression> in) {
    assert !in.isEmpty();
    List<JavaExpression> out = new ArrayList<JavaExpression>(in.size());
    JavaExpression last = null;
    for (JavaExpression current : in) {
      if (last == null) {
        last = current;
        continue;
      }
      if (current instanceof StringExpression && last instanceof StringExpression) {
        // Last and current are both strings - combine them.
        StringExpression currentString = (StringExpression) current;
        StringExpression lastString = (StringExpression) last;
        last = new StringExpression(lastString.getValue() + currentString.getValue());
      } else {
        out.add(last);
        last = current;
      }
    }
    out.add(last);
    return out;
  }

  /**
   * Concatenate a list of JavaExpressions into a single string.
   * 
   * e.g. from: "a", "b", stuff to : "a" + "b" + stuff
   */
  private JavaExpression concatenate(List<JavaExpression> expressions) {
    StringWriter buffer = new StringWriter();
    PrintWriter out = new PrintWriter(buffer);
    boolean seenFirst = false;
    for (JavaExpression expression : expressions) {
      if (seenFirst) {
        out.print(" + ");
      }
      seenFirst = true;
      expression.write(out);
    }
    return literal(Type.VAR_NAME, buffer.toString());
  }

}