cn.dreampie.ClosureMinifier Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of minify-maven-plugin Show documentation
Minify Script Maven Plugin
The newest version!
package cn.dreampie;

import com.google.common.base.Charsets;
import com.google.common.collect.Lists;
import com.google.common.io.Files;
import com.google.javascript.jscomp.*;
import com.google.javascript.jscomp.Compiler;
import org.apache.maven.plugin.logging.Log;

import java.io.File;
import java.io.IOException;
import java.util.List;

/**
 * Copyright 2011 Mark Derricutt.
 * 
 * Contributing authors:
 * Daniel Bower
 * 

 * 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.
 * 

 * 

 * Run the Closure Compiler tool on a directory of Javascripts.
 * 

 * This class supports no configuration in its current form.
 */
public class ClosureMinifier {

  private Log log = LogKit.getLog();
  private CompilationLevel compilationLevel = CompilationLevel.SIMPLE_OPTIMIZATIONS;
  private File sourceDirectory;
  private File outputDirectory;


  public void compile(List filesToCompile, File destFile) {
    Compiler compiler = new Compiler();
    Result result = compiler.compile(getExterns(), getInputs(filesToCompile), getCompilerOptions());
    compile(result, destFile, compiler);
  }

  public void compile(List filesToCompile) {
    File destFile = null;
    Result result = null;
    Compiler compiler = null;
    for (File file : filesToCompile) {
      compiler = new Compiler();
      destFile = prepareDestFile(file);
      log.info("Compile " + destFile.getAbsolutePath());
      result = compiler.compile(getExterns(), Lists.newArrayList(getInput(file)), getCompilerOptions());
      compile(result, destFile, compiler);
    }
  }

  private void compile(Result result, File destFile, Compiler compiler) {

    log.debug(result.debugLog);
    for (JSError error : result.errors) {
      log.error("Closure Minifier Error:  " + error.sourceName + "  Description:  " + error.description);
    }
    for (JSError warning : result.warnings) {
      log.info("Closure Minifier Warning:  " + warning.sourceName + "  Description:  " + warning.description);
    }

    if (result.success) {
      try {
        Files.write(compiler.toSource(), destFile, Charsets.UTF_8);
      } catch (IOException e) {
        throw new ClosureException("Failed to write minified file to " + destFile, e);
      }
    } else {
      throw new ClosureException("Closure Compiler Failed - See error messages on System.err");
    }
  }

  /**
   * Prepare the Destination File, Remove if it already exists
   */
  private File prepareDestFile(File file) {
    String path = file.getAbsolutePath().replace(sourceDirectory.getAbsolutePath(), "");
    File f = new File(outputDirectory, path.replace(".js", ".min.js"));
    File dir = f.getParentFile();
    if (!dir.exists())
      dir.mkdirs();
    return f;
  }

  /**
   * Prepare options for the Compiler.
   */
  private CompilerOptions getCompilerOptions() {
    CompilationLevel level = null;
    try {
      level = this.compilationLevel;
    } catch (IllegalArgumentException e) {
      throw new ClosureException("Compilation level is invalid", e);
    }

    CompilerOptions options = new CompilerOptions();
    level.setOptionsForCompilationLevel(options);

    return options;
  }

  /**
   * Externs are defined in the Closure documentations as:
   * External variables are declared in 'externs' files. For instance, the file may include
   * definitions for global javascript/browser objects such as window, document.
   * 
   * This method sneaks into the CommandLineRunner class of the Closure command line tool
   * and pulls the default Externs there.  This class could be modified to instead look
   * somewhere more relevant to the project.
   */
  private List getExterns() {
    try {
      return CommandLineRunner.getDefaultExterns();
    } catch (IOException e) {
      throw new ClosureException("Unable to load default External variables Files. The files include definitions for global javascript/browser objects such as window, document.", e);
    }
  }

  private List getInputs(List filesToProcess) {
    List files = Lists.newArrayList();

    for (File file : filesToProcess) {
      files.add(getInput(file));
    }

    return files;
  }

  private SourceFile getInput(File fileToProcess) {
    return SourceFile.fromFile(fileToProcess);
  }

  public CompilationLevel getCompilationLevel() {
    return compilationLevel;
  }

  public void setCompilationLevel(CompilationLevel compilationLevel) {
    this.compilationLevel = compilationLevel;
  }

  public void setSourceDirectory(File sourceDirectory) {
    this.sourceDirectory = sourceDirectory;
  }

  public void setOutputDirectory(File outputDirectory) {
    this.outputDirectory = outputDirectory;
  }

}