/*
* 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.rg;
import com.google.gwt.core.ext.BadPropertyValueException;
import com.google.gwt.core.ext.ConfigurationProperty;
import com.google.gwt.core.ext.Generator;
import com.google.gwt.core.ext.PropertyOracle;
import com.google.gwt.core.ext.SelectionProperty;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.TreeLogger.Type;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.NotFoundException;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.dev.util.Util;
import com.google.gwt.i18n.client.LocaleInfo;
import com.google.gwt.resources.client.ClientBundle.Source;
import com.google.gwt.resources.client.CssResource;
import com.google.gwt.resources.client.CssResource.ClassName;
import com.google.gwt.resources.client.CssResource.Import;
import com.google.gwt.resources.client.CssResource.ImportedWithPrefix;
import com.google.gwt.resources.client.CssResource.NotStrict;
import com.google.gwt.resources.client.CssResource.Shared;
import com.google.gwt.resources.client.ResourcePrototype;
import com.google.gwt.resources.converter.Css2Gss;
import com.google.gwt.resources.converter.Css2GssConversionException;
import com.google.gwt.resources.ext.ClientBundleRequirements;
import com.google.gwt.resources.ext.ResourceContext;
import com.google.gwt.resources.ext.ResourceGeneratorUtil;
import com.google.gwt.resources.ext.SupportsGeneratorResultCaching;
import com.google.gwt.resources.gss.BooleanConditionCollector;
import com.google.gwt.resources.gss.CollectAndRemoveConstantDefinitions;
import com.google.gwt.resources.gss.CreateRuntimeConditionalNodes;
import com.google.gwt.resources.gss.CssPrinter;
import com.google.gwt.resources.gss.ExtendedEliminateConditionalNodes;
import com.google.gwt.resources.gss.ExternalClassesCollector;
import com.google.gwt.resources.gss.GwtGssFunctionMapProvider;
import com.google.gwt.resources.gss.ImageSpriteCreator;
import com.google.gwt.resources.gss.PermutationsCollector;
import com.google.gwt.resources.gss.RecordingBidiFlipper;
import com.google.gwt.resources.gss.RenamingSubstitutionMap;
import com.google.gwt.resources.gss.RuntimeConditionalBlockCollector;
import com.google.gwt.resources.gss.ValidateRuntimeConditionalNode;
import com.google.gwt.resources.rg.CssResourceGenerator.JClassOrderComparator;
import com.google.gwt.thirdparty.common.css.MinimalSubstitutionMap;
import com.google.gwt.thirdparty.common.css.PrefixingSubstitutionMap;
import com.google.gwt.thirdparty.common.css.SourceCode;
import com.google.gwt.thirdparty.common.css.SourceCodeLocation;
import com.google.gwt.thirdparty.common.css.SubstitutionMap;
import com.google.gwt.thirdparty.common.css.compiler.ast.CssCompositeValueNode;
import com.google.gwt.thirdparty.common.css.compiler.ast.CssDefinitionNode;
import com.google.gwt.thirdparty.common.css.compiler.ast.CssNumericNode;
import com.google.gwt.thirdparty.common.css.compiler.ast.CssTree;
import com.google.gwt.thirdparty.common.css.compiler.ast.CssValueNode;
import com.google.gwt.thirdparty.common.css.compiler.ast.ErrorManager;
import com.google.gwt.thirdparty.common.css.compiler.ast.GssError;
import com.google.gwt.thirdparty.common.css.compiler.ast.GssFunction;
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.common.css.compiler.passes.AbbreviatePositionalValues;
import com.google.gwt.thirdparty.common.css.compiler.passes.CheckDependencyNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.CollectConstantDefinitions;
import com.google.gwt.thirdparty.common.css.compiler.passes.CollectMixinDefinitions;
import com.google.gwt.thirdparty.common.css.compiler.passes.ColorValueOptimizer;
import com.google.gwt.thirdparty.common.css.compiler.passes.ConstantDefinitions;
import com.google.gwt.thirdparty.common.css.compiler.passes.CreateComponentNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.CreateConditionalNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.CreateConstantReferences;
import com.google.gwt.thirdparty.common.css.compiler.passes.CreateDefinitionNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.CreateForLoopNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.CreateMixins;
import com.google.gwt.thirdparty.common.css.compiler.passes.CreateStandardAtRuleNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.CreateVendorPrefixedKeyframes;
import com.google.gwt.thirdparty.common.css.compiler.passes.CssClassRenaming;
import com.google.gwt.thirdparty.common.css.compiler.passes.DisallowDuplicateDeclarations;
import com.google.gwt.thirdparty.common.css.compiler.passes.EliminateEmptyRulesetNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.EliminateUnitsFromZeroNumericValues;
import com.google.gwt.thirdparty.common.css.compiler.passes.EliminateUselessRulesetNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.HandleUnknownAtRuleNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.MarkNonFlippableNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.MarkRemovableRulesetNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.MergeAdjacentRulesetNodesWithSameDeclarations;
import com.google.gwt.thirdparty.common.css.compiler.passes.MergeAdjacentRulesetNodesWithSameSelector;
import com.google.gwt.thirdparty.common.css.compiler.passes.ProcessComponents;
import com.google.gwt.thirdparty.common.css.compiler.passes.ProcessKeyframes;
import com.google.gwt.thirdparty.common.css.compiler.passes.ProcessRefiners;
import com.google.gwt.thirdparty.common.css.compiler.passes.ReplaceConstantReferences;
import com.google.gwt.thirdparty.common.css.compiler.passes.ReplaceMixins;
import com.google.gwt.thirdparty.common.css.compiler.passes.ResolveCustomFunctionNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.SplitRulesetNodes;
import com.google.gwt.thirdparty.common.css.compiler.passes.UnrollLoops;
import com.google.gwt.thirdparty.common.css.compiler.passes.ValidatePropertyValues;
import com.google.gwt.thirdparty.guava.common.base.CaseFormat;
import com.google.gwt.thirdparty.guava.common.base.Charsets;
import com.google.gwt.thirdparty.guava.common.base.Joiner;
import com.google.gwt.thirdparty.guava.common.base.Predicate;
import com.google.gwt.thirdparty.guava.common.base.Predicates;
import com.google.gwt.thirdparty.guava.common.base.Strings;
import com.google.gwt.thirdparty.guava.common.collect.ImmutableMap;
import com.google.gwt.thirdparty.guava.common.collect.ImmutableSet;
import com.google.gwt.thirdparty.guava.common.collect.ImmutableSet.Builder;
import com.google.gwt.thirdparty.guava.common.collect.Lists;
import com.google.gwt.thirdparty.guava.common.collect.Maps;
import com.google.gwt.thirdparty.guava.common.collect.Sets;
import com.google.gwt.thirdparty.guava.common.io.ByteSource;
import com.google.gwt.thirdparty.guava.common.io.Resources;
import com.google.gwt.user.rebind.SourceWriter;
import com.google.gwt.user.rebind.StringSourceWriter;
import org.apache.commons.io.IOUtils;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.URL;
import java.nio.charset.Charset;
import java.nio.charset.UnsupportedCharsetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.Adler32;
/**
* This generator parses and compiles a GSS file to a css string and generates the implementation
* of the corresponding CssResource interface.
*/
public class GssResourceGenerator extends AbstractCssResourceGenerator implements
SupportsGeneratorResultCaching {
/**
* GssOptions contains the values of all configuration properties that can be used with
* GssResource.
*/
public static class GssOptions {
private final boolean enabled;
private final AutoConversionMode autoConversionMode;
private final boolean gssDefaultInUiBinder;
public GssOptions(boolean enabled, AutoConversionMode autoConversionMode, boolean gssDefaultInUiBinder) {
this.enabled = enabled;
this.autoConversionMode = autoConversionMode;
this.gssDefaultInUiBinder = gssDefaultInUiBinder;
}
public boolean isEnabled() {
return enabled;
}
public boolean isGssDefaultInUiBinder() {
return gssDefaultInUiBinder;
}
public boolean isAutoConversionOff() {
return autoConversionMode == AutoConversionMode.OFF;
}
public boolean isLenientConversion() {
return autoConversionMode == AutoConversionMode.LENIENT;
}
}
/**
* Different conversion modes from css to gss.
*/
public enum AutoConversionMode { STRICT, LENIENT, OFF }
/*
* TODO(dankurka): This is a nasty hack to get the compiler to output all @def's
* it has seen in a compile. Once GSS migration is done this needs to be removed.
*/
private static boolean shouldEmitVariables;
private static PrintWriter printWriter;
private static Set<String> writtenAtDefs = new HashSet<>();
private static final String KEY_ENABLE_GSS = "CssResource.enableGss";
private static final String KEY_GSS_DEFAULT_IN_UIBINDER = "CssResource.gssDefaultInUiBinder";
static {
String varFileName = System.getProperty("emitGssVarNameFile");
shouldEmitVariables = varFileName != null;
if (shouldEmitVariables) {
try {
File file = new File(varFileName);
file.createNewFile();
printWriter = new PrintWriter(new FileOutputStream(file));
} catch (Exception e) {
System.err.println("Error while opening file");
e.printStackTrace();
System.exit(-1);
}
}
}
public static SourceCode readUrlContent(URL fileUrl, TreeLogger logger) throws UnableToCompleteException {
TreeLogger branchLogger = logger.branch(TreeLogger.DEBUG,
"Reading GSS stylesheet " + fileUrl.toExternalForm());
try {
ByteSource byteSource = Resources.asByteSource(fileUrl);
// default charset
Charset charset = Charsets.UTF_8;
// check if the stylesheet doesn't include a @charset at-rule
String styleSheetCharset = extractCharset(byteSource);
if (styleSheetCharset != null) {
try {
charset = Charset.forName(styleSheetCharset);
} catch (UnsupportedCharsetException e) {
logger.log(Type.ERROR, "Unsupported charset found: " + styleSheetCharset);
throw new UnableToCompleteException();
}
}
String fileContent = byteSource.asCharSource(charset).read();
// If the stylesheet specified a charset, we have to remove the at-rule otherwise the GSS
// compiler will fail.
if (styleSheetCharset != null) {
int charsetAtRuleLength = CHARSET_MIN_LENGTH + styleSheetCharset.length();
// replace charset at-rule by blanks to keep correct source location of the rest of
// the stylesheet.
fileContent = Strings.repeat(" ", charsetAtRuleLength) +
fileContent.substring(charsetAtRuleLength);
}
return new SourceCode(fileUrl.getFile(), fileContent);
} catch (IOException e) {
branchLogger.log(TreeLogger.ERROR, "Unable to parse CSS", e);
}
throw new UnableToCompleteException();
}
public static GssOptions getGssOptions(PropertyOracle propertyOracle, TreeLogger logger) throws UnableToCompleteException {
boolean gssEnabled;
boolean gssDefaultInUiBinder;
AutoConversionMode conversionMode;
try {
ConfigurationProperty enableGssProp =
propertyOracle.getConfigurationProperty(KEY_ENABLE_GSS);
String enableGss = enableGssProp.getValues().get(0);
gssEnabled = Boolean.parseBoolean(enableGss);
} catch (BadPropertyValueException ex) {
logger.log(Type.ERROR, "Unable to determine if GSS need to be used");
throw new UnableToCompleteException();
}
try {
conversionMode = Enum.valueOf(AutoConversionMode.class, propertyOracle
.getConfigurationProperty(KEY_CONVERSION_MODE).getValues().get(0)
.toUpperCase(Locale.ROOT));
} catch (BadPropertyValueException ex) {
logger.log(Type.ERROR, "Unable to conversion mode for GSS");
throw new UnableToCompleteException();
}
try {
ConfigurationProperty uiBinderGssDefaultProp =
propertyOracle.getConfigurationProperty(KEY_GSS_DEFAULT_IN_UIBINDER);
String uiBinderGssDefaultValue = uiBinderGssDefaultProp.getValues().get(0);
gssDefaultInUiBinder = Boolean.parseBoolean(uiBinderGssDefaultValue);
} catch (BadPropertyValueException ex) {
logger.log(Type.ERROR, "Unable to determine default for GSS in UiBinder");
throw new UnableToCompleteException();
}
return new GssOptions(gssEnabled, conversionMode, gssDefaultInUiBinder);
}
private static synchronized void write(Set<String> variables) {
for (String atDef : variables) {
if (writtenAtDefs.add(atDef)) {
printWriter.println("@def " + atDef + " 1px;");
}
}
printWriter.flush();
}
/**
* {@link ErrorManager} used to log the errors and warning messages produced by the different
* {@link com.google.gwt.thirdparty.common.css.compiler.ast.CssCompilerPass}.
*/
public static class LoggerErrorManager implements ErrorManager {
private final TreeLogger logger;
private boolean hasErrors;
public LoggerErrorManager(TreeLogger logger) {
this.logger = logger;
}
@Override
public void generateReport() {
// do nothing
}
@Override
public boolean hasErrors() {
return hasErrors;
}
@Override
public void report(GssError error) {
String fileName = "";
String location = "";
SourceCodeLocation codeLocation = error.getLocation();
if (codeLocation != null) {
fileName = codeLocation.getSourceCode().getFileName();
location = "[line: " + codeLocation.getBeginLineNumber() + " column: " + codeLocation
.getBeginIndexInLine() + "]";
}
logger.log(Type.ERROR, "Error in " + fileName + location + ": " + error.getMessage());
hasErrors = true;
}
@Override
public void reportWarning(GssError warning) {
logger.log(Type.WARN, warning.getMessage());
}
}
private static class ConversionResult {
final String gss;
final Map<String, String> defNameMapping;
private ConversionResult(String gss, Map<String, String> defNameMapping) {
this.gss = gss;
this.defNameMapping = defNameMapping;
}
}
private static class RenamingResult {
final Map<String, String> mapping;
final Set<String> externalClassCandidate;
private RenamingResult(Map<String, String> mapping, Set<String> externalClassCandidate) {
this.mapping = mapping;
this.externalClassCandidate = externalClassCandidate;
}
}
private static class CssParsingResult {
final CssTree tree;
final List<String> permutationAxes;
final Map<String, String> originalConstantNameMapping;
final Set<String> trueConditions;
private CssParsingResult(CssTree tree, List<String> permutationAxis, Set<String> trueConditions,
Map<String, String> originalConstantNameMapping) {
this.tree = tree;
this.permutationAxes = permutationAxis;
this.originalConstantNameMapping = originalConstantNameMapping;
this.trueConditions = trueConditions;
}
}
/**
* Predicate implementation used during the conversion to GSS.
*/
private static class ConfigurationPropertyMatcher implements Predicate<String> {
private final PropertyOracle propertyOracle;
private final TreeLogger logger;
private boolean error;
ConfigurationPropertyMatcher(ResourceContext context, TreeLogger logger) {
this.logger = logger;
propertyOracle = context.getGeneratorContext().getPropertyOracle();
}
@Override
public boolean apply(String booleanCondition) {
// if the condition is negated, the string parameter contains the ! operator if this method
// is called during the conversion to GSS
if (booleanCondition.startsWith("!")) {
booleanCondition = booleanCondition.substring(1);
}
try {
ConfigurationProperty property = propertyOracle.getConfigurationProperty(booleanCondition);
boolean valid = checkPropertyIsSingleValueAndBoolean(property, logger);
error |= !valid;
return valid;
} catch (BadPropertyValueException e) {
return false;
}
}
}
// To be sure to avoid conflict during the style classes renaming between different GssResources,
// we will create a different prefix for each GssResource. We use a MinimalSubstitutionMap
// that will create a String with 1-6 characters in length but keeping the length of the prefix
// as short as possible. For instance if we have two GssResources to compile, the prefix
// for the first resource will be 'a' and the prefix for the second resource will be 'b' and so on
private static final SubstitutionMap resourcePrefixBuilder = new MinimalSubstitutionMap();
private static final String KEY_CONVERSION_MODE = "CssResource.conversionMode";
private static final String KEY_STYLE = "CssResource.style";
private static final String ALLOWED_AT_RULE = "CssResource.allowedAtRules";
private static final String ALLOWED_FUNCTIONS = "CssResource.allowedFunctions";
private static final String KEY_OBFUSCATION_PREFIX = "CssResource.obfuscationPrefix";
private static final String KEY_CLASS_PREFIX = "cssResourcePrefix";
private static final String KEY_BY_CLASS_AND_METHOD = "cssResourceClassAndMethod";
private static final String KEY_HAS_CACHED_DATA = "hasCachedData";
private static final String KEY_SHARED_METHODS = "sharedMethods";
private static final char[] BASE32_CHARS = new char[]{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', '0', '1',
'2', '3', '4', '5', '6'};
// We follow CSS specification to detect the charset:
// - Authors using an @charset rule must place the rule at the very beginning of the style sheet,
// preceded by no characters.
// - @charset must be written literally, i.e., the 10 characters '@charset "' (lowercase, no
// backslash escapes), followed by the encoding name, followed by '";'.
// see: http://www.w3.org/TR/CSS2/syndata.html#charset
private static final Pattern CHARSET = Pattern.compile("^@charset \"([^\"]*)\";");
private static final int CHARSET_MIN_LENGTH = "@charset \"\";".length();
/**
* Returns the import prefix for a type, including the trailing hyphen.
*/
public static String getImportPrefix(JClassType importType) {
String prefix = importType.getSimpleSourceName();
ImportedWithPrefix exp = importType.getAnnotation(ImportedWithPrefix.class);
if (exp != null) {
prefix = exp.value();
}
return prefix + "-";
}
private static String encode(long id) {
assert id >= 0;
StringBuilder b = new StringBuilder();
// Use only guaranteed-alpha characters for the first character
b.append(BASE32_CHARS[(int) (id & 0xf)]);
id >>= 4;
while (id != 0) {
b.append(BASE32_CHARS[(int) (id & 0x1f)]);
id >>= 5;
}
return b.toString();
}
private static boolean checkPropertyIsSingleValueAndBoolean(ConfigurationProperty property,
TreeLogger logger) {
List<String> values = property.getValues();
if (values.size() > 1) {
logger.log(Type.ERROR, "The configuration property " + property.getName() + " is used in " +
"a conditional css and cannot be a multi-valued property");
return false;
}
String value = values.get(0);
if (!"true".equals(value) && !"false".equals(value)) {
logger.log(Type.ERROR, "The configuration property " + property.getName() + " is used in " +
"a conditional css. Its value must be either \"true\" or \"false\"");
return false;
}
return true;
}
/**
* Temporary method needed when GSS and the old CSS syntax are both supported by the sdk.
* It aims to choose the right resource file according to whether gss is enabled or not. If gss is
* enabled, it will try to find the resource file ending by .gss first. If GSS is disabled it will
* try to find the .css file. This logic is applied even if a
* {@link com.google.gwt.resources.client.ClientBundle.Source} annotation is used to define
* the resource file.
* <p>
* This method can be deleted once the support for the old CssResource is removed and use directly
* ResourceGeneratorUtil.findResources().
*/
static URL[] findResources(TreeLogger logger, ResourceContext context, JMethod method,
boolean gssEnabled) throws UnableToCompleteException {
boolean isSourceAnnotationUsed = method.getAnnotation(Source.class) != null;
if (!isSourceAnnotationUsed) {
// ResourceGeneratorUtil will try to find automatically the resource file. Give him the right
// extension to use first
String[] extensions = gssEnabled ?
new String[]{".gss", ".css"} : new String[]{".css", ".gss"};
return ResourceGeneratorUtil.findResources(logger, context, method, extensions);
}
// find the original resource files specified by the @Source annotation
URL[] originalResources = ResourceGeneratorUtil.findResources(logger, context, method);
URL[] resourcesToUse = new URL[originalResources.length];
String preferredExtension = gssEnabled ? ".gss" : ".css";
// Try to find all the resources by using the preferred extension according to whether gss is
// enabled or not. If one file with the preferred extension is missing, return the original
// resource files otherwise return the preferred files.
String[] sourceFiles = method.getAnnotation(Source.class).value();
for (int i = 0; i < sourceFiles.length; i++) {
String original = sourceFiles[i];
if (!original.endsWith(preferredExtension) && original.length() > 4) {
String preferredFile = original.substring(0, original.length() - 4) + preferredExtension;
// try to find the resource relative to the package
String path = method.getEnclosingType().getPackage().getName().replace('.', '/') + '/';
URL preferredUrl = ResourceGeneratorUtil
.tryFindResource(logger, context.getGeneratorContext(), context, path + preferredFile);
if (preferredUrl == null) {
// if it doesn't exist, assume it is absolute
preferredUrl = ResourceGeneratorUtil
.tryFindResource(logger, context.getGeneratorContext(), context, preferredFile);
}
if (preferredUrl == null) {
// avoid to mix gss and css, if one file with the preferred extension is missing
return originalResources;
}
logger.log(Type.DEBUG, "Preferred resource file found: " + preferredFile + ". This file " +
"will be used in replacement of " + original);
resourcesToUse[i] = preferredUrl;
} else {
// gss and css files shouldn't be used together for a same resource. So if one of the file
// is using the the preferred extension, return the original resources. If the dev has mixed
// gss and ccs files, that will fail later.
return originalResources;
}
}
return resourcesToUse;
}
private Map<JMethod, CssParsingResult> cssParsingResultMap;
private Set<String> allowedNonStandardFunctions;
private LoggerErrorManager errorManager;
private JMethod getTextMethod;
private JMethod ensuredInjectedMethod;
private JMethod getNameMethod;
private String obfuscationPrefix;
private CssObfuscationStyle obfuscationStyle;
private Set<String> allowedAtRules;
private Map<JClassType, Map<String, String>> replacementsByClassAndMethod;
private Map<JMethod, String> replacementsForSharedMethods;
private final GssOptions gssOptions;
public GssResourceGenerator(GssOptions gssOptions) {
this.gssOptions = gssOptions;
}
@Override
public String createAssignment(TreeLogger logger, ResourceContext context, JMethod method)
throws UnableToCompleteException {
CssParsingResult cssParsingResult = cssParsingResultMap.get(method);
CssTree cssTree = cssParsingResult.tree;
RenamingResult renamingResult = doClassRenaming(cssTree, method, logger, context);
// TODO : Should we foresee configuration properties for simplifyCss and eliminateDeadCode
// booleans ?
ConstantDefinitions constantDefinitions = optimizeTree(cssParsingResult, context, true, true,
logger);
checkErrors();
Set<String> externalClasses = revertRenamingOfExternalClasses(cssTree, renamingResult);
checkErrors();
// Validate that classes not assigned to one of the interface methods are external
validateExternalClasses(externalClasses, renamingResult.externalClassCandidate, method, logger);
SourceWriter sw = new StringSourceWriter();
sw.println("new " + method.getReturnType().getQualifiedSourceName() + "() {");
sw.indent();
Map<JMethod, String> actualReplacements = writeMethods(logger, context, method, sw, constantDefinitions,
cssParsingResult.originalConstantNameMapping, renamingResult.mapping);
sw.outdent();
sw.println("}");
CssResourceGenerator.outputCssMapArtifact(logger, context, method, actualReplacements);
return sw.toString();
}
private void validateExternalClasses(Set<String> externalClasses,
Set<String> externalClassCandidates, JMethod method,
TreeLogger logger) throws UnableToCompleteException {
if (!isStrictResource(method)) {
return;
}
boolean hasError = false;
for (String candidate : externalClassCandidates) {
if (!externalClasses.contains(candidate)) {
logger.log(Type.ERROR, "The following non-obfuscated class is present in a strict "
+ "CssResource: " + candidate + ". Fix by adding String accessor "
+ "method(s) to the CssResource interface for obfuscated classes, "
+ "or use an @external declaration for unobfuscated classes.");
hasError = true;
}
}
if (hasError) {
throw new UnableToCompleteException();
}
}
@Override
public void init(TreeLogger logger, ResourceContext context) throws UnableToCompleteException {
cssParsingResultMap = new IdentityHashMap<>();
errorManager = new LoggerErrorManager(logger);
allowedNonStandardFunctions = new HashSet<>();
allowedAtRules = Sets.newHashSet(ExternalClassesCollector.EXTERNAL_AT_RULE);
try {
PropertyOracle propertyOracle = context.getGeneratorContext().getPropertyOracle();
ConfigurationProperty styleProp = propertyOracle.getConfigurationProperty(KEY_STYLE);
obfuscationStyle = CssObfuscationStyle.getObfuscationStyle(styleProp.getValues().get(0));
obfuscationPrefix = getObfuscationPrefix(propertyOracle, context);
ConfigurationProperty allowedAtRuleProperty = propertyOracle
.getConfigurationProperty(ALLOWED_AT_RULE);
allowedAtRules.addAll(allowedAtRuleProperty.getValues());
ConfigurationProperty allowedFunctionsProperty = propertyOracle
.getConfigurationProperty(ALLOWED_FUNCTIONS);
allowedNonStandardFunctions.addAll(allowedFunctionsProperty.getValues());
ClientBundleRequirements requirements = context.getRequirements();
requirements.addConfigurationProperty(KEY_STYLE);
requirements.addConfigurationProperty(KEY_OBFUSCATION_PREFIX);
requirements.addConfigurationProperty(ALLOWED_AT_RULE);
requirements.addConfigurationProperty(ALLOWED_FUNCTIONS);
requirements.addConfigurationProperty(KEY_CONVERSION_MODE);
} catch (BadPropertyValueException e) {
logger.log(TreeLogger.ERROR, "Unable to query module property", e);
throw new UnableToCompleteException();
}
TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle();
JClassType cssResourceInterface = typeOracle.findType(CssResource.class.getCanonicalName());
JClassType resourcePrototypeInterface = typeOracle.findType(ResourcePrototype.class
.getCanonicalName());
try {
getTextMethod = cssResourceInterface.getMethod("getText", new JType[0]);
ensuredInjectedMethod = cssResourceInterface.getMethod("ensureInjected", new JType[0]);
getNameMethod = resourcePrototypeInterface.getMethod("getName", new JType[0]);
} catch (NotFoundException e) {
logger.log(TreeLogger.ERROR, "Unable to lookup methods from CssResource and " +
"ResourcePrototype interface", e);
throw new UnableToCompleteException();
}
initReplacement(context);
}
@SuppressWarnings("unchecked")
private void initReplacement(ResourceContext context) {
if (context.getCachedData(KEY_HAS_CACHED_DATA, Boolean.class) != Boolean.TRUE) {
context.putCachedData(KEY_SHARED_METHODS, new IdentityHashMap<JMethod, String>());
context.putCachedData(KEY_BY_CLASS_AND_METHOD, new IdentityHashMap<JClassType, Map<String,
String>>());
context.putCachedData(KEY_HAS_CACHED_DATA, Boolean.TRUE);
}
replacementsByClassAndMethod = context.getCachedData(KEY_BY_CLASS_AND_METHOD, Map.class);
replacementsForSharedMethods = context.getCachedData(KEY_SHARED_METHODS, Map.class);
}
private String getObfuscationPrefix(PropertyOracle propertyOracle, ResourceContext context)
throws BadPropertyValueException {
String prefix = propertyOracle.getConfigurationProperty(KEY_OBFUSCATION_PREFIX)
.getValues().get(0);
if ("empty".equalsIgnoreCase(prefix)) {
return "";
} else if ("default".equalsIgnoreCase(prefix)) {
return getDefaultObfuscationPrefix(context);
}
return prefix;
}
private String getDefaultObfuscationPrefix(ResourceContext context) {
String prefix = context.getCachedData(KEY_CLASS_PREFIX, String.class);
if (prefix == null) {
prefix = computeDefaultPrefix(context);
context.putCachedData(KEY_CLASS_PREFIX, prefix);
}
return prefix;
}
private String computeDefaultPrefix(ResourceContext context) {
SortedSet<JClassType> gssResources = computeOperableTypes(context);
Adler32 checksum = new Adler32();
for (JClassType type : gssResources) {
checksum.update(Util.getBytes(type.getQualifiedSourceName()));
}
int seed = Math.abs((int) checksum.getValue());
return encode(seed) + "-";
}
private SortedSet<JClassType> computeOperableTypes(ResourceContext context) {
TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle();
JClassType baseInterface = typeOracle.findType(CssResource.class.getCanonicalName());
SortedSet<JClassType> toReturn = new TreeSet<>(new JClassOrderComparator());
JClassType[] cssResourceSubtypes = baseInterface.getSubtypes();
for (JClassType type : cssResourceSubtypes) {
if (type.isInterface() != null) {
toReturn.add(type);
}
}
return toReturn;
}
@Override
public void prepare(TreeLogger logger, ResourceContext context,
ClientBundleRequirements requirements, JMethod method) throws UnableToCompleteException {
if (method.getReturnType().isInterface() == null) {
logger.log(TreeLogger.ERROR, "Return type must be an interface");
throw new UnableToCompleteException();
}
URL[] resourceUrls = findResources(logger, context, method, gssOptions.isEnabled());
if (resourceUrls.length == 0) {
logger.log(TreeLogger.ERROR, "At least one source must be specified");
throw new UnableToCompleteException();
}
CssParsingResult cssParsingResult = parseResources(Lists.newArrayList(resourceUrls), context,
logger);
cssParsingResultMap.put(method, cssParsingResult);
for (String permutationAxis : cssParsingResult.permutationAxes) {
try {
context.getRequirements().addPermutationAxis(permutationAxis);
} catch (BadPropertyValueException e) {
logger.log(TreeLogger.ERROR, "Unknown deferred-binding property " + permutationAxis, e);
throw new UnableToCompleteException();
}
}
}
@Override
protected String getCssExpression(TreeLogger logger, ResourceContext context,
JMethod method) throws UnableToCompleteException {
CssTree cssTree = cssParsingResultMap.get(method).tree;
String standard = printCssTree(cssTree);
// TODO add configuration properties for swapLtrRtlInUrl, swapLeftRightInUrl and
// shouldFlipConstantReferences booleans
RecordingBidiFlipper recordingBidiFlipper =
new RecordingBidiFlipper(cssTree.getMutatingVisitController(), false, false, true);
recordingBidiFlipper.runPass();
if (recordingBidiFlipper.nodeFlipped()) {
String reversed = printCssTree(cssTree);
return LocaleInfo.class.getName() + ".getCurrentLocale().isRTL() ? "
+ reversed + " : " + standard;
} else {
return standard;
}
}
private void checkErrors() throws UnableToCompleteException {
if (errorManager.hasErrors()) {
throw new UnableToCompleteException();
}
}
private RenamingResult doClassRenaming(CssTree cssTree, JMethod method, TreeLogger logger,
ResourceContext context) throws UnableToCompleteException {
Map<String, Map<String, String>> replacementsWithPrefix = computeReplacements(method, logger,
context);
RenamingSubstitutionMap substitutionMap = new RenamingSubstitutionMap(replacementsWithPrefix);
new CssClassRenaming(cssTree.getMutatingVisitController(), substitutionMap, null).runPass();
Map<String, String> mapping = replacementsWithPrefix.get("");
mapping = Maps.newHashMap(Maps.filterKeys(mapping, Predicates.in(substitutionMap
.getStyleClasses())));
return new RenamingResult(mapping, substitutionMap.getExternalClassCandidates());
}
/**
* When the tree is fully processed, we can now collect the external classes and revert the
* renaming for these classes. We cannot collect the external classes during the original renaming
* because some external at-rule could be located inside a conditional block and could be
* removed when these blocks are evaluated.
*/
private Set<String> revertRenamingOfExternalClasses(CssTree cssTree, RenamingResult renamingResult) {
ExternalClassesCollector externalClassesCollector = new ExternalClassesCollector(cssTree
.getMutatingVisitController(), errorManager);
externalClassesCollector.runPass();
Map<String, String> styleClassesMapping = renamingResult.mapping;
// set containing all the style classes before the renaming.
Set<String> allStyleClassSet = Sets.newHashSet(styleClassesMapping.keySet());
// add the style classes that aren't associated to a method
allStyleClassSet.addAll(renamingResult.externalClassCandidate);
Set<String> externalClasses = externalClassesCollector.getExternalClassNames(allStyleClassSet,
renamingResult.externalClassCandidate);
final Map<String, String> revertMap = new HashMap<>(externalClasses.size());
for (String external : externalClasses) {
revertMap.put(styleClassesMapping.get(external), external);
// override the mapping
styleClassesMapping.put(external, external);
}
SubstitutionMap revertExternalClasses = new SubstitutionMap() {
@Override
public String get(String key) {
return revertMap.get(key);
}
};
new CssClassRenaming(cssTree.getMutatingVisitController(), revertExternalClasses, null)
.runPass();
return externalClasses;
}
private boolean isStrictResource(JMethod method) {
NotStrict notStrict = method.getAnnotation(NotStrict.class);
return notStrict == null;
}
private void finalizeTree(CssTree cssTree) throws UnableToCompleteException {
new CheckDependencyNodes(cssTree.getMutatingVisitController(), errorManager, false).runPass();
// Don't continue if errors exist
checkErrors();
new CreateStandardAtRuleNodes(cssTree.getMutatingVisitController(), errorManager).runPass();
new CreateMixins(cssTree.getMutatingVisitController(), errorManager).runPass();
new CreateDefinitionNodes(cssTree.getMutatingVisitController(), errorManager).runPass();
new CreateConstantReferences(cssTree.getMutatingVisitController()).runPass();
new CreateConditionalNodes(cssTree.getMutatingVisitController(), errorManager).runPass();
new CreateRuntimeConditionalNodes(cssTree.getMutatingVisitController()).runPass();
new CreateForLoopNodes(cssTree.getMutatingVisitController(), errorManager).runPass();
new CreateComponentNodes(cssTree.getMutatingVisitController(), errorManager).runPass();
new ValidatePropertyValues(cssTree.getVisitController(), errorManager).runPass();
new HandleUnknownAtRuleNodes(cssTree.getMutatingVisitController(), errorManager,
allowedAtRules, true, false).runPass();
new ProcessKeyframes(cssTree.getMutatingVisitController(), errorManager, true, true).runPass();
new CreateVendorPrefixedKeyframes(cssTree.getMutatingVisitController(),
errorManager).runPass();
new UnrollLoops(cssTree.getMutatingVisitController(), errorManager).runPass();
new ProcessRefiners(cssTree.getMutatingVisitController(), errorManager, true).runPass();
new MarkNonFlippableNodes(cssTree.getMutatingVisitController(), errorManager).runPass();
}
private ConstantDefinitions optimizeTree(CssParsingResult cssParsingResult, ResourceContext context,
boolean simplifyCss, boolean eliminateDeadStyles, TreeLogger logger)
throws UnableToCompleteException {
CssTree cssTree = cssParsingResult.tree;
// Collect mixin definitions and replace mixins
CollectMixinDefinitions collectMixinDefinitions = new CollectMixinDefinitions(
cssTree.getMutatingVisitController(), errorManager);
collectMixinDefinitions.runPass();
new ReplaceMixins(cssTree.getMutatingVisitController(), errorManager,
collectMixinDefinitions.getDefinitions()).runPass();
new ProcessComponents<>(cssTree.getMutatingVisitController(), errorManager).runPass();
RuntimeConditionalBlockCollector runtimeConditionalBlockCollector = new
RuntimeConditionalBlockCollector(cssTree.getVisitController());
runtimeConditionalBlockCollector.runPass();
Set<String> trueCompileTimeConditions = ImmutableSet.<String>builder()
.addAll(getCurrentDeferredBindingProperties(context, cssParsingResult.permutationAxes,
logger))
.addAll(getTrueConfigurationProperties(context, cssParsingResult.trueConditions, logger))
.build();
new ExtendedEliminateConditionalNodes(cssTree.getMutatingVisitController(),
trueCompileTimeConditions, runtimeConditionalBlockCollector.getRuntimeConditionalBlock())
.runPass();
new ValidateRuntimeConditionalNode(cssTree.getVisitController(), errorManager,
gssOptions.isLenientConversion()).runPass();
// Don't continue if errors exist
checkErrors();
CollectConstantDefinitions collectConstantDefinitionsPass = new CollectConstantDefinitions(
cssTree);
collectConstantDefinitionsPass.runPass();
ReplaceConstantReferences replaceConstantReferences = new ReplaceConstantReferences(cssTree,
collectConstantDefinitionsPass.getConstantDefinitions(), false, errorManager, false);
replaceConstantReferences.runPass();
new ImageSpriteCreator(cssTree.getMutatingVisitController(), context, errorManager).runPass();
Map<String, GssFunction> gssFunctionMap = new GwtGssFunctionMapProvider(context).get();
new ResolveCustomFunctionNodes(cssTree.getMutatingVisitController(), errorManager,
gssFunctionMap, true, allowedNonStandardFunctions).runPass();
// collect the final value of the constants and remove them.
collectConstantDefinitionsPass = new CollectAndRemoveConstantDefinitions(cssTree);
collectConstantDefinitionsPass.runPass();
if (simplifyCss) {
// Eliminate empty rules.
new EliminateEmptyRulesetNodes(cssTree.getMutatingVisitController()).runPass();
// Eliminating units for zero values.
new EliminateUnitsFromZeroNumericValues(cssTree.getMutatingVisitController()).runPass();
// Optimize color values.
new ColorValueOptimizer(cssTree.getMutatingVisitController()).runPass();
// Compress redundant top-right-bottom-left value lists.
new AbbreviatePositionalValues(cssTree.getMutatingVisitController()).runPass();
}
if (eliminateDeadStyles) {
// Report errors for duplicate declarations
new DisallowDuplicateDeclarations(cssTree.getVisitController(), errorManager).runPass();
// Split rules by selector and declaration.
new SplitRulesetNodes(cssTree.getMutatingVisitController()).runPass();
// Dead code elimination.
new MarkRemovableRulesetNodes(cssTree).runPass();
new EliminateUselessRulesetNodes(cssTree).runPass();
// Merge of rules with same selector.
new MergeAdjacentRulesetNodesWithSameSelector(cssTree).runPass();
new EliminateUselessRulesetNodes(cssTree).runPass();
// Merge of rules with same styles.
new MergeAdjacentRulesetNodesWithSameDeclarations(cssTree).runPass();
new EliminateUselessRulesetNodes(cssTree).runPass();
new MarkNonFlippableNodes(cssTree.getMutatingVisitController(), errorManager).runPass();
}
return collectConstantDefinitionsPass.getConstantDefinitions();
}
private Set<String> getTrueConfigurationProperties(ResourceContext context,
Set<String> configurationProperties, TreeLogger logger) throws UnableToCompleteException {
Builder<String> setBuilder = ImmutableSet.builder();
PropertyOracle oracle = context.getGeneratorContext().getPropertyOracle();
for (String property : configurationProperties) {
try {
// TODO : only check configuration properties ?
ConfigurationProperty confProp = oracle.getConfigurationProperty(property);
if (!checkPropertyIsSingleValueAndBoolean(confProp, logger)) {
throw new UnableToCompleteException();
}
if ("true".equals(confProp.getValues().get(0))) {
setBuilder.add(property);
}
} catch (BadPropertyValueException e1) {
logger.log(Type.ERROR, "Unknown configuration property [" + property + "]");
throw new UnableToCompleteException();
}
}
return setBuilder.build();
}
private Set<String> getCurrentDeferredBindingProperties(ResourceContext context,
List<String> permutationAxes, TreeLogger logger) throws UnableToCompleteException {
Builder<String> setBuilder = ImmutableSet.builder();
PropertyOracle oracle = context.getGeneratorContext().getPropertyOracle();
for (String permutationAxis : permutationAxes) {
String propValue;
try {
SelectionProperty selProp = oracle.getSelectionProperty(null,
permutationAxis);
propValue = selProp.getCurrentValue();
} catch (BadPropertyValueException e) {
try {
ConfigurationProperty confProp = oracle.getConfigurationProperty(permutationAxis);
propValue = confProp.getValues().get(0);
} catch (BadPropertyValueException e1) {
logger.log(Type.ERROR, "Unknown configuration property [" + permutationAxis + "]");
throw new UnableToCompleteException();
}
}
if (propValue != null) {
setBuilder.add(permutationAxis + ":" + propValue);
}
}
return setBuilder.build();
}
private CssParsingResult parseResources(List<URL> resources, ResourceContext context,
TreeLogger logger) throws UnableToCompleteException {
List<SourceCode> sourceCodes = new ArrayList<>(resources.size());
ImmutableMap.Builder<String, String> constantNameMappingBuilder = ImmutableMap.builder();
// assert that we only support either gss or css on one resource.
boolean css = ensureEitherCssOrGss(resources, logger);
if (css && gssOptions.isAutoConversionOff()) {
logger.log(Type.ERROR,
"Your ClientBundle is referencing css files instead of gss. "
+ "You will need to either convert these files to gss using the "
+ "converter tool or turn on auto convertion in your gwt.xml file. "
+ "Note: Autoconversion will be removed in the next version of GWT, "
+ "you will need to move to gss."
+ "Add this line to your gwt.xml file to temporary avoid this:"
+ "<set-configuration-property name=\"CssResource.conversionMode\""
+ " value=\"strict\" /> "
+ "Details on how to migrate to GSS can be found at: http://goo.gl/tEQnmJ");
throw new UnableToCompleteException();
}
if (css) {
String concatenatedCss = concatCssFiles(resources, logger);
ConversionResult result = convertToGss(concatenatedCss, context, logger);
if (shouldEmitVariables) {
write(result.defNameMapping.keySet());
}
String gss = result.gss;
String name = "[auto-converted gss files from : " + resources + "]";
sourceCodes.add(new SourceCode(name, gss));
constantNameMappingBuilder.putAll(result.defNameMapping);
} else {
for (URL stylesheet : resources) {
sourceCodes.add(readUrlContent(stylesheet, logger));
}
}
CssTree tree;
try {
tree = new GssParser(sourceCodes).parse();
} catch (GssParserException e) {
logger.log(TreeLogger.ERROR, "Unable to parse CSS", e);
throw new UnableToCompleteException();
}
// create more explicit nodes
finalizeTree(tree);
checkErrors();
// collect boolean conditions that have to be mapped to configuration properties
BooleanConditionCollector booleanConditionCollector = new BooleanConditionCollector(tree
.getMutatingVisitController());
booleanConditionCollector.runPass();
// collect permutations axis used in conditionals.
PermutationsCollector permutationsCollector = new PermutationsCollector(tree
.getMutatingVisitController());
permutationsCollector.runPass();
return new CssParsingResult(tree, permutationsCollector.getPermutationAxes(),
booleanConditionCollector.getBooleanConditions(), constantNameMappingBuilder.build());
}
private static String extractCharset(ByteSource byteSource) throws IOException {
String firstLine = byteSource.asCharSource(Charsets.UTF_8).readFirstLine();
if (firstLine != null) {
Matcher matcher = CHARSET.matcher(firstLine);
if (matcher.matches()) {
return matcher.group(1);
}
}
return null;
}
private ConversionResult convertToGss(String concatenatedCss, ResourceContext context,
TreeLogger logger) throws UnableToCompleteException {
File tempFile = null;
FileOutputStream fos = null;
try {
// We actually need a URL for the old CssResource to work. So create a temp file.
tempFile = File.createTempFile(UUID.randomUUID() + "css_converter", "css.tmp");
fos = new FileOutputStream(tempFile);
IOUtils.write(concatenatedCss, fos);
fos.close();
ConfigurationPropertyMatcher configurationPropertyMatcher =
new ConfigurationPropertyMatcher(context, logger);
Css2Gss converter = new Css2Gss(tempFile.toURI().toURL(), logger,
gssOptions.isLenientConversion(), configurationPropertyMatcher);
String gss = converter.toGss();
if (configurationPropertyMatcher.error) {
throw new UnableToCompleteException();
}
return new ConversionResult(gss, converter.getDefNameMapping());
} catch (Css2GssConversionException e) {
String message = "An error occurs during the automatic conversion: " + e.getMessage();
if (!gssOptions.isLenientConversion()) {
message += "\n You should try to change the faulty css to fix this error. If you are " +
"unable to change the css, you can setup the automatic conversion to be lenient. Add " +
"the following line to your gwt.xml file: " +
"<set-configuration-property name=\"CssResource.conversionMode\" value=\"lenient\" />";
}
logger.log(Type.ERROR, message, e);
throw new UnableToCompleteException();
} catch (IOException e) {
logger.log(Type.ERROR, "Error while writing temporary css file", e);
throw new UnableToCompleteException();
} finally {
if (tempFile != null) {
tempFile.delete();
}
if (fos != null) {
IOUtils.closeQuietly(fos);
}
}
}
public static String concatCssFiles(List<URL> resources, TreeLogger logger)
throws UnableToCompleteException {
StringBuffer buffer = new StringBuffer();
for (URL stylesheet : resources) {
try {
String fileContent = Resources.asByteSource(stylesheet).asCharSource(Charsets.UTF_8)
.read();
buffer.append(fileContent);
buffer.append("\n");
} catch (IOException e) {
logger.log(TreeLogger.ERROR, "Unable to parse CSS", e);
throw new UnableToCompleteException();
}
}
return buffer.toString();
}
private boolean ensureEitherCssOrGss(List<URL> resources, TreeLogger logger)
throws UnableToCompleteException {
boolean css = resources.get(0).toString().endsWith(".css");
for (URL stylesheet : resources) {
if (css && !stylesheet.toString().endsWith(".css")) {
logger.log(Type.ERROR,
"Only either css files or gss files are supported on one interface");
throw new UnableToCompleteException();
} else if (!css && !stylesheet.toString().endsWith(".gss")) {
logger.log(Type.ERROR,
"Only either css files or gss files are supported on one interface");
throw new UnableToCompleteException();
}
}
return css;
}
private String printCssTree(CssTree tree) {
CssPrinter cssPrinterPass = new CssPrinter(tree);
cssPrinterPass.runPass();
return cssPrinterPass.getCompactPrintedString();
}
private boolean writeClassMethod(TreeLogger logger, JMethod userMethod,
Map<String, String> substitutionMap, SourceWriter sw) throws
UnableToCompleteException {
if (userMethod.getParameters().length > 0) {
logger.log(Type.ERROR, "The method [" + userMethod.getName() + "] shouldn't contain any " +
"parameters");
throw new UnableToCompleteException();
}
String name = getClassName(userMethod);
String value = substitutionMap.get(name);
if (value == null) {
logger.log(Type.ERROR, "The following style class [" + name + "] is missing from the source" +
" CSS file");
return false;
} else {
writeSimpleGetter(userMethod, "\"" + value + "\"", sw);
}
return true;
}
private String getClassName(JMethod method) {
String name = method.getName();
ClassName classNameOverride = method.getAnnotation(ClassName.class);
if (classNameOverride != null) {
name = classNameOverride.value();
}
return name;
}
private boolean writeDefMethod(CssDefinitionNode definitionNode, TreeLogger logger,
JMethod userMethod, SourceWriter sw) throws UnableToCompleteException {
String name = userMethod.getName();
JClassType classReturnType = userMethod.getReturnType().isClass();
List<CssValueNode> params = definitionNode.getParameters();
if (params.size() != 1 && !isReturnTypeString(classReturnType)) {
logger.log(TreeLogger.ERROR, "@def rule " + name
+ " must define exactly one value or return type must be String");
return false;
}
String returnExpr;
if (isReturnTypeString(classReturnType)) {
List<String> returnValues = new ArrayList<String>();
for (CssValueNode valueNode : params) {
returnValues.add(Generator.escape(valueNode.toString()));
}
returnExpr = "\"" + Joiner.on(" ").join(returnValues) + "\"";
} else {
JPrimitiveType returnType = userMethod.getReturnType().isPrimitive();
if (returnType == null) {
logger.log(TreeLogger.ERROR, name + ": Return type must be primitive type " +
"or String for @def accessors");
return false;
}
CssValueNode valueNode = params.get(0);
// when a constant refers to another constant, closure-stylesheet wrap the CssNumericNode in
// a CssCompositeValueNode. Unwrap it.
if (valueNode instanceof CssCompositeValueNode) {
CssCompositeValueNode toUnwrap = (CssCompositeValueNode) valueNode;
if (toUnwrap.getValues().size() == 1) {
valueNode = toUnwrap.getValues().get(0);
}
}
if (!(valueNode instanceof CssNumericNode)) {
logger.log(TreeLogger.ERROR, "The value of the constant defined by @" + name + " is not a" +
" numeric");
return false;
}
String numericValue = ((CssNumericNode) valueNode).getNumericPart();
if (returnType == JPrimitiveType.INT || returnType == JPrimitiveType.LONG) {
returnExpr = "" + Long.parseLong(numericValue);
} else if (returnType == JPrimitiveType.FLOAT) {
returnExpr = numericValue + "F";
} else if (returnType == JPrimitiveType.DOUBLE) {
returnExpr = "" + numericValue;
} else {
logger.log(TreeLogger.ERROR, returnType.getQualifiedSourceName()
+ " is not a valid primitive return type for @def accessors");
return false;
}
}
writeSimpleGetter(userMethod, returnExpr, sw);
return true;
}
private Map<JMethod, String> writeMethods(TreeLogger logger, ResourceContext context, JMethod method,
SourceWriter sw, ConstantDefinitions constantDefinitions,
Map<String, String> originalConstantNameMapping, Map<String, String> substitutionMap)
throws UnableToCompleteException {
JClassType gssResource = method.getReturnType().isInterface();
boolean success = true;
Map<JMethod, String> methodToClassName = new LinkedHashMap<>();
for (JMethod toImplement : gssResource.getOverridableMethods()) {
if (toImplement == getTextMethod) {
writeGetText(logger, context, method, sw);
} else if (toImplement == ensuredInjectedMethod) {
writeEnsureInjected(sw);
} else if (toImplement == getNameMethod) {
writeGetName(method, sw);
} else {
success &= writeUserMethod(logger, toImplement, sw, constantDefinitions,
originalConstantNameMapping, substitutionMap, methodToClassName);
}
}
if (!success) {
throw new UnableToCompleteException();
}
return methodToClassName;
}
private boolean writeUserMethod(TreeLogger logger, JMethod userMethod, SourceWriter sw,
ConstantDefinitions constantDefinitions, Map<String, String> originalConstantNameMapping,
Map<String, String> substitutionMap, Map<JMethod, String> methodToClassName)
throws UnableToCompleteException {
String className = getClassName(userMethod);
// method to access style class ?
if (substitutionMap.containsKey(className) &&
isReturnTypeString(userMethod.getReturnType().isClass())) {
methodToClassName.put(userMethod, substitutionMap.get(className));
return writeClassMethod(logger, userMethod, substitutionMap, sw);
}
// method to access constant value ?
CssDefinitionNode definitionNode;
String methodName = userMethod.getName();
if (originalConstantNameMapping.containsKey(methodName)) {
// method name maps a constant that has been renamed during the auto conversion
String constantName = originalConstantNameMapping.get(methodName);
definitionNode = constantDefinitions.getConstantDefinition(constantName);
} else {
definitionNode = constantDefinitions.getConstantDefinition(methodName);
if (definitionNode == null) {
// try with upper case
definitionNode = constantDefinitions.getConstantDefinition(toUpperCase(methodName));
}
}
if (definitionNode != null) {
return writeDefMethod(definitionNode, logger, userMethod, sw);
}
if (substitutionMap.containsKey(className)) {
// method matched a class name but not a constant and the return type is not a string
logger.log(Type.ERROR, "The return type of the method [" + userMethod.getName() + "] must " +
"be java.lang.String.");
throw new UnableToCompleteException();
}
// the method doesn't match a style class nor a constant
logger.log(Type.ERROR,
"The following method [" + userMethod.getName() + "()] doesn't match a constant" +
" nor a style class. You could fix that by adding ." + className + " {}"
);
return false;
}
/**
* Transform a camel case string to upper case. Each word is separated by a '_'
*
* @param camelCase
*/
private String toUpperCase(String camelCase) {
return CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, camelCase);
}
private Map<String, Map<String, String>> computeReplacements(JMethod method, TreeLogger logger,
ResourceContext context) throws UnableToCompleteException {
Map<String, Map<String, String>> replacementsWithPrefix = new HashMap<String, Map<String,
String>>();
replacementsWithPrefix
.put("", computeReplacementsForType(method.getReturnType().isInterface()));
// Process the Import annotation if any
Import imp = method.getAnnotation(Import.class);
if (imp != null) {
boolean fail = false;
TypeOracle typeOracle = context.getGeneratorContext().getTypeOracle();
for (Class<? extends CssResource> clazz : imp.value()) {
JClassType importType = typeOracle.findType(clazz.getName().replace('$', '.'));
assert importType != null : "TypeOracle does not have type " + clazz.getName();
// add this import type as a requirement for this generator
context.getRequirements().addTypeHierarchy(importType);
String prefix = getImportPrefix(importType);
if (replacementsWithPrefix.put(prefix, computeReplacementsForType(importType)) != null) {
logger.log(TreeLogger.ERROR, "Multiple imports that would use the prefix " + prefix);
fail = true;
}
}
if (fail) {
throw new UnableToCompleteException();
}
}
return replacementsWithPrefix;
}
private Map<String, String> computeReplacementsForType(JClassType cssResource) {
Map<String, String> replacements = replacementsByClassAndMethod.get(cssResource);
if (replacements == null) {
replacements = new HashMap<String, String>();
replacementsByClassAndMethod.put(cssResource, replacements);
String resourcePrefix = resourcePrefixBuilder.get(cssResource.getQualifiedSourceName());
// This substitution map will prefix each renamed class with the resource prefix and use a
// MinimalSubstitutionMap for computing the obfuscated name.
SubstitutionMap prefixingSubstitutionMap = new PrefixingSubstitutionMap(
new MinimalSubstitutionMap(), obfuscationPrefix + resourcePrefix + "-");
for (JMethod method : cssResource.getOverridableMethods()) {
if (method == getNameMethod || method == getTextMethod || method == ensuredInjectedMethod) {
continue;
}
String styleClass = getClassName(method);
if (replacementsForSharedMethods.containsKey(method)) {
replacements.put(styleClass, replacementsForSharedMethods.get(method));
} else {
String obfuscatedClassName = prefixingSubstitutionMap.get(styleClass);
String replacement = obfuscationStyle.getPrettyName(styleClass, cssResource,
obfuscatedClassName);
if (hasSharedAnnotation(method)) {
// We always use the base type for obfuscation if this is a shared method
replacement = obfuscationStyle.getPrettyName(styleClass, method.getEnclosingType(),
obfuscatedClassName);
replacementsForSharedMethods.put(method, replacement);
}
replacements.put(styleClass, replacement);
}
}
}
return replacements;
}
private boolean hasSharedAnnotation(JMethod method) {
JClassType enclosingType = method.getEnclosingType();
Shared shared = enclosingType.getAnnotation(Shared.class);
return shared != null;
}
}