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