| /* | |
| * Copyright 2009 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.css; | |
| import com.google.gwt.core.ext.TreeLogger; | |
| import com.google.gwt.core.ext.typeinfo.JMethod; | |
| import com.google.gwt.resources.client.CssResource.ClassName; | |
| import com.google.gwt.resources.css.ast.Context; | |
| import com.google.gwt.resources.css.ast.CssCompilerException; | |
| import com.google.gwt.resources.css.ast.CssDef; | |
| import com.google.gwt.resources.css.ast.CssSelector; | |
| import com.google.gwt.resources.css.ast.CssStylesheet; | |
| import com.google.gwt.resources.css.ast.CssVisitor; | |
| import java.util.ArrayList; | |
| import java.util.Collections; | |
| import java.util.HashMap; | |
| import java.util.HashSet; | |
| import java.util.IdentityHashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Set; | |
| import java.util.regex.Matcher; | |
| /** | |
| * Renames class selectors to their obfuscated names. | |
| */ | |
| public class ClassRenamer extends CssVisitor { | |
| /** | |
| * A tag to indicate that an externally-defined CSS class has no JMethod that | |
| * is used to access it. | |
| */ | |
| private static final Replacement UNREFERENCED_EXTERNAL = new Replacement( | |
| null, null); | |
| /* | |
| * TODO: Replace with Pair<A, B>. | |
| */ | |
| private static class Replacement { | |
| private JMethod method; | |
| private String obfuscatedClassName; | |
| public Replacement(JMethod method, String obfuscatedClassName) { | |
| this.method = method; | |
| this.obfuscatedClassName = obfuscatedClassName; | |
| } | |
| public JMethod getMethod() { | |
| return method; | |
| } | |
| public String getObfuscatedClassName() { | |
| return obfuscatedClassName; | |
| } | |
| /** | |
| * For debugging use only. | |
| */ | |
| @Override | |
| public String toString() { | |
| if (this == UNREFERENCED_EXTERNAL) { | |
| return "Unreferenced external class name"; | |
| } else { | |
| return method.getName() + "=" + obfuscatedClassName; | |
| } | |
| } | |
| } | |
| /** | |
| * Records replacements that have actually been performed. | |
| */ | |
| private final Map<JMethod, String> actualReplacements = new IdentityHashMap<JMethod, String>(); | |
| private final Map<String, Map<JMethod, String>> classReplacementsWithPrefix; | |
| private final Set<String> cssDefs = new HashSet<String>(); | |
| private final Set<String> externalClasses; | |
| private final TreeLogger logger; | |
| private final Set<JMethod> missingClasses; | |
| private final boolean strict; | |
| private final Set<String> unknownClasses = new HashSet<String>(); | |
| public ClassRenamer(TreeLogger logger, | |
| Map<String, Map<JMethod, String>> classReplacementsWithPrefix, | |
| boolean strict, Set<String> externalClasses) { | |
| this.logger = logger.branch(TreeLogger.DEBUG, "Replacing CSS class names"); | |
| this.classReplacementsWithPrefix = classReplacementsWithPrefix; | |
| this.strict = strict; | |
| this.externalClasses = externalClasses; | |
| // Require a definition for all classes in the default namespace | |
| assert classReplacementsWithPrefix.containsKey(""); | |
| missingClasses = new HashSet<JMethod>( | |
| classReplacementsWithPrefix.get("").keySet()); | |
| } | |
| @Override | |
| public void endVisit(CssDef x, Context ctx) { | |
| cssDefs.add(x.getKey()); | |
| } | |
| @Override | |
| public void endVisit(CssSelector x, Context ctx) { | |
| final Map<String, Replacement> potentialReplacements; | |
| potentialReplacements = computeReplacements(classReplacementsWithPrefix, | |
| externalClasses); | |
| String sel = x.getSelector(); | |
| int originalLength = sel.length(); | |
| Matcher ma = CssSelector.CLASS_SELECTOR_PATTERN.matcher(sel); | |
| StringBuilder sb = new StringBuilder(originalLength); | |
| int start = 0; | |
| while (ma.find()) { | |
| String sourceClassName = ma.group(1); | |
| Replacement entry = potentialReplacements.get(sourceClassName); | |
| if (entry == null) { | |
| unknownClasses.add(sourceClassName); | |
| continue; | |
| } else if (entry == UNREFERENCED_EXTERNAL) { | |
| // An @external without an accessor method. This is OK. | |
| continue; | |
| } | |
| JMethod method = entry.getMethod(); | |
| String obfuscatedClassName = entry.getObfuscatedClassName(); | |
| // Consume the interstitial portion of the original selector | |
| sb.append(sel.subSequence(start, ma.start(1))); | |
| sb.append(obfuscatedClassName); | |
| start = ma.end(1); | |
| actualReplacements.put(method, obfuscatedClassName); | |
| missingClasses.remove(method); | |
| } | |
| if (start != 0) { | |
| // Consume the remainder and update the selector | |
| sb.append(sel.subSequence(start, originalLength)); | |
| x.setSelector(sb.toString()); | |
| } | |
| } | |
| @Override | |
| public void endVisit(CssStylesheet x, Context ctx) { | |
| boolean stop = false; | |
| // Skip names corresponding to @def entries. They too can be declared as | |
| // String accessors. | |
| List<JMethod> toRemove = new ArrayList<JMethod>(); | |
| for (JMethod method : missingClasses) { | |
| if (cssDefs.contains(method.getName())) { | |
| toRemove.add(method); | |
| } | |
| } | |
| for (JMethod method : toRemove) { | |
| missingClasses.remove(method); | |
| } | |
| if (!missingClasses.isEmpty()) { | |
| stop = true; | |
| TreeLogger errorLogger = logger.branch(TreeLogger.INFO, | |
| "The following obfuscated style classes were missing from " | |
| + "the source CSS file:"); | |
| for (JMethod m : missingClasses) { | |
| String name = m.getName(); | |
| ClassName className = m.getAnnotation(ClassName.class); | |
| if (className != null) { | |
| name = className.value(); | |
| } | |
| errorLogger.log(TreeLogger.ERROR, name + ": Fix by adding ." + name | |
| + "{}"); | |
| } | |
| } | |
| if (strict && !unknownClasses.isEmpty()) { | |
| stop = true; | |
| TreeLogger errorLogger = logger.branch(TreeLogger.ERROR, | |
| "The following unobfuscated classes were present in a strict CssResource:"); | |
| for (String s : unknownClasses) { | |
| errorLogger.log(TreeLogger.ERROR, s); | |
| } | |
| if (errorLogger.isLoggable(TreeLogger.INFO)) { | |
| errorLogger.log(TreeLogger.INFO, "Fix by adding String accessor " | |
| + "method(s) to the CssResource interface for obfuscated classes, " | |
| + "or using an @external declaration for unobfuscated classes."); | |
| } | |
| } | |
| if (stop) { | |
| throw new CssCompilerException("Missing a CSS replacement"); | |
| } | |
| } | |
| /** | |
| * Reports the replacements that were actually performed by this visitor. | |
| */ | |
| public Map<JMethod, String> getReplacements() { | |
| return actualReplacements; | |
| } | |
| /** | |
| * Flatten class name lookups to speed selector rewriting. | |
| * | |
| * @param classReplacementsWithPrefix a map of local prefixes to the | |
| * obfuscated names of imported methods. If a CssResource makes use | |
| * of the {@link CssResource.Import} annotation, the keys of this map | |
| * will correspond to the {@link CssResource.ImportedWithPrefix} | |
| * value defined on the imported CssResource. The zero-length string | |
| * key holds the obfuscated names for the CssResource that is being | |
| * generated. | |
| * @return A flattened version of the classReplacementWithPrefix map, where | |
| * the keys are the source class name (with prefix included), and | |
| * values have the obfuscated class name and associated JMethod. | |
| */ | |
| private Map<String, Replacement> computeReplacements( | |
| Map<String, Map<JMethod, String>> classReplacementsWithPrefix, | |
| Set<String> externalClasses) { | |
| Map<String, Replacement> toReturn = new HashMap<String, Replacement>(); | |
| for (String externalClass : externalClasses) { | |
| toReturn.put(externalClass, UNREFERENCED_EXTERNAL); | |
| } | |
| for (Map.Entry<String, Map<JMethod, String>> outerEntry : classReplacementsWithPrefix.entrySet()) { | |
| String prefix = outerEntry.getKey(); | |
| for (Map.Entry<JMethod, String> entry : outerEntry.getValue().entrySet()) { | |
| JMethod method = entry.getKey(); | |
| String sourceClassName = method.getName(); | |
| String obfuscatedClassName = entry.getValue(); | |
| if (cssDefs.contains(sourceClassName)) { | |
| continue; | |
| } | |
| ClassName className = method.getAnnotation(ClassName.class); | |
| if (className != null) { | |
| sourceClassName = className.value(); | |
| } | |
| sourceClassName = prefix + sourceClassName; | |
| if (externalClasses.contains(sourceClassName)) { | |
| /* | |
| * It simplifies the sanity-checking logic to treat external classes | |
| * as though they were simply obfuscated to exactly the value the user | |
| * wants. | |
| */ | |
| obfuscatedClassName = sourceClassName; | |
| } | |
| toReturn.put(sourceClassName, new Replacement(method, | |
| obfuscatedClassName)); | |
| } | |
| } | |
| return Collections.unmodifiableMap(toReturn); | |
| } | |
| } |