/*
* Copyright 2014 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.gwt.resources.converter;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.TreeLogger.Type;
import com.google.gwt.dev.util.TextOutput;
import com.google.gwt.resources.css.ast.Context;
import com.google.gwt.resources.css.ast.CssCharset;
import com.google.gwt.resources.css.ast.CssDef;
import com.google.gwt.resources.css.ast.CssEval;
import com.google.gwt.resources.css.ast.CssExternalSelectors;
import com.google.gwt.resources.css.ast.CssFontFace;
import com.google.gwt.resources.css.ast.CssIf;
import com.google.gwt.resources.css.ast.CssMediaRule;
import com.google.gwt.resources.css.ast.CssNoFlip;
import com.google.gwt.resources.css.ast.CssPageRule;
import com.google.gwt.resources.css.ast.CssProperty;
import com.google.gwt.resources.css.ast.CssProperty.DotPathValue;
import com.google.gwt.resources.css.ast.CssProperty.FunctionValue;
import com.google.gwt.resources.css.ast.CssProperty.Value;
import com.google.gwt.resources.css.ast.CssRule;
import com.google.gwt.resources.css.ast.CssSelector;
import com.google.gwt.resources.css.ast.CssSprite;
import com.google.gwt.resources.css.ast.CssUnknownAtRule;
import com.google.gwt.resources.css.ast.CssUrl;
import com.google.gwt.thirdparty.common.css.SourceCode;
import com.google.gwt.thirdparty.common.css.compiler.ast.GssParser;
import com.google.gwt.thirdparty.common.css.compiler.ast.GssParserException;
import com.google.gwt.thirdparty.guava.common.base.Predicate;
import com.google.gwt.thirdparty.guava.common.base.Splitter;
import com.google.gwt.thirdparty.guava.common.base.Strings;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* The GssGenerationVisitor turns a css tree into a gss string.
*/
public class GssGenerationVisitor extends ExtendedCssVisitor {
/* templates and tokens list */
private static final String AND = " && ";
private static final String CHARSET = "@charset \"%s\";";
private static final String DEF = "@def ";
private static final String ELSE = "@else ";
private static final String ELSE_IF = "@elseif (%s)";
private static final String EVAL = "eval('%s')";
private static final String EXTERNAL = "@external";
private static final String GWT_SPRITE = "gwt-sprite: \"%s\"";
private static final String IF = "@if (%s)";
private static final String IMPORTANT = " !important";
private static final String IS = "is(\"%s\", \"%s\")";
private static final String NO_FLIP = "/* @noflip */";
private static final String NOT = "!";
private static final String OR = " || ";
private static final Pattern UNESCAPE = Pattern.compile("\\\\");
private static final Pattern UNESCAPE_EXTERNAL = Pattern.compile("\\\\|@external|,|\\n|\\r");
private static final String URL = "resourceUrl(\"%s\")";
private static final String VALUE = "value('%s')";
private static final String VALUE_WITH_SUFFIX = "value('%s', '%s')";
// Used to quote font family name that contains white space(s) and aren't quoted yet.
private static Pattern NOT_QUOTED_WITH_WITHESPACE = Pattern.compile("^[^'\"].*\\s.*[^'\"]$");
// Used to sanitize the boolean conditions
private static Pattern BANG_OPERATOR = Pattern.compile("^(!+)(.*)");
// GSS impose constant names to be in uppercase. This Map will contains the mapping between
// the name of constants defined in the CSS and the corresponding name that will be used in GSS.
private final Map<String, String> cssToGssConstantMapping;
private final TextOutput out;
private final boolean lenient;
private final TreeLogger treeLogger;
private final Predicate<String> simpleBooleanConditionPredicate;
// list of external at-rules defined inside a media at-rule.
// In lenient mode, these nodes will be extracted and print outside the media at-rule.
private final List<CssExternalSelectors> wrongExternalNodes = new
ArrayList<CssExternalSelectors>();
// list of constant definition nodes defined inside a media at-rule.
// In lenient mode, these nodes will be extracted and print outside the media at-rule.
private final List<CssDef> wrongDefNodes = new ArrayList<CssDef>();
private boolean insideNoFlipNode;
private boolean needsNewLine;
private boolean needsOpenBrace;
private boolean needsComma;
private boolean insideMediaAtRule;
// used to group a sequence of @def in one block
private boolean previousNodeIsDef;
// used to group asequence of @external in one block
private boolean previousNodeIsExternal;
public GssGenerationVisitor(TextOutput out, Map<String, String> cssToGssConstantMapping,
boolean lenient, TreeLogger treeLogger, Predicate<String> simpleBooleanConditionPredicate) {
this.cssToGssConstantMapping = cssToGssConstantMapping;
this.out = out;
this.lenient = lenient;
this.treeLogger = treeLogger;
this.simpleBooleanConditionPredicate = simpleBooleanConditionPredicate;
}
public String getContent() {
return out.toString();
}
@Override
public void endVisit(CssFontFace x, Context ctx) {
closeBrace();
}
@Override
public void endVisit(CssMediaRule x, Context ctx) {
closeBrace();
insideMediaAtRule = false;
maybePrintWrongExternalNodes();
maybePrintWrongDefNodes(ctx);
}
@Override
public void endVisit(CssPageRule x, Context ctx) {
closeBrace();
}
@Override
public void endVisit(CssUnknownAtRule x, Context ctx) {
// The old CSS resource has no support for many at-rules, like animations. There is no way
// for us to parse them using the old CSS parser, so we will just output them as a string to
// the GSS stylesheet and hope that the GSS parser is okay with the rule
out.print(x.getRule());
}
@Override
public boolean visit(CssSprite x, Context ctx) {
return false;
}
@Override
public void endVisit(CssSprite x, Context ctx) {
needsComma = false;
accept(x.getSelectors());
openBrace();
out.print(String.format(GWT_SPRITE, x.getResourceFunction().getPath()));
semiColon();
accept(x.getProperties());
closeBrace();
}
@Override
public boolean visit(CssDef x, Context ctx) {
printDef(x, null, "def", false);
previousNodeIsDef = true;
previousNodeIsExternal = false;
return false;
}
@Override
public boolean visit(CssEval x, Context ctx) {
printDef(x, EVAL, "eval", false);
return false;
}
@Override
public boolean visit(CssUrl x, Context ctx) {
printDef(x, URL, "url", true);
return false;
}
@Override
public boolean visit(CssRule x, Context ctx) {
maybePrintNewLine();
needsOpenBrace = true;
needsComma = false;
needsNewLine = false;
previousNodeIsDef = false;
previousNodeIsExternal = false;
return true;
}
@Override
public void endVisit(CssRule x, Context ctx) {
// empty rule block case.
maybePrintOpenBrace();
closeBrace();
needsNewLine = true;
}
@Override
public boolean visit(CssNoFlip x, Context ctx) {
insideNoFlipNode = true;
previousNodeIsDef = false;
previousNodeIsExternal = false;
return true;
}
@Override
public boolean visit(CssExternalSelectors x, Context ctx) {
if (insideMediaAtRule) {
if (lenient) {
treeLogger.log(Type.WARN, "An external at-rule is not allowed inside a @media at-rule. " +
"The following external at-rule [" + x + "] will be moved in the upper scope");
wrongExternalNodes.add(x);
} else {
treeLogger.log(Type.ERROR, "An external at-rule is not allowed inside a @media at-rule. " +
"[" + x + "].");
throw new Css2GssConversionException("An external at-rule is not allowed inside a @media" +
" at-rule.");
}
} else {
printExternal(x);
}
return false;
}
@Override
public boolean visit(CssCharset x, Context ctx) {
out.print(String.format(CHARSET, x.getCharset()));
out.newlineOpt();
needsNewLine = true;
previousNodeIsDef = false;
previousNodeIsExternal = false;
return true;
}
private void maybePrintWrongExternalNodes() {
if (!lenient) {
return;
}
for (CssExternalSelectors external : wrongExternalNodes) {
printExternal(external);
}
wrongExternalNodes.clear();
}
private void maybePrintWrongDefNodes(Context ctx) {
if (!lenient) {
return;
}
for (CssDef def : wrongDefNodes) {
if (def instanceof CssUrl) {
visit((CssUrl) def, ctx);
} else if (def instanceof CssEval) {
visit((CssEval) def, ctx);
} else {
visit(def, ctx);
}
}
wrongDefNodes.clear();
}
private void printExternal(CssExternalSelectors x) {
boolean first = true;
for (String selector : x.getClasses()) {
String unescaped = unescapeExternalClass(selector);
if (validateExternalClass(selector) && !Strings.isNullOrEmpty(unescaped)) {
if (first) {
if (!previousNodeIsExternal) {
maybePrintNewLine();
}
out.print(EXTERNAL);
first = false;
}
out.print(" ");
boolean needQuote = selector.endsWith("*");
if (needQuote) {
out.print("'");
}
out.printOpt(unescaped);
if (needQuote) {
out.print("'");
}
}
}
if (!first) {
semiColon();
}
previousNodeIsDef = false;
previousNodeIsExternal = true;
}
private boolean validateExternalClass(String selector) {
if (selector.contains(":")) {
if (lenient) {
treeLogger.log(Type.WARN, "This invalid external selector will be skipped: " + selector);
return false;
} else {
throw new Css2GssConversionException(
"One of your external statements contains a pseudo class: " + selector);
}
}
return true;
}
@Override
public void endVisit(CssNoFlip x, Context ctx) {
insideNoFlipNode = false;
}
@Override
public boolean visit(CssProperty x, Context ctx) {
maybePrintOpenBrace();
StringBuilder propertyBuilder = new StringBuilder();
if (insideNoFlipNode) {
propertyBuilder.append(NO_FLIP);
propertyBuilder.append(' ');
}
propertyBuilder.append(x.getName());
propertyBuilder.append(": ");
String valueListCss = printValuesList(x.getValues().getValues(), false);
if ("font-family".equals(x.getName())) {
// Font family names containing whitespace should be quoted.
valueListCss = quoteFontFamilyWithWhiteSpace(valueListCss);
}
propertyBuilder.append(valueListCss);
if (x.isImportant()) {
propertyBuilder.append(IMPORTANT);
}
String cssProperty = propertyBuilder.toString();
// See if we can parse the rule using the GSS parser and thus verify that the
// rule is indeed correct CSS.
try {
new GssParser(new SourceCode(null, "body{" + cssProperty + "}")).parse();
} catch (GssParserException e) {
if (lenient) {
// print a warning message and don't print the rule.
treeLogger.log(Type.WARN, "The following rule is not valid and will be skipped: " +
cssProperty);
return false;
} else {
treeLogger.log(Type.ERROR, "The following rule is not valid. " +
cssProperty);
throw new Css2GssConversionException("Invalid css rule", e);
}
}
out.print(cssProperty);
semiColon();
return true;
}
/**
* Quotes the font family names that contains white space but aren't quoted yet. thus allowing
* usage of fonts that might be mistaken for constants. RTis is also recommended by the CSS
* specification: http://www.w3.org/TR/CSS2/fonts.html#propdef-font-family
* <p>It's important to notice that the converter doesn't manage the case where a constant is
* used inside a font family name with whitespace. The font family name will be quoted and
* won't be replaced.
* {@code
* @def myFontFamily Comic;
*
* .div {
* font-family: Arial, myFontFamily sans MS;
* }
* }
*
* will be converted to:
*
* {@code
* @def MY_FONT_FAMILY Comic;
*
* .div {
* font-family: Arial, "MY_FONT_FAMILY sans MS";
* }
* }
* @param cssProperty
*/
private String quoteFontFamilyWithWhiteSpace(String cssProperty) {
StringBuilder valueBuilder = new StringBuilder();
boolean first = true;
for (String subProperty : Splitter.on(",").trimResults().omitEmptyStrings().split(cssProperty)) {
if (first) {
first = false;
} else {
valueBuilder.append(",");
}
if (NOT_QUOTED_WITH_WITHESPACE.matcher(subProperty).matches()) {
valueBuilder.append("'" + subProperty + "'");
} else {
valueBuilder.append(subProperty);
}
}
return valueBuilder.toString();
}
@Override
public boolean visit(CssElse x, Context ctx) {
closeBrace();
out.print(ELSE);
openBrace();
needsNewLine = false;
previousNodeIsDef = false;
previousNodeIsExternal = false;
return true;
}
@Override
public boolean visit(CssElIf x, Context ctx) {
closeBrace();
openConditional(ELSE_IF, x);
return true;
}
@Override
public void endVisit(CssIf x, Context ctx) {
closeBrace();
needsNewLine = true;
}
@Override
public boolean visit(CssIf x, Context ctx) {
maybePrintNewLine();
openConditional(IF, x);
return true;
}
private void openConditional(String template, CssIf ifOrElif) {
String condition;
String runtimeCondition = extractExpression(ifOrElif);
if (runtimeCondition != null) {
if (simpleBooleanConditionPredicate.apply(runtimeCondition)) {
condition = runtimeCondition;
} else {
condition = String.format(EVAL, runtimeCondition);
}
} else {
condition = printConditionnalExpression(ifOrElif);
}
out.print(String.format(template, condition));
openBrace();
needsNewLine = false;
previousNodeIsDef = false;
previousNodeIsExternal = false;
}
private String extractExpression(CssIf ifOrElif) {
String condition = ifOrElif.getExpression();
if (condition == null) {
return null;
}
if (condition.trim().startsWith("(")) {
condition = condition.substring(1, condition.length() - 1);
}
// sanitize the expression. GSS doesn't accept more than one ! operator
Matcher m = BANG_OPERATOR.matcher(condition);
if (m.matches()) {
String bangs = m.group(1);
String replacement;
if (bangs.length() % 2 == 0) {
replacement = "";
} else {
replacement = "!";
}
condition = m.replaceFirst(replacement + "$2");
}
return condition;
}
@Override
public boolean visit(CssFontFace x, Context ctx) {
out.print("@font-face");
openBrace();
previousNodeIsDef = false;
previousNodeIsExternal = false;
return true;
}
@Override
public boolean visit(CssMediaRule x, Context ctx) {
maybePrintNewLine();
insideMediaAtRule = true;
out.print("@media");
boolean isFirst = true;
for (String m : x.getMedias()) {
if (isFirst) {
out.print(" ");
isFirst = false;
} else {
comma();
}
out.print(m);
}
spaceOpt();
out.print("{");
out.newlineOpt();
out.indentIn();
needsNewLine = false;
previousNodeIsDef = false;
previousNodeIsExternal = false;
return true;
}
@Override
public boolean visit(CssPageRule x, Context ctx) {
out.print("@page");
if (x.getPseudoPage() != null) {
out.print(" :");
out.print(x.getPseudoPage());
}
spaceOpt();
out.print("{");
out.newlineOpt();
out.indentIn();
previousNodeIsDef = false;
previousNodeIsExternal = false;
return true;
}
@Override
public boolean visit(CssSelector x, Context ctx) {
if (needsComma) {
comma(false);
}
maybePrintNewLine();
needsComma = true;
needsNewLine = true;
out.print(unescape(x.getSelector()));
return true;
}
private void printDef(CssDef def, String valueTemplate, String atRule, boolean insideUrlNode) {
if (validateDefNode(def, atRule)) {
if (!previousNodeIsDef) {
maybePrintNewLine();
}
out.print(DEF);
String name = cssToGssConstantMapping.get(def.getKey());
if (name == null) {
throw new Css2GssConversionException("unknown @" + atRule + " rule [" + def.getKey() + "]");
}
out.print(name);
out.print(' ');
String values = printValuesList(def.getValues(), insideUrlNode);
if (valueTemplate != null) {
out.print(String.format(valueTemplate, values));
} else {
out.print(values);
}
semiColon();
previousNodeIsDef = true;
needsNewLine = true;
}
}
private boolean validateDefNode(CssDef def, String atRule) {
if (insideMediaAtRule) {
if (lenient) {
treeLogger.log(Type.WARN, "A " + atRule + " is not allowed inside a @media at-rule." +
"The following " + atRule + " [" + def + "] will be moved in the upper scope");
wrongDefNodes.add(def);
return false;
} else {
treeLogger.log(Type.ERROR, "A " + atRule + " is not allowed inside a @media at-rule. ["
+ def + "]");
throw new Css2GssConversionException("A " + atRule + " is not allowed inside a @media " +
"at-rule.");
}
}
return true;
}
private void closeBrace() {
out.indentOut();
out.print('}');
out.newlineOpt();
}
private void comma() {
comma(true);
}
private void comma(boolean addSpace) {
out.print(',');
if (addSpace) {
spaceOpt();
}
}
private void openBrace() {
spaceOpt();
out.print('{');
out.newlineOpt();
out.indentIn();
}
private void semiColon() {
out.print(';');
out.newlineOpt();
}
private void spaceOpt() {
out.printOpt(' ');
}
private void maybePrintOpenBrace() {
if (needsOpenBrace) {
openBrace();
needsOpenBrace = false;
}
}
private void maybePrintNewLine() {
if (needsNewLine) {
out.newlineOpt();
}
}
private String printConditionnalExpression(CssIf x) {
if (x == null || x.getExpression() != null) {
throw new IllegalStateException();
}
StringBuilder builder = new StringBuilder();
String propertyName = x.getPropertyName();
for (String propertyValue : x.getPropertyValues()) {
if (builder.length() != 0) {
if (x.isNegated()) {
builder.append(AND);
} else {
builder.append(OR);
}
}
if (x.isNegated()) {
builder.append(NOT);
}
builder.append(String.format(IS, propertyName, propertyValue));
}
return builder.toString();
}
private String printValuesList(List<Value> values, boolean insideUrlNode) {
StringBuilder builder = new StringBuilder();
for (Value value : values) {
if (value.isSpaceRequired() && builder.length() != 0) {
builder.append(' ');
}
String expression = value.toCss();
if (value.isIdentValue() != null && cssToGssConstantMapping.containsKey(expression)) {
expression = cssToGssConstantMapping.get(expression);
} else if (value.isExpressionValue() != null) {
expression = value.getExpression();
} else if (value.isDotPathValue() != null) {
DotPathValue dotPathValue = value.isDotPathValue();
if (insideUrlNode) {
expression = dotPathValue.getPath();
} else {
if (Strings.isNullOrEmpty(dotPathValue.getSuffix())) {
expression = String.format(VALUE, dotPathValue.getPath());
} else {
expression =
String.format(VALUE_WITH_SUFFIX, dotPathValue.getPath(), dotPathValue.getSuffix());
}
}
} else if (value.isFunctionValue() != null) {
FunctionValue functionValue = value.isFunctionValue();
// process the argument list values
String arguments = printValuesList(functionValue.getValues().getValues(), insideUrlNode);
expression = unescape(functionValue.getName()) + "(" + arguments + ")";
}
// don't escape content of quoted string and don't escape isFunctionValue because the
// arguments and the name of the functions are already unescaped if needed.
if (value.isStringValue() != null || value.isFunctionValue() != null) {
builder.append(expression);
} else {
builder.append(unescape(expression));
}
}
return builder.toString();
}
private String unescape(String toEscape) {
return UNESCAPE.matcher(toEscape).replaceAll("");
}
private String unescapeExternalClass(String external) {
return UNESCAPE_EXTERNAL.matcher(external).replaceAll("");
}
}