Java tutorial
/* * 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.core.ext.UnableToCompleteException; import com.google.gwt.dev.util.DefaultTextOutput; import com.google.gwt.dev.util.log.PrintWriterTreeLogger; import com.google.gwt.resources.css.GenerateCssAst; import com.google.gwt.resources.css.ast.CssStylesheet; 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.Splitter; import com.google.gwt.thirdparty.guava.common.collect.FluentIterable; import com.google.gwt.thirdparty.guava.common.collect.ImmutableSet; import com.google.gwt.thirdparty.guava.common.io.Files; import org.apache.commons.io.Charsets; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.io.PrintWriter; import java.net.MalformedURLException; import java.net.URL; import java.util.Collection; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.Map; import java.util.Set; /** * Converter from Css to Gss. */ public class Css2Gss { private final URL cssFile; private final TreeLogger treeLogger; private final boolean lenient; private PrintWriter printWriter; private Map<String, String> defNameMapping; private Predicate<String> simpleBooleanConditionPredicate; private final Set<URL> scopeFiles; public Css2Gss(String filePath) throws MalformedURLException { this(new File(filePath).toURI().toURL(), false); } public Css2Gss(URL resource, boolean lenient) { this(resource, lenient, Predicates.<String>alwaysFalse(), new HashSet<URL>()); } public Css2Gss(URL resource, boolean lenient, Predicate<String> simpleBooleanConditionPredicate, Set<URL> scopeFiles) { cssFile = resource; printWriter = new PrintWriter(System.err); PrintWriterTreeLogger printWriterTreeLogger = new PrintWriterTreeLogger(printWriter); printWriterTreeLogger.setMaxDetail(Type.WARN); this.treeLogger = printWriterTreeLogger; this.lenient = lenient; this.simpleBooleanConditionPredicate = simpleBooleanConditionPredicate; this.scopeFiles = scopeFiles; } public Css2Gss(URL fileUrl, TreeLogger treeLogger, boolean lenient, Predicate<String> simpleBooleanConditionPredicate, Set<URL> scopeFiles) { cssFile = fileUrl; this.treeLogger = treeLogger; this.lenient = lenient; this.simpleBooleanConditionPredicate = simpleBooleanConditionPredicate; this.scopeFiles = scopeFiles; } public Css2Gss(URL url, TreeLogger logger, boolean lenientConversion, Predicate<String> simpleBooleanConditionPredicate) { this(url, logger, lenientConversion, simpleBooleanConditionPredicate, new HashSet<URL>()); } public String toGss() throws UnableToCompleteException { try { CssStylesheet sheet = GenerateCssAst.exec(treeLogger, cssFile); DefCollectorVisitor defCollectorVisitor = new DefCollectorVisitor(lenient, treeLogger); defCollectorVisitor.accept(sheet); defNameMapping = defCollectorVisitor.getDefMapping(); addScopeDefs(scopeFiles, defNameMapping); new UndefinedConstantVisitor(new HashSet<String>(defNameMapping.values()), lenient, treeLogger) .accept(sheet); new ElseNodeCreator().accept(sheet); new AlternateAnnotationCreatorVisitor().accept(sheet); GssGenerationVisitor gssGenerationVisitor = new GssGenerationVisitor(new DefaultTextOutput(false), defNameMapping, lenient, treeLogger, simpleBooleanConditionPredicate); gssGenerationVisitor.accept(sheet); return gssGenerationVisitor.getContent(); } finally { if (printWriter != null) { printWriter.flush(); } } } private void addScopeDefs(Set<URL> scopeFiles, Map<String, String> defNameMapping) throws UnableToCompleteException { for (URL fileName : scopeFiles) { CssStylesheet sheet = GenerateCssAst.exec(treeLogger, fileName); DefCollectorVisitor defCollectorVisitor = new DefCollectorVisitor(lenient, treeLogger); defCollectorVisitor.accept(sheet); defNameMapping.putAll(defCollectorVisitor.getDefMapping()); } } /** * GSS allows only uppercase letters and numbers for a name of the constant. The constants * need to be renamed in order to be compatible with GSS. This method returns a mapping * between the old name and the new name compatible with GSS. */ public Map<String, String> getDefNameMapping() { return defNameMapping; } public static void main(String... args) { Options options = Options.parseOrQuit(args); if (options.singleFile) { try { System.out.println( convertFile(options.resource, options.simpleBooleanConditions, options.scopeFiles)); System.exit(0); } catch (Exception e) { e.printStackTrace(); System.exit(-1); } } Collection<File> filesToConvert = FileUtils.listFiles(options.resource, new String[] { "css" }, options.recurse); for (File cssFile : filesToConvert) { try { if (doesCorrespondingGssFileExists(cssFile)) { System.out.println( "GSS file already exists - will not convert, file: " + cssFile.getAbsolutePath()); continue; } String gss = convertFile(cssFile, options.simpleBooleanConditions, options.scopeFiles); writeGss(gss, cssFile); System.out.println("Converted " + cssFile.getAbsolutePath()); } catch (Exception e) { System.err.println("Failed to convert " + cssFile.getAbsolutePath()); e.printStackTrace(); } } } private static boolean doesCorrespondingGssFileExists(File cssFile) { File gssFile = getCorrespondingGssFile(cssFile); return gssFile.exists(); } private static File getCorrespondingGssFile(File cssFile) { String name = cssFile.getName(); assert name.endsWith(".css"); name = name.substring(0, name.length() - ".css".length()) + ".gss"; return new File(cssFile.getParentFile(), name); } private static void writeGss(String gss, File cssFile) throws IOException { File gssFile = getCorrespondingGssFile(cssFile); Files.asCharSink(gssFile, Charsets.UTF_8).write(gss); } private static String convertFile(File resource, Set<String> simpleBooleanConditions, Set<URL> scopeFiles) throws MalformedURLException, UnableToCompleteException { Predicate<String> simpleConditionPredicate; if (simpleBooleanConditions != null) { simpleConditionPredicate = Predicates.in(simpleBooleanConditions); } else { simpleConditionPredicate = Predicates.alwaysFalse(); } return new Css2Gss(resource.toURI().toURL(), false, simpleConditionPredicate, scopeFiles).toGss(); } private static void printUsage() { System.err.println("Usage :"); System.err.println("java " + Css2Gss.class.getName() + " [Options] [file or directory]"); System.err.println("Options:"); System.err.println( " -r -> Recursively convert all css files on the given directory" + "(leaves .css files in place)"); System.err.println(" -condition list_of_condition -> Specify a comma-separated list of " + "variables that are used in conditionals and that will be mapped to configuration " + "properties. The converter will not use the is() function when it will convert these " + "conditions"); System.err.println(" -scope list_of_files -> Specify a comma-separated list of " + "css files to be used in this conversion to determine all defined variables"); } static class Options { static final Map<String, ArgumentConsumer> argumentConsumers; static { argumentConsumers = new LinkedHashMap<String, ArgumentConsumer>(); argumentConsumers.put("-r", new ArgumentConsumer() { @Override public boolean consume(Options option, String nextArg) { option.recurse = true; return false; } }); argumentConsumers.put("-condition", new ArgumentConsumer() { @Override public boolean consume(Options option, String nextArg) { if (nextArg == null) { quitEarly("-condition option must be followed by a comma separated list of conditions"); } option.simpleBooleanConditions = FluentIterable.from(Splitter.on(',').split(nextArg)).toSet(); return true; } }); argumentConsumers.put("-basedir", new ArgumentConsumer() { @Override public boolean consume(Options option, String nextArg) { nextArg += nextArg.endsWith(File.separator) ? "" : File.separator; option.baseDir = new File(nextArg); if (!option.baseDir.exists() || !option.baseDir.isDirectory()) { quitEarly("Basedir is does not exist"); } return true; } }); argumentConsumers.put("-scope", new ArgumentConsumer() { @Override public boolean consume(Options option, String nextArg) { option.scope = nextArg; return true; } }); } boolean recurse; boolean singleFile; ImmutableSet<URL> scopeFiles = ImmutableSet.of(); File resource; Set<String> simpleBooleanConditions; File baseDir; private String scope; private static Options parseOrQuit(String[] args) { if (!validateArgs(args)) { quitEarly(null); } Options options = new Options(); int index = 0; // consume options while (index < args.length - 1) { String arg = args[index++]; String nextArg = index < args.length - 1 ? args[index] : null; ArgumentConsumer consumer = argumentConsumers.get(arg); if (consumer == null) { quitEarly("Unknown argument: " + arg); } boolean skipNextArg = consumer.consume(options, nextArg); if (skipNextArg) { index++; } } if (index == args.length) { quitEarly("Missing file or directly as last parameter"); } if (options.scope != null) { ImmutableSet<String> scopeFileSet = FluentIterable.from(Splitter.on(',').split(options.scope)) .toSet(); HashSet<URL> set = new HashSet<URL>(); for (String scopeFile : scopeFileSet) { File file = null; if (options.baseDir != null && !scopeFile.startsWith(File.separator)) { file = new File(options.baseDir, scopeFile).getAbsoluteFile(); } else { file = new File(scopeFile).getAbsoluteFile(); } if (!file.exists() && !file.isFile()) { quitEarly("The scope file '" + file.getAbsolutePath() + "' does not exist"); } try { set.add(file.toURI().toURL()); } catch (MalformedURLException e) { quitEarly("Can not create url for scope file: '" + scopeFile + "'"); } } options.scopeFiles = ImmutableSet.copyOf(set); } // last argument is always the file or directory path if (options.baseDir != null && !args[index].startsWith(File.separator)) { options.resource = new File(options.baseDir, args[index]).getAbsoluteFile(); } else { options.resource = new File(args[index]).getAbsoluteFile(); } options.singleFile = !options.resource.isDirectory(); // validate options if (!options.resource.exists()) { quitEarly("File or Directory does not exists: " + options.resource.getAbsolutePath()); } if (options.recurse && !options.resource.isDirectory()) { quitEarly("When using -r the last parameter needs to be a directory"); } return options; } private static void quitEarly(String errorMsg) { if (errorMsg != null) { System.err.println("Error: " + errorMsg); } printUsage(); System.exit(-1); } private static boolean validateArgs(String[] args) { return args.length > 0 && args.length < 9; } } private interface ArgumentConsumer { /** *Returns true if the next argument has been consumed. */ boolean consume(Options option, String nextArg); } }