Refactor compile_js.gypi to support script_args and closure_args

third_party/closure_compiler/compile.py

 #!/usr/bin/python
 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Runs Closure compiler on JavaScript files to check for errors and produce
 minified output."""
 
 import argparse
 import os
@@ skipping 40 matching lines @@
   _POLYMER_EXTRA_ANNOTATIONS = [
     "attribute",
     "status",
     "element",
     "homepage",
     "submodule",
     "group",
   ]
 
   _COMMON_CLOSURE_ARGS = [
-    "--accept_const_keyword",
-    "--language_in=ECMASCRIPT5_STRICT",
-    "--summary_detail_level=3",
-    "--compilation_level=SIMPLE_OPTIMIZATIONS",
-    "--source_map_format=V3",
-    "--polymer_pass",
-  ] + [
     "--jscomp_error=%s" % err for err in _COMMON_JSCOMP_ERRORS
   ] + [
     "--extra_annotation_name=%s" % a for a in _POLYMER_EXTRA_ANNOTATIONS
   ]
 
   # These are the extra flags used when compiling in strict mode.
   # Flags that are normally disabled are turned on for strict mode.
   _STRICT_CLOSURE_ARGS = [
     "--jscomp_error=reportUnknownTypes",
     "--jscomp_error=duplicate",
@@ skipping 168 matching lines @@
 
     Return:
       The filepath of the newly created, written, and closed temporary file.
     """
     with tempfile.NamedTemporaryFile(mode="wt", delete=False) as tmp_file:
       self._temp_files.append(tmp_file.name)
       tmp_file.write(contents)
     return tmp_file.name
 
   def _run_js_check(self, sources, out_file=None, externs=None,
-                    output_wrapper=None):
+                    closure_args=None):
     """Check |sources| for type errors.
 
     Args:
       sources: Files to check.
       out_file: A file where the compiled output is written to.
       externs: @extern files that inform the compiler about custom globals.
-      output_wrapper: Wraps output into this string at the place denoted by the
-          marker token %output%.
+      closure_args: Arguments passed directly to the closure compiler.
 
     Returns:
       (errors, stderr) A parsed list of errors (strings) found by the compiler
           and the raw stderr (as a string).
     """
     args = ["--js=%s" % s for s in sources]
 
     if out_file:
       out_dir = os.path.dirname(out_file)
       if not os.path.exists(out_dir):
         os.makedirs(out_dir)
       args += ["--js_output_file=%s" % out_file]
       args += ["--create_source_map=%s" % (self._MAP_FILE_FORMAT % out_file)]
 
     if externs:
       args += ["--externs=%s" % e for e in externs]
 
-    if output_wrapper:
-      args += ['--output_wrapper="%s"' % output_wrapper]
+    args += closure_args
 
     args_file_content = " %s" % " ".join(self._common_args() + args)
     self._log_debug("Args: %s" % args_file_content.strip())
 
     args_file = self._create_temp_file(args_file_content)
     self._log_debug("Args file: %s" % args_file)
 
     runner_args = ["--compiler-args-file=%s" % args_file]
     _, stderr = self._run_jar(self._runner_jar, runner_args)
 
@@ skipping 10 matching lines @@
 
     if errors and out_file:
       if os.path.exists(out_file):
         os.remove(out_file)
       if os.path.exists(self._MAP_FILE_FORMAT % out_file):
         os.remove(self._MAP_FILE_FORMAT % out_file)
 
     return errors, stderr
 
   def check(self, source_file, out_file=None, depends=None, externs=None,
-            output_wrapper=None):
+            closure_args=None):
     """Closure compiler |source_file| while checking for errors.
 
     Args:
       source_file: A file to check.
       out_file: A file where the compiled output is written to.
       depends: Files that |source_file| requires to run (e.g. earlier <script>).
       externs: @extern files that inform the compiler about custom globals.
-      output_wrapper: Wraps output into this string at the place denoted by the
-          marker token %output%.
+      closure_args: Arguments passed directly to the closure compiler.
 
     Returns:
       (found_errors, stderr) A boolean indicating whether errors were found and
           the raw Closure compiler stderr (as a string).
     """
     self._log_debug("FILE: %s" % source_file)
 
     if source_file.endswith("_externs.js"):
       self._log_debug("Skipping externs: %s" % source_file)
       return
 
     self._file_arg = source_file
 
     cwd, tmp_dir = os.getcwd(), tempfile.gettempdir()
     rel_path = lambda f: os.path.join(os.path.relpath(cwd, tmp_dir), f)
 
     depends = depends or []
     includes = [rel_path(f) for f in depends + [source_file]]
     contents = ['<include src="%s">' % i for i in includes]
     meta_file = self._create_temp_file("\n".join(contents))
     self._log_debug("Meta file: %s" % meta_file)
 
     self._processor = processor.Processor(meta_file)
     self._expanded_file = self._create_temp_file(self._processor.contents)
     self._log_debug("Expanded file: %s" % self._expanded_file)
 
     errors, stderr = self._run_js_check([self._expanded_file],
                                         out_file=out_file, externs=externs,
-                                        output_wrapper=output_wrapper)
+                                        closure_args=closure_args)
     filtered_errors = self._filter_errors(errors)
     cleaned_errors = map(self._clean_up_error, filtered_errors)
     output = self._format_errors(cleaned_errors)
 
     if cleaned_errors:
       prefix = "\n" if output else ""
       self._log_error("Error in: %s%s%s" % (source_file, prefix, output))
     elif output:
       self._log_debug("Output: %s" % output)
 
     self._nuke_temp_files()
     return bool(cleaned_errors), stderr
 
-  def check_multiple(self, sources, out_file=None, output_wrapper=None,
+  def check_multiple(self, sources, out_file=None, closure_args=None,
                      externs=None):
     """Closure compile a set of files and check for errors.
 
     Args:
       sources: An array of files to check.
       out_file: A file where the compiled output is written to.
-      output_wrapper: Wraps output into this string at the place denoted by the
-          marker token %output%.
+      closure_args: Arguments passed directly to the closure compiler.
       externs: @extern files that inform the compiler about custom globals.
 
     Returns:
       (found_errors, stderr) A boolean indicating whether errors were found and
           the raw Closure Compiler stderr (as a string).
     """
     errors, stderr = self._run_js_check(sources, out_file=out_file,
-                                        output_wrapper=output_wrapper,
+                                        closure_args=closure_args,
                                         externs=externs)
     self._nuke_temp_files()
     return bool(errors), stderr
 
 
 if __name__ == "__main__":
   parser = argparse.ArgumentParser(
       description="Typecheck JavaScript using Closure compiler")
   parser.add_argument("sources", nargs=argparse.ONE_OR_MORE,
                       help="Path to a source file to typecheck")
   single_file_group = parser.add_mutually_exclusive_group()
   single_file_group.add_argument("--single-file", dest="single_file",
                                  action="store_true",
                                  help="Process each source file individually")
   single_file_group.add_argument("--no-single-file", dest="single_file",
                                  action="store_false",
                                  help="Process all source files as a group")
   parser.add_argument("-d", "--depends", nargs=argparse.ZERO_OR_MORE)
   parser.add_argument("-e", "--externs", nargs=argparse.ZERO_OR_MORE)
   parser.add_argument("-o", "--out_file",
                       help="A file where the compiled output is written to")
-  parser.add_argument("-w", "--output_wrapper",
-                      help="Wraps output into this string at the place"
-                         + " denoted by the marker token %output%")
+  parser.add_argument("-c", "--closure_args",
+                      help="Arguments passed directly to the closure compiler")
   parser.add_argument("-v", "--verbose", action="store_true",
                       help="Show more information as this script runs")
   parser.add_argument("--strict", action="store_true",
                       help="Enable strict type checking")
   parser.add_argument("--success-stamp",
                       help="Timestamp file to update upon success")
 
   parser.set_defaults(single_file=True, strict=False)
   opts = parser.parse_args()
 
   depends = opts.depends or []
   externs = set(opts.externs or [])
 
   polymer_externs = os.path.join(os.path.dirname(_CURRENT_DIR), 'polymer',
                                  'v0_8', 'components-chromium',
                                  'polymer-externs', 'polymer.externs.js')
   externs.add(polymer_externs)
 
   checker = Checker(verbose=opts.verbose, strict=opts.strict)
   if opts.single_file:
     for source in opts.sources:
       depends, externs = build.inputs.resolve_recursive_dependencies(
           source, depends, externs)
       found_errors, _ = checker.check(source, out_file=opts.out_file,
                                       depends=depends, externs=externs,
-                                      output_wrapper=opts.output_wrapper)
+                                      closure_args=opts.closure_args)
       if found_errors:
         sys.exit(1)
   else:
     found_errors, stderr = checker.check_multiple(
         opts.sources,
         out_file=opts.out_file,
-        output_wrapper=opts.output_wrapper,
+        closure_args=opts.closure_args,
         externs=externs)
     if found_errors:
       print stderr
       sys.exit(1)
 
   if opts.success_stamp:
     with open(opts.success_stamp, "w"):
       os.utime(opts.success_stamp, None)