Package com.google.javascript.jscomp

Class AbstractCommandLineRunner<A extends Compiler,​B extends CompilerOptions>

  • Direct Known Subclasses:
    CommandLineRunner
    public abstract class AbstractCommandLineRunner<A extends Compiler,​B extends CompilerOptions>
extends java.lang.Object
    Implementations of AbstractCommandLineRunner translate flags into Java API calls on the Compiler. AbstractCompiler contains common flags and logic to make that happen.

    This class may be extended and used to create other Java classes that behave the same as running the Compiler from the command line. Example: 

     class MyCommandLineRunner extends
     AbstractCommandLineRunner<MyCompiler, MyOptions> {
   MyCommandLineRunner(String[] args) {
     super(args);
   }

   @Override
   protected MyOptions createOptions() {
     MyOptions options = new MyOptions();
     CompilerFlagTranslator.setOptionsFromFlags(options);
     addMyCrazyCompilerPassThatOutputsAnExtraFile(options);
     return options;
   }

   @Override
   protected MyCompiler createCompiler() {
     return new MyCompiler();
   }

   public static void main(String[] args) {
     (new MyCommandLineRunner(args)).run();
   }
 }

    • Method Detail

      • setExitCodeReceiver

        @GwtIncompatible("Unnecessary")
public void setExitCodeReceiver​(com.google.common.base.Function<java.lang.Integer,​java.lang.Void> newExitCodeReceiver)
        Parameters:
        newExitCodeReceiver - receives a non-zero integer to indicate a problem during execution or 0i to indicate success.

      • isInTestMode

        @GwtIncompatible("Unnecessary")
protected boolean isInTestMode()
        Returns whether we're in test mode.

      • createCompiler

        @GwtIncompatible("Unnecessary")
protected abstract A createCompiler()
        Returns the instance of the Compiler to use when run() is called.

      • prepForBundleAndAppendTo

        @GwtIncompatible("Unnecessary")
protected abstract void prepForBundleAndAppendTo​(java.lang.Appendable out,
                                                 CompilerInput input,
                                                 java.lang.String content)
                                          throws java.io.IOException
        Performs any transformation needed on the given compiler input and appends it to the given output bundle.
        Throws:
        java.io.IOException

      • appendRuntimeTo

        @GwtIncompatible("Unnecessary")
protected abstract void appendRuntimeTo​(java.lang.Appendable out)
                                 throws java.io.IOException
        Writes whatever runtime libraries are needed to bundle.
        Throws:
        java.io.IOException

      • createOptions

        @GwtIncompatible("Unnecessary")
protected abstract B createOptions()
        Returns the instance of the Options to use when run() is called. createCompiler() is called before createOptions(), so getCompiler() will not return null when createOptions() is called.

      • getDiagnosticGroups

        @GwtIncompatible("Unnecessary")
protected DiagnosticGroups getDiagnosticGroups()
        The warning classes that are available from the command-line.

      • addAllowlistWarningsGuard

        @GwtIncompatible("Unnecessary")
protected abstract void addAllowlistWarningsGuard​(CompilerOptions options,
                                                  java.io.File allowlistFile)

      • setRunOptions

        @GwtIncompatible("Unnecessary")
protected void setRunOptions​(CompilerOptions options)
                      throws java.io.IOException
        Sets options based on the configurations set flags API. Called during the run() run() method. If you want to ignore the flags API, or interpret flags your own way, then you should override this method.
        Throws:
        java.io.IOException

      • getCompiler

        @GwtIncompatible("Unnecessary")
protected final A getCompiler()

      • getBuiltinExterns

        @GwtIncompatible("Unnecessary")
public static java.util.List<SourceFile> getBuiltinExterns​(CompilerOptions.Environment env)
                                                    throws java.io.IOException
        Returns:
        a mutable list
        Throws:
        java.io.IOException

      • getVersionText

        protected abstract java.lang.String getVersionText()
        Some text identifying this binary and its version.

        At minimum, this is what will be printed when `--version` is passed.

      • run

        @GwtIncompatible("Unnecessary")
public final void run()
        Runs the Compiler and calls System.exit() with the exit status of the compiler.

      • getErrorPrintStream

        @GwtIncompatible("Unnecessary")
protected final java.io.PrintStream getErrorPrintStream()
        Returns the PrintStream for writing errors associated with this AbstractCommandLineRunner.

      • parseJsonFilesFromInputStream

        @GwtIncompatible("Unnecessary")
public java.util.List<AbstractCommandLineRunner.JsonFileSpec> parseJsonFilesFromInputStream()
                                                                                     throws java.io.IOException
        Throws:
        java.io.IOException

      • createInputs

        @GwtIncompatible("Unnecessary")
protected java.util.List<SourceFile> createInputs​(java.util.List<AbstractCommandLineRunner.FlagEntry<AbstractCommandLineRunner.JsSourceType>> files,
                                                  java.util.List<AbstractCommandLineRunner.JsonFileSpec> jsonFiles,
                                                  boolean allowStdIn,
                                                  java.util.List<AbstractCommandLineRunner.JsChunkSpec> jsChunkSpecs)
                                           throws java.io.IOException
        Creates inputs from a list of source files, zips and json files.

        Can be overridden by subclasses who want to pull files from different places.

        Parameters:
        files - A list of flag entries indicates js and zip file names
        jsonFiles - A list of json encoded files.
        allowStdIn - Whether '-' is allowed appear as a filename to represent stdin. If true, '-' is only allowed to appear once.
        jsChunkSpecs - A list chunk specs.
        Returns:
        An array of inputs
        Throws:
        java.io.IOException

      • createJsModules

        public static java.util.List<JSChunk> createJsModules​(java.util.List<AbstractCommandLineRunner.JsChunkSpec> specs,
                                                      java.util.List<CompilerInput> inputs)
                                               throws java.io.IOException
        Creates module objects from a list of chunk specifications.
        Parameters:
        specs - A list of chunk specifications, not null or empty.
        inputs - A list of JS file paths, not null
        Returns:
        An array of module objects
        Throws:
        java.io.IOException

      • checkModuleName

        @GwtIncompatible("Unnecessary")
protected void checkModuleName​(java.lang.String name)
        Validates the module name. Can be overridden by subclasses.
        Parameters:
        name - The module name

      • parseModuleWrappers

        public static java.util.Map<java.lang.String,​java.lang.String> parseModuleWrappers​(java.util.List<java.lang.String> specs,
                                                                                         java.lang.Iterable<JSChunk> chunks)
        Parses module wrapper specifications.
        Parameters:
        specs - A list of module wrapper specifications, not null. The spec format is: name:wrapper. Wrappers.
        chunks - The JS chunks whose wrappers are specified
        Returns:
        A map from module name to module wrapper. Modules with no wrapper will have the empty string as their value in this map.

      • doRun

        @GwtIncompatible("Unnecessary")
protected int doRun()
             throws java.io.IOException
        Parses command-line arguments and runs the compiler.
        Returns:
        system exit status
        Throws:
        java.io.IOException

      • getCompileMetricsRecorder

        protected CompileMetricsRecorderInterface getCompileMetricsRecorder()
        Child classes should override this if they want to actually record metrics about the compilation.

      • createExterns

        @GwtIncompatible("Unnecessary")
protected java.util.List<SourceFile> createExterns​(CompilerOptions options)
                                            throws java.io.IOException
        Throws:
        java.io.IOException

      • shouldGenerateMapPerModule

        @GwtIncompatible("Unnecessary")
protected boolean shouldGenerateMapPerModule​(B options)
        Returns true if and only if a source map file should be generated for each module, as opposed to one unified map. This is specified by having the source map pattern include the %outname% variable.

      • filenameToOutputStream

        @GwtIncompatible("Unnecessary")
protected java.io.OutputStream filenameToOutputStream​(java.lang.String fileName)
                                               throws java.io.IOException
        Converts a file name into a Outputstream. Returns null if the file name is null.
        Throws:
        java.io.IOException

      • createDefineReplacements

        public static void createDefineReplacements​(java.util.List<java.lang.String> definitions,
                                            CompilerOptions options)
        Create a map of constant names to constant values from a textual description of the map.
        Parameters:
        definitions - A list of overriding definitions for defines in the form <name>[=<val>], where <val> is a number, boolean, or single-quoted string without single quotes.