Make compile_frontend.py work with default JVM 1.8 installation on Mac OS X

Source/devtools/scripts/compile_frontend.py

 #!/usr/bin/env python
 # Copyright (c) 2012 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 35 matching lines @@
 
 if len(sys.argv) == 2 and sys.argv[1] == '--help':
     print("Usage: %s [module_names]" % path.basename(sys.argv[0]))
     print("  module_names    list of modules for which the Closure compilation should run.")
     print("                  If absent, the entire frontend will be compiled.")
     sys.exit(0)
 
 is_cygwin = sys.platform == 'cygwin'
 
 
-def run_in_shell(command_line):
-    return subprocess.Popen(command_line, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True)
-
+def popen(arguments):
+    return subprocess.Popen(arguments, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 
 def to_platform_path(filepath):
     if not is_cygwin:
         return filepath
     return re.sub(r'^/cygdrive/(\w)', '\\1:', filepath)
 
 
 def to_platform_path_exact(filepath):
     if not is_cygwin:
         return filepath
-    output, _ = run_in_shell('cygpath -w %s' % filepath).communicate()
+    output, _ = popen(['cygpath', '-w', filepath]).communicate()
     # pylint: disable=E1103
     return output.strip().replace('\\', '\\\\')
 
 scripts_path = path.dirname(path.abspath(__file__))
 devtools_path = path.dirname(scripts_path)
 inspector_path = path.join(path.dirname(devtools_path), 'core', 'inspector')
 devtools_frontend_path = path.join(devtools_path, 'front_end')
 patched_es6_externs_file = to_platform_path(path.join(devtools_frontend_path, 'es6.js'))
 global_externs_file = to_platform_path(path.join(devtools_frontend_path, 'externs.js'))
 protocol_externs_file = path.join(devtools_frontend_path, 'protocol_externs.js')
@@ skipping 27 matching lines @@
     fpath, fname = path.split(program)
     if fpath:
         if is_exe(program):
             return program
     else:
         for part in os.environ["PATH"].split(os.pathsep):
             part = part.strip('"')
             exe_file = path.join(part, program)
             if is_exe(exe_file):
                 return exe_file
-
     return None
 
 
 def log_error(message):
     print 'ERROR: ' + message
 
 def error_excepthook(exctype, value, traceback):
     print 'ERROR:'
     sys.__excepthook__(exctype, value, traceback)
 sys.excepthook = error_excepthook
 
 application_descriptors = ['inspector.json', 'toolbox.json']
 loader = modular_build.DescriptorLoader(devtools_frontend_path)
 descriptors = loader.load_applications(application_descriptors)
 modules_by_name = descriptors.modules
 
 
 def hasErrors(output):
     return re.search(error_warning_regex, output) != None
 
 
 def verify_jsdoc_extra(additional_files):
     files = [to_platform_path(file) for file in descriptors.all_compiled_files() + additional_files]
     file_list = tempfile.NamedTemporaryFile(mode='wt', delete=False)
     try:
         file_list.write('\n'.join(files))
     finally:
         file_list.close()
-    return run_in_shell('%s -jar %s --files-list-name %s' % (java_exec, jsdoc_validator_jar, to_platform_path_exact(file_list.name))), file_list
+    return popen(java_exec + ['-jar', jsdoc_validator_jar, '--files-list-name', to_platform_path_exact(file_list.name)]), file_list
 
 
 def verify_jsdoc(additional_files):
     def file_list():
         return descriptors.all_compiled_files() + additional_files
 
     errors_found = False
     for full_file_name in file_list():
         lineIndex = 0
         with open(full_file_name, 'r') as sourceFile:
@@ skipping 48 matching lines @@
     has_server_jvm = True
     java_path = which('java')
     if not java_path:
         java_path = which('java.exe')
 
     if not java_path:
         print 'NOTE: No Java executable found in $PATH.'
         sys.exit(1)
 
     is_ok = False
-    java_version_out, _ = run_in_shell('%s -version' % java_path).communicate()
+    java_version_out, _ = popen([java_path, '-version']).communicate()
     # pylint: disable=E1103
     match = re.search(java_build_regex, java_version_out)
     if match:
         major = int(match.group(1))
         minor = int(match.group(2))
         is_ok = major >= required_major and minor >= required_minor
     if is_ok:
-        exec_command = '%s -Xms1024m -server -XX:+TieredCompilation' % java_path
-        check_server_proc = run_in_shell('%s -version' % exec_command)
+        exec_command = [java_path, '-Xms1024m', '-server', '-XX:+TieredCompilation']
+        check_server_proc = popen(exec_command + ['-version'])
         check_server_proc.communicate()
         if check_server_proc.returncode != 0:
             # Not all Java installs have server JVMs.
-            exec_command = exec_command.replace('-server ', '')
+            exec_command = exec_command.remove('-server ')
             has_server_jvm = False
 
     if not is_ok:
         print 'NOTE: Java executable version %d.%d or above not found in $PATH.' % (required_major, required_minor)
         sys.exit(1)
     print 'Java executable: %s%s' % (java_path, '' if has_server_jvm else ' (no server JVM)')
     return exec_command
 
 java_exec = find_java()
 
 closure_compiler_jar = to_platform_path(path.join(scripts_path, 'closure', 'compiler.jar'))
 closure_runner_jar = to_platform_path(path.join(scripts_path, 'compiler-runner', 'closure-runner.jar'))
 jsdoc_validator_jar = to_platform_path(path.join(scripts_path, 'jsdoc-validator', 'jsdoc-validator.jar'))
 
 modules_dir = tempfile.mkdtemp()
-common_closure_args = ' --summary_detail_level 3 --jscomp_error visibility --compilation_level SIMPLE_OPTIMIZATIONS --warning_level VERBOSE --language_in=ES6_STRICT --language_out=ES5_STRICT --accept_const_keyword --extra_annotation_name suppressReceiverCheck --extra_annotation_name suppressGlobalPropertiesCheck --module_output_path_prefix %s' % to_platform_path_exact(modules_dir + path.sep)
+common_closure_args = [
+    '--summary_detail_level', '3',
+    '--jscomp_error', 'visibility',
+    '--compilation_level', 'SIMPLE_OPTIMIZATIONS',
+    '--warning_level', 'VERBOSE',
+    '--language_in=ES6_STRICT',
+    '--language_out=ES5_STRICT',
+    '--accept_const_keyword',
+    '--extra_annotation_name', 'suppressReceiverCheck',
+    '--extra_annotation_name', 'suppressGlobalPropertiesCheck',
+    '--module_output_path_prefix', to_platform_path_exact(modules_dir + path.sep)
+]
 
 worker_modules_by_name = {}
 dependents_by_module_name = {}
 
 for module_name in descriptors.application:
     module = descriptors.modules[module_name]
     if descriptors.application[module_name].get('type', None) == 'worker':
         worker_modules_by_name[module_name] = module
     for dep in module.get('dependencies', []):
         list = dependents_by_module_name.get(dep)
@@ skipping 84 matching lines @@
     return command
 
 print 'Compiling frontend...'
 
 compiler_args_file = tempfile.NamedTemporaryFile(mode='wt', delete=False)
 try:
     platform_protocol_externs_file = to_platform_path(protocol_externs_file)
     runtime_js_path = to_platform_path(path.join(devtools_frontend_path, 'Runtime.js'))
     checked_modules = modules_to_check()
     for name in checked_modules:
-        closure_args = common_closure_args
+        closure_args = ' '.join(common_closure_args)
         closure_args += ' --externs ' + to_platform_path(patched_es6_externs_file)
         closure_args += ' --externs ' + to_platform_path(global_externs_file)
         closure_args += ' --externs ' + platform_protocol_externs_file
         runtime_module = module_arg(runtime_module_name) + ':1 --js ' + runtime_js_path
         closure_args += runtime_module + dump_module(name, True, {})
         compiler_args_file.write('%s %s%s' % (name, closure_args, os.linesep))
 finally:
     compiler_args_file.close()
 
-closure_runner_command = '%s -jar %s --compiler-args-file %s' % (java_exec, closure_runner_jar, to_platform_path_exact(compiler_args_file.name))
-modular_compiler_proc = run_in_shell(closure_runner_command)
+modular_compiler_proc = popen(java_exec + ['-jar', closure_runner_jar, '--compiler-args-file', to_platform_path_exact(compiler_args_file.name)])
 
 
 def unclosure_injected_script(sourceFileName, outFileName):
 
     source = read_file(sourceFileName)
 
     def replace_function(matchobj):
         return re.sub(r'@param', 'param', matchobj.group(1) or '') + '\n//' + matchobj.group(2)
 
     # Comment out the closure function and its jsdocs
     source = re.sub(r'(/\*\*(?:[\s\n]*\*\s*@param[^\n]+\n)+\s*\*/\s*)?\n(\(function)', replace_function, source, count=1)
 
     # Comment out its return statement
     source = re.sub(r'\n(\s*return\s+[^;]+;\s*\n\}\)\s*)$', '\n/*\\1*/', source)
 
     # Replace the "var Object" override with a "self.Object" one
     source = re.sub(r'\nvar Object =', '\nself.Object =', source, count=1)
 
     write_file(outFileName, source)
 
 injectedScriptSourceTmpFile = to_platform_path(path.join(inspector_path, 'InjectedScriptSourceTmp.js'))
 
 unclosure_injected_script(injected_script_source_name, injectedScriptSourceTmpFile)
 
 print 'Compiling InjectedScriptSource.js...'
-spawned_compiler_command = '%s -jar %s %s' % (java_exec, closure_compiler_jar, common_closure_args)
 
-command = spawned_compiler_command
-command += '    --externs ' + to_platform_path(injected_script_externs_file)
-command += '    --externs ' + to_platform_path(protocol_externs_file)
-command += '    --module ' + jsmodule_name_prefix + 'injected_script' + ':1'
-command += '        --js ' + to_platform_path(injectedScriptSourceTmpFile)
+spawned_compiler_command = java_exec + [
+    '-jar',
+    closure_compiler_jar
+] + common_closure_args
 
-injectedScriptCompileProc = run_in_shell(command)
+command = spawned_compiler_command + [
+    '--externs', to_platform_path_exact(injected_script_externs_file),
+    '--externs', to_platform_path_exact(protocol_externs_file),
+    '--module', jsmodule_name_prefix + 'injected_script' + ':1',
+    '--js', to_platform_path(injectedScriptSourceTmpFile),

[dgozman, 2015/06/05 13:08:29]

nit: extra comma

+]
+
+injectedScriptCompileProc = popen(command)
 
 print 'Compiling devtools.js...'
-spawned_compiler_command = '%s -jar %s %s' % (java_exec, closure_compiler_jar, common_closure_args)
-command = spawned_compiler_command
-command += '    --externs ' + to_platform_path(global_externs_file)
-command += '    --externs ' + to_platform_path(path.join(devtools_frontend_path, 'host', 'InspectorFrontendHostAPI.js'))
-command += '    --module ' + jsmodule_name_prefix + 'devtools_js' + ':1'
-command += '        --js ' + to_platform_path(path.join(devtools_frontend_path, 'devtools.js'))
-devtoolsJSCompileProc = run_in_shell(command)
+
+command = spawned_compiler_command + [
+    '--externs', to_platform_path(global_externs_file),
+    '--externs', to_platform_path(path.join(devtools_frontend_path, 'host', 'InspectorFrontendHostAPI.js')),
+    '--module', jsmodule_name_prefix + 'devtools_js' + ':1',
+    '--js', to_platform_path(path.join(devtools_frontend_path, 'devtools.js'))
+]
+devtoolsJSCompileProc = popen(command)
 
 print 'Verifying JSDoc comments...'
 additional_jsdoc_check_files = [injectedScriptSourceTmpFile]
 errors_found |= verify_jsdoc(additional_jsdoc_check_files)
 jsdocValidatorProc, jsdocValidatorFileList = verify_jsdoc_extra(additional_jsdoc_check_files)
 
 print 'Validating InjectedScriptSource.js...'
 injectedscript_check_script_path = path.join(scripts_path, "check_injected_script_source.py")
-check_injected_script_command = '%s %s' % (injectedscript_check_script_path, injected_script_source_name)
-validateInjectedScriptProc = run_in_shell(check_injected_script_command)
+validateInjectedScriptProc = popen([sys.executable, injectedscript_check_script_path, injected_script_source_name])
 
 print
 
 (jsdocValidatorOut, _) = jsdocValidatorProc.communicate()
 if jsdocValidatorOut:
     print ('JSDoc validator output:%s%s' % (os.linesep, jsdocValidatorOut))
     errors_found = True
 
 os.remove(jsdocValidatorFileList.name)
 
@@ skipping 66 matching lines @@
 print 'Validate InjectedScriptSource.js output:%s' % os.linesep, (validateInjectedScriptOut if validateInjectedScriptOut else '<empty>')
 errors_found |= hasErrors(validateInjectedScriptOut)
 
 if errors_found:
     print 'ERRORS DETECTED'
 
 os.remove(injectedScriptSourceTmpFile)
 os.remove(compiler_args_file.name)
 os.remove(protocol_externs_file)
 shutil.rmtree(modules_dir, True)