internal static Result fromCMD(CMDCompiler compiler, CompilerOptions options)
{
Result result = new Result(options);
result.Output = compiler.OutputScript;
result.Errors.AddRange(compiler.getErrors());
result.Warnings.AddRange(compiler.getWarnings());
return result;
}
/// <summary>
/// Builds up a string that is sent through the CommandLine google closure compiler.
/// </summary>
/// <param name="options">Compiler options that need to be processed</param>
/// <returns>String containing all the options as needed by the compiler</returns>
public string Configure(CompilerOptions options)
{
string input = getInputFiles(options);
if (input == String.Empty)
return String.Empty;
string extraArgs = getExtraArg(options);
string output = getOutputFile(options);
string debug = getDebug(options);
string compilation_level = getCompilationLevel(options);
string warning_level = getWarningLevel(options);
string outputformat = getOutputFormat(options);
string idemode = getIdeMode(options);
return debug + compilation_level + extraArgs + warning_level + outputformat + idemode + input + output;
}
/// <summary>
/// Figures out the compilation level from the compiler options.
/// </summary>
/// <param name="options"></param>
/// <returns>Returns --compilation_level string value for the closure compiler consumption</returns>
private string getCompilationLevel(CompilerOptions options)
{
switch (options.CompilerLevel)
{
case CompilerOptions.ECompilerLevel.WhiteSpaceOnly:
{
return " --compilation_level=WHITESPACE_ONLY";
}
case CompilerOptions.ECompilerLevel.SimpleOptimization:
{
return " --compilation_level=SIMPLE_OPTIMIZATIONS";
}
case CompilerOptions.ECompilerLevel.AdvancedOptimization:
{
return " --compilation_level=ADVANCED_OPTIMIZATIONS";
}
default:
{
break;
}
}
return String.Empty;
}
public Result Compile(CompilerOptions options)
{
OutputScript = String.Empty;
Errors.Clear();
Warnings.Clear();
Failures.Clear();
string command = CMDCompilerOptions.Instance.Configure(options);
if (command != String.Empty)
{
var file = createConfigFile(command);
CompilerState = ECompileState.Running;
Java.Run("-jar \"" + CMDCompiler.Closure + "\"" + " --flagfile=\"" + file + "\"", compile_OutputDataReceived, compile_ErrorDataReceived);
File.Delete(file);
CompilerState = ECompileState.Finished;
}
return Result.fromCMD(this, options);;
}
/// <summary>
/// Process the argument string and returns a jsCompiler ready string
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
private string getExtraArg(CompilerOptions options)
{
string result = options.ExtraArgs.Trim();
return result.Length != 0 ? " " + result : String.Empty;
}
/// <summary>
/// Sets the debug flag in the closure compiler
/// </summary>
/// <param name="options"></param>
/// <returns>If enabled, the string --debug closure options. Otherwise nothing.</returns>
private string getDebug(CompilerOptions options)
{
if (options.Debug == true)
return " --debug";
return String.Empty;
}
private string getWarningLevel(CompilerOptions options)
{
switch (options.WarningLevel)
{
case CompilerOptions.EWarningLevel.Quiet:
{
return " --warning_level=QUIET";
}
case CompilerOptions.EWarningLevel.Verbose:
{
return " --warning_level=VERBOSE";
}
default:
{
break;
}
}
return String.Empty;
}
private string getOutputFormat(CompilerOptions options)
{
switch (options.OutputFormatting)
{
case CompilerOptions.EOutputFormatting.PrettyPrint:
{
return " --formatting=PRETTY_PRINT";
}
case CompilerOptions.EOutputFormatting.PrintInputDelimeter:
{
return " --formatting=PRINT_INPUT_DELIMITER";
}
default:
{
break;
}
}
return String.Empty;
}
/// <summary>
/// Extracts the output file, if one is provided, and applies the proper closure
/// compiler flag. If no outfile file is provided, then we don't provide anything
/// to the closure compiler, which result in sending the resulting JS to the stdout.
/// </summary>
/// <param name="options"></param>
/// <returns>js file name with the --js_output_file closure options</returns>
private string getOutputFile(CompilerOptions options)
{
if (options.OutputFile != String.Empty)
return " --js_output_file=\"" + options.OutputFile + "\"";
return String.Empty;
}
/// <summary>
/// Takes in an array of files and appends the --js required by the
/// closure compiler.
/// </summary>
/// <param name="files">List of files that need processing</param>
/// <returns>List of files with the --js closure setting</returns>
private string getInputFiles(CompilerOptions options)
{
if (options.InputFiles.Count == 0)
return String.Empty;
StringBuilder result = new StringBuilder(5084);
for (int iFile = 0, length = options.InputFiles.Count; iFile < length; iFile++)
result.Append(" --js=\"" + options.InputFiles[iFile] + "\"");
return result.ToString();
}
private string getIdeMode(CompilerOptions options)
{
return " --ideMode=" + options.IdeMode.ToString().ToLower();
}
internal static Result fromJNI(com.google.javascript.jscomp.Compiler compiler, com.google.javascript.jscomp.Result gcResult, CompilerOptions options)
{
Result result = new Result(options);
result.Output = compiler.toSource();
com.google.javascript.jscomp.JSError[] errors = compiler.getErrors();
for (int index = 0, length = errors.Length; index < length; index++)
{
com.google.javascript.jscomp.JSError error = errors[index];
result.Errors.Add(new Error(error.sourceName, error.description, error.getLineNumber(), error.getCharno(), Error.ESeverity.High));
}
com.google.javascript.jscomp.JSError[] warnings = compiler.getWarnings();
for (int index = 0, length = warnings.Length; index < length; index++)
{
com.google.javascript.jscomp.JSError warning = warnings[index];
result.Warnings.Add(new Error(warning.sourceName, warning.description, warning.getLineNumber(), warning.getCharno(), Error.ESeverity.Medium));
}
return result;
}
private Result(CompilerOptions options)
{
_Errors = new List<Error>();
_Warnings = new List<Error>();
_Options = options;
}
/// <summary>
/// Invokes the google closure compiler with the provided options. At the very least,
/// a list of JavaScript files need to be provided.
/// </summary>
/// <param name="options">CompilerOptions for the google closure compiler.</param>
/// <returns>Result object, which has the compiled JavaScript, Warnings and Errors</returns>
///
public jsCompiler.Core.Result Compile(CompilerOptions options)
{
return gcCompiler.Compile(options);
}
public Result Compile(CompilerOptions options)
{
com.google.javascript.jscomp.CompilerOptions gcOptions = jsCompiler.Core.JNICompilerOptions.Instance.Configure(options);
com.google.javascript.jscomp.JSSourceFile[] gcInputFile = jsCompiler.gcBridge.SourceFiles.Configure(options);
com.google.javascript.jscomp.JSSourceFile[] gcExternFile = jsCompiler.gcBridge.ExternFiles.Configure(options);
// Compile the source...
com.google.javascript.jscomp.Result gcResult = gcCompiler.compile(gcExternFile, gcInputFile, gcOptions);
Result result = Result.fromJNI(gcCompiler, gcResult, options);
// We set this to null so that we get a new instance when we compile source again.
gcCompiler = null;
return result;
}
