Add ChromeCodingConvention.java to Closure Compiler to preserve getInstance() type

third_party/closure_compiler/compile_modules.py

 #!/usr/bin/env 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.
 
 import argparse
 import ast
 from checker import Checker as Checker
 import os
 
+
+def get_rel_path_generator(file_path):
+  current_dir = os.getcwd()
+  module_dir = os.path.dirname(file_path)
+
+  if current_dir and module_dir:
+    here_to_module_dir = os.path.relpath(module_dir, current_dir)
+    if here_to_module_dir:
+      return lambda f: os.path.join(here_to_module_dir, f)
+
+  return lambda f: f
+
+
 class Module(object):
-  def __init__(self, name, sources, depends=[], externs=[]):
+  def __init__(self, name, sources, depends=[], externs=[],
+               expected_output=None):
     self.name = name
     self.sources = sources
     # TODO(dbeam): support depending on other modules/dependency flattening.
     self.depends = depends
     self.externs = externs
+    self.expected_output = expected_output
 
   @staticmethod
-  def from_dict(d):
+  def from_dict_and_rel_path_generator(d, rel_path_generator):
     keys = d.keys()
 
     required = ["name", "sources"]
     assert all(r in keys for r in required), "Module missing name or sources"
 
-    allowed = required + ["depends", "externs"]
+    allowed = required + ["depends", "externs", "expected_output"]

[Dan Beam, 2014/07/29 18:05:10]

this should not be in production code, figure out a way to only allow this key
to exist from tests.

[Vitaly Pavlenko, 2014/07/29 18:53:46]

Done.

     assert all(k in allowed for k in keys), "Module has unknown key"
 
     depends = d["depends"] if "depends" in d else []
     externs = d["externs"] if "externs" in d else []
-    return Module(d["name"], d["sources"], depends=depends, externs=externs)
+
+    sources = map(rel_path_generator, d["sources"])
+    depends = map(rel_path_generator, depends)
+    externs = map(rel_path_generator, externs)
+
+    expected_output = d["expected_output"] if "expected_output" in d else ""
+    return Module(d["name"], sources, depends=depends, externs=externs,
+                  expected_output=expected_output)
 
 
 # TODO(dbeam): should ModuleParser be internal to ModuleCompiler or should we
 # pass Modules into ModuleCompiler.compile()? Maybe this is fine?
 class ModuleParser(object):
   _cache = {}
 
   def __init__(self, verbose=False):
     self._verbose = verbose
 
   def parse(self, file_path):
     if file_path in self._cache:
-      print "(INFO) Found module file %s in the cache" % file_path 
+      print "(INFO) Found module file %s in the cache" % file_path
       return self._cache[file_path]
 
+
     file = open(file_path, "r")
     file_content = file.read()
     data = ast.literal_eval(file_content)
     file.close()
 
     if self._verbose:
       print "(INFO) Layout: " + os.linesep + file_content + os.linesep
 
-    self._cache[file_path] = [Module.from_dict(m) for m in data]
+    self._cache[file_path] = [Module.from_dict_and_rel_path_generator(
+        m, get_rel_path_generator(file_path)) for m in data]
     return self._cache[file_path]
 
 
 class ModuleCompiler(object):
-  _checker = None
-  _parser = None
 
-  def __init__(self, verbose=False):
+  def __init__(self, verbose=False, test_expected_output=False):
     self._verbose = verbose
+    self._parser = ModuleParser(verbose=self._verbose)
+    self._checker = Checker(verbose=self._verbose,
+                            return_output=test_expected_output)
+    self._test_expected_output = test_expected_output
 
   def _debug(self, msg, prefix="(INFO) ", suffix=""):
     if self._verbose:
       print prefix + msg.strip() + suffix
 
-  def compile(self, module_file):
+  def compile_source(self, source_path, module):
+    output = self._checker.check(source_path,
+                                 depends=module.depends,
+                                 externs=module.externs)
+
+    if self._test_expected_output:
+      return output
+
+  def get_modules(self, module_file):
+    return self._parser.parse(module_file)
+
+  def compile_module_file(self, module_file):
     self._debug("MODULE FILE: " + module_file, prefix="")
 
-    # NOTE: It's possible but unlikely that |_checker| or |_parser|'s verbosity
-    # isn't the same as |self._verbose| due to this class being called with
-    # verbose=False then verbose=True in the same program.
-    self._parser = self._parser or ModuleParser(verbose=self._verbose)
-    self._checker = self._checker or Checker(verbose=self._verbose)
-
-    current_dir = os.getcwd()
-    module_dir = os.path.dirname(module_file)
-    rel_path = lambda f: f
-
-    if current_dir and module_dir:
-      here_to_module_dir = os.path.relpath(module_dir, current_dir)
-      if here_to_module_dir:
-        rel_path = lambda f: os.path.join(here_to_module_dir, f)
-
-    modules = self._parser.parse(module_file)
+    modules = self.get_modules(module_file)
 
     for m in modules:
       self._debug("MODULE: " + m.name, prefix="", suffix=os.linesep)
 
       for s in m.sources:
-        depends = [rel_path(d) for d in m.depends]
-        externs = [rel_path(e) for e in m.externs]
-        self._checker.check(rel_path(s), depends=depends, externs=externs)
+        self.compile_source(s, m)
 
         if s != m.sources[-1]:
           self._debug(os.linesep, prefix="")
 
       if m != modules[-1]:
         self._debug(os.linesep, prefix="")
 
 
 def main(opts):
   module_compiler = ModuleCompiler(verbose=opts.verbose)
   for module_file in opts.module_file:
-    module_compiler.compile(module_file)
+    module_compiler.compile_module_file(module_file)
 
 
 if __name__ == "__main__":
   parser = argparse.ArgumentParser(
       description="Typecheck JavaScript using Closure compiler")
   parser.add_argument("-v", "--verbose", action="store_true",
                       help="Show more information as this script runs")
   parser.add_argument("module_file", nargs=argparse.ONE_OR_MORE,
                       help="Path to a modules file to check")
   main(parser.parse_args())