| /* | |
| * 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(""); | |
| } | |
| } |