| /* | |
| * 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.Generator; | |
| import com.google.gwt.core.ext.TreeLogger; | |
| import com.google.gwt.core.ext.UnableToCompleteException; | |
| import com.google.gwt.dev.util.log.PrintWriterTreeLogger; | |
| import com.google.gwt.resources.client.CssResource; | |
| import com.google.gwt.resources.client.CssResource.ClassName; | |
| import com.google.gwt.resources.gss.ClassNamesCollector; | |
| import com.google.gwt.resources.rg.GssResourceGenerator; | |
| import com.google.gwt.resources.rg.GssResourceGenerator.LoggerErrorManager; | |
| import com.google.gwt.thirdparty.common.css.compiler.ast.CssTree; | |
| 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.CollectConstantDefinitions; | |
| 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.UnrollLoops; | |
| import com.google.gwt.thirdparty.guava.common.base.CaseFormat; | |
| import com.google.gwt.thirdparty.guava.common.base.Function; | |
| import com.google.gwt.thirdparty.guava.common.collect.Iterables; | |
| import com.google.gwt.thirdparty.guava.common.collect.Lists; | |
| import com.google.gwt.user.rebind.SourceWriter; | |
| import com.google.gwt.user.rebind.StringSourceWriter; | |
| import com.google.gwt.util.tools.ArgHandlerFile; | |
| import com.google.gwt.util.tools.ArgHandlerFlag; | |
| import com.google.gwt.util.tools.ArgHandlerString; | |
| import com.google.gwt.util.tools.ToolBase; | |
| import java.io.File; | |
| import java.io.PrintWriter; | |
| import java.net.MalformedURLException; | |
| import java.net.URL; | |
| import java.util.Collection; | |
| import java.util.Comparator; | |
| import java.util.HashSet; | |
| import java.util.Set; | |
| import java.util.TreeSet; | |
| /** | |
| * A utility class for creating a Java interface declaration for a given CSS | |
| * file. | |
| */ | |
| public class InterfaceGenerator extends ToolBase { | |
| private static final Comparator<String> NAME_COMPARATOR = new Comparator<String>() { | |
| public int compare(String o1, String o2) { | |
| return o1.compareToIgnoreCase(o2); | |
| } | |
| }; | |
| private static final TreeLogger.Type LOG_LEVEL = TreeLogger.WARN; | |
| public static void main(String[] args) { | |
| (new InterfaceGenerator()).execImpl(args); | |
| } | |
| private String interfaceName; | |
| private File inputFile; | |
| private TreeLogger logger; | |
| private boolean standaloneFile; | |
| private class ArgHandlerAddPackageHeader extends ArgHandlerFlag { | |
| public ArgHandlerAddPackageHeader() { | |
| addTagValue("-standalone", true); | |
| } | |
| @Override | |
| public String getPurposeSnippet() { | |
| return "Add package and import statements to generated interface so that " | |
| + "they are still functional when they stand alone."; | |
| } | |
| @Override | |
| public String getLabel() { | |
| return "addPackageHeader"; | |
| } | |
| @Override | |
| public boolean setFlag(boolean value) { | |
| standaloneFile = value; | |
| logger.log(TreeLogger.DEBUG, value ? "Not creating" : "Creating" + " a standalone file"); | |
| return true; | |
| } | |
| @Override | |
| public boolean getDefaultValue() { | |
| return standaloneFile; | |
| } | |
| } | |
| private InterfaceGenerator() { | |
| registerHandler(new ArgHandlerAddPackageHeader()); | |
| registerHandler(new ArgHandlerString() { | |
| @Override | |
| public String getPurpose() { | |
| return "The name of the generated CssResource subtype"; | |
| } | |
| @Override | |
| public String getTag() { | |
| return "-typeName"; | |
| } | |
| @Override | |
| public String[] getTagArgs() { | |
| return new String[] {"some.package.MyCssResource"}; | |
| } | |
| @Override | |
| public boolean isRequired() { | |
| return true; | |
| } | |
| @Override | |
| public boolean setString(String str) { | |
| if (str.length() == 0) { | |
| return false; | |
| } | |
| if (!Character.isJavaIdentifierStart(str.charAt(0))) { | |
| return false; | |
| } | |
| for (int i = 1, j = str.length(); i < j; i++) { | |
| char c = str.charAt(i); | |
| if (!(Character.isJavaIdentifierPart(c) || c == '.')) { | |
| return false; | |
| } | |
| } | |
| interfaceName = str; | |
| if (logger.isLoggable(TreeLogger.DEBUG)) { | |
| logger.log(TreeLogger.DEBUG, "interfaceName = " + interfaceName); | |
| } | |
| return true; | |
| } | |
| }); | |
| // -css in.css | |
| registerHandler(new ArgHandlerFile() { | |
| @Override | |
| public String getPurpose() { | |
| return "The input CSS file to process"; | |
| } | |
| @Override | |
| public String getTag() { | |
| return "-css"; | |
| } | |
| @Override | |
| public boolean isRequired() { | |
| return true; | |
| } | |
| @Override | |
| public void setFile(File file) { | |
| inputFile = file; | |
| if (logger.isLoggable(TreeLogger.DEBUG)) { | |
| logger.log(TreeLogger.DEBUG, "inputFile = " + file.getAbsolutePath()); | |
| } | |
| } | |
| }); | |
| } | |
| @Override | |
| protected String getDescription() { | |
| return "Create a CssResource interface based on a CSS file"; | |
| } | |
| private void execImpl(String[] args) { | |
| // Set up logging | |
| PrintWriter logWriter = new PrintWriter(System.err); | |
| logger = new PrintWriterTreeLogger(logWriter); | |
| ((PrintWriterTreeLogger) logger).setMaxDetail(LOG_LEVEL); | |
| // Process args or die | |
| if (!processArgs(args)) { | |
| System.exit(-1); | |
| } | |
| boolean error = false; | |
| try { | |
| System.out.println(process()); | |
| } catch (MalformedURLException e) { | |
| logger.log(TreeLogger.ERROR, "Unable to load CSS", e); | |
| error = true; | |
| } catch (UnableToCompleteException e) { | |
| logger.log(TreeLogger.ERROR, "Unable to process CSS", e); | |
| error = true; | |
| } finally { | |
| // Make sure the logs are emitted | |
| logWriter.flush(); | |
| } | |
| System.exit(error ? -1 : 0); | |
| } | |
| /** | |
| * Munge a CSS class name into a Java identifier. | |
| */ | |
| private String methodName(String className) { | |
| StringBuilder sb = new StringBuilder(); | |
| char c = className.charAt(0); | |
| boolean nextUpCase = false; | |
| if (Character.isJavaIdentifierStart(c)) { | |
| sb.append(Character.toLowerCase(c)); | |
| } | |
| for (int i = 1, j = className.length(); i < j; i++) { | |
| c = className.charAt(i); | |
| if (!Character.isJavaIdentifierPart(c)) { | |
| nextUpCase = true; | |
| continue; | |
| } | |
| if (nextUpCase) { | |
| nextUpCase = false; | |
| c = Character.toUpperCase(c); | |
| } | |
| sb.append(c); | |
| } | |
| return sb.toString(); | |
| } | |
| private String process() throws MalformedURLException, | |
| UnableToCompleteException { | |
| // Create AST | |
| CssTree cssTree = createAst(inputFile.toURI().toURL(), logger); | |
| // Sort all names | |
| Set<String> names = new TreeSet<String>(NAME_COMPARATOR); | |
| names.addAll(new ClassNamesCollector().getClassNames(cssTree)); | |
| CollectConstantDefinitions collectConstantDefinitionsPass = new CollectConstantDefinitions( | |
| cssTree); | |
| collectConstantDefinitionsPass.runPass(); | |
| Collection<String> renamedDefs = renameDefs(collectConstantDefinitionsPass | |
| .getConstantDefinitions().getConstantsNames()); | |
| names.addAll(renamedDefs); | |
| // Deduplicate method names | |
| Set<String> methodNames = new HashSet<String>(); | |
| // Build the interface | |
| SourceWriter sw = new StringSourceWriter(); | |
| int lastDot = interfaceName.lastIndexOf('.'); | |
| if (standaloneFile) { | |
| sw.println("// DO NOT EDIT"); | |
| sw.println("// Automatically generated by " | |
| + InterfaceGenerator.class.getName()); | |
| sw.println("package " + interfaceName.substring(0, lastDot) + ";"); | |
| sw.println("import " + CssResource.class.getCanonicalName() + ";"); | |
| sw.println("import " + ClassName.class.getCanonicalName() + ";"); | |
| } | |
| sw.println("interface " + interfaceName.substring(lastDot + 1) | |
| + " extends CssResource {"); | |
| sw.indent(); | |
| for (String className : names) { | |
| String methodName = methodName(className); | |
| while (!methodNames.add(methodName)) { | |
| // Unusual, handles foo-bar and foo--bar | |
| methodName += "_"; | |
| } | |
| sw.println(); | |
| if (!methodName.equals(className)) { | |
| sw.println("@ClassName(\"" + Generator.escape(className) + "\")"); | |
| } | |
| sw.println("String " + methodName + "();"); | |
| } | |
| sw.outdent(); | |
| sw.println("}"); | |
| return sw.toString(); | |
| } | |
| /** | |
| * In GSS, constant names are defined in upper case but a method name to access a constant in | |
| * a CssResource interface can be written in lower camel case. | |
| * <p> | |
| * This method converts all constant names in a lower camel case identifier. | |
| */ | |
| private Collection<String> renameDefs(Iterable<String> constantsNames) { | |
| return Lists.newArrayList(Iterables.transform(constantsNames, new Function<String, String>() { | |
| @Override | |
| public String apply(String constantName) { | |
| String lowerCase = CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, constantName); | |
| // If we cannot revert the method name to the original constant name, use the | |
| // original constant name. | |
| // This case happens when number are used after an underscore: | |
| // CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "DEF_1") returns def1 | |
| // but CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, "def1") returns DEF1 and the | |
| // GssResourceGenerator is not able to match the name of the method with the name of the | |
| // constant . | |
| if (!constantName.equals(CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, | |
| lowerCase))) { | |
| return constantName; | |
| } | |
| return lowerCase; | |
| } | |
| })); | |
| } | |
| private CssTree createAst(URL sourceFileUrl, TreeLogger logger) | |
| throws UnableToCompleteException { | |
| LoggerErrorManager errorManager = new LoggerErrorManager(logger); | |
| CssTree cssTree; | |
| try { | |
| cssTree = new GssParser(GssResourceGenerator.readUrlContent(sourceFileUrl, logger)).parse(); | |
| } catch (GssParserException e) { | |
| logger.log(TreeLogger.ERROR, "Unable to parse CSS", e); | |
| throw new UnableToCompleteException(); | |
| } | |
| new CreateDefinitionNodes(cssTree.getMutatingVisitController(), errorManager).runPass(); | |
| // Can create new style classes | |
| new CreateForLoopNodes(cssTree.getMutatingVisitController(), errorManager).runPass(); | |
| new UnrollLoops(cssTree.getMutatingVisitController(), errorManager).runPass(); | |
| return cssTree; | |
| } | |
| } |