Output closure-compiled JavaScript files

third_party/closure_compiler/checker.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 a JavaScript file to check for errors."""
 
 import argparse
 import os
 import re
@@ skipping 26 matching lines @@
     "--jscomp_error=missingReturn",
     "--jscomp_error=nonStandardJsDocs",
     "--jscomp_error=suspiciousCode",
     "--jscomp_error=undefinedNames",
     "--jscomp_error=undefinedVars",
     "--jscomp_error=unknownDefines",
     "--jscomp_error=uselessCode",
     "--jscomp_error=visibility",
     "--language_in=ECMASCRIPT5_STRICT",
     "--summary_detail_level=3",
+    '--compilation_level=WHITESPACE_ONLY'

[Dan Beam, 2015/03/06 02:57:29]

' -> "

[Dan Beam, 2015/03/06 02:57:29]

nit: trailing ,

[Theresa, 2015/03/06 18:09:19]

Done.

[Theresa, 2015/03/06 18:09:19]

Done.

   ]
 
   # 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",
     "--jscomp_error=misplacedTypeAnnotation",
   ]
 
@@ skipping 113 matching lines @@
     errors = filter(None, errors)
     contents = "\n## ".join("\n\n".join(errors).splitlines())
     return "## %s" % contents if contents else ""
 
   def _create_temp_file(self, contents):
     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, externs=None):
+  def run_js_check(self, sources, externs=None, out_file=None,

[Dan Beam, 2015/03/06 02:57:29]

i think if the code will be modified, there should be a source map, so couple
these options together (i.e. just treat a non-empty out_file as a desire to
generate output)

[Theresa, 2015/03/06 03:07:19]

Right now, the out_file is never empty. I'll look into modifying compile_js to
only specify an out_file if the corresponding compiled_resources.gyp specifies
output should be generated.

[Dan Beam, 2015/03/06 03:41:38]

why not just write the output for all files?

+                   generate_output=False):
     if not self._check_java_path():
       return 1, ""
 
     args = ["--js=%s" % s for s in sources]
+
+    if generate_output:
+      args += ["--js_output_file=%s" % out_file]
+      args += ["--source_map_format=V3"]
+      args += ["--create_source_map=%s.map" % out_file]
+
     if externs:
       args += ["--externs=%s" % e for e in externs]
     args_file_content = " %s" % " ".join(self._common_args() + args)
     self._debug("Args: %s" % args_file_content.strip())
 
     args_file = self._create_temp_file(args_file_content)
     self._debug("Args file: %s" % args_file)
 
     runner_args = ["--compiler-args-file=%s" % args_file]
     runner_cmd = self._run_jar(self._runner_jar, args=runner_args)
     _, stderr = runner_cmd.communicate()
 
     errors = stderr.strip().split("\n\n")
     self._debug("Summary: %s" % errors.pop())
 
     self._clean_up()
 
     return errors, stderr
 
-  def check(self, source_file, depends=None, externs=None):
+  def check(self, source_file, depends=None, externs=None,
+            out_file=None, generate_output=False):
     """Closure compile a file and check for errors.
 
     Args:
         source_file: A file to check.
         depends: Other files that would be included with a <script> earlier in
             the page.
         externs: @extern files that inform the compiler about custom globals.
 
     Returns:
         (has_errors, output) A boolean indicating if there were errors and the
@@ skipping 18 matching lines @@
 
     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._debug("Meta file: %s" % meta_file)
 
     self._processor = processor.Processor(meta_file)
     self._expanded_file = self._create_temp_file(self._processor.contents)
     self._debug("Expanded file: %s" % self._expanded_file)
 
-    errors, stderr = self.run_js_check([self._expanded_file], externs)
+    errors, stderr = self.run_js_check([self._expanded_file], externs,
+                                       out_file, generate_output)
 
     # Filter out false-positive promise chain errors.
     # See https://github.com/google/closure-compiler/issues/715 for details.
     errors = self._error_filter.filter(errors);
 
     output = self._format_errors(map(self._fix_up_error, errors))
     if errors:
       prefix = "\n" if output else ""
       self._error("Error in: %s%s%s" % (source_file, prefix, output))
     elif output:
@@ skipping 23 matching lines @@
   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 place to output results")
+  parser.add_argument("-g", "--generate_output",
+                      help="Whether or not an output file should be generated")
   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 = opts.externs or set()
+  generate_output = False if (opts.generate_output == '0') else True

[Dan Beam, 2015/03/06 02:57:29]

False if (condition) else True => can always be shortened to => (condition)

+
+  # Clean up intermediate folders that get created by output.py or create the dirs if needed

[Dan Beam, 2015/03/06 02:57:29]

end with .

[Dan Beam, 2015/03/06 02:57:29]

80 col wrap

+  out_dir = os.path.dirname(opts.out_file)
+  if not generate_output:
+    if os.path.exists(out_dir) and os.listdir(out_dir) == []:

[Dan Beam, 2015/03/06 02:57:29]

why are we making empty directories?

[Theresa, 2015/03/06 03:07:19]

I think output.py is creating them when it generates the path for the output
file.. I'll change compile_js to be smarter about when it's running output.py.

+      os.removedirs(out_dir)
+  else:
+    if not os.path.exists(out_dir):
+      os.makedirs(out_dir)

[Dan Beam, 2015/03/06 02:57:28]

so closure doesn't do this automatically?  make a path if it doesn't exist?

[Theresa, 2015/03/06 03:07:19]

It might. I'll try removing this. I had copied it from 312:315 below without
checking if it was needed.

 
   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)
-      has_errors, _ = checker.check(source, depends=depends, externs=externs)
+      has_errors, _ = checker.check(source, depends=depends, externs=externs,
+                                    out_file=opts.out_file, generate_output=generate_output)

[Dan Beam, 2015/03/06 02:57:29]

80 col wrap

       if has_errors:
         sys.exit(1)
 
-      if opts.out_file:
-        out_dir = os.path.dirname(opts.out_file)
-        if not os.path.exists(out_dir):
-          os.makedirs(out_dir)
-        # TODO(dbeam): write compiled file to |opts.out_file|.
-        open(opts.out_file, "w").write("")
   else:
     has_errors, errors = checker.check_multiple(opts.sources)
     if has_errors:
       print errors
       sys.exit(1)
 
   if opts.success_stamp:
     with open(opts.success_stamp, 'w'):
       os.utime(opts.success_stamp, None)