DevTools: Simplify debug and release mode builds

third_party/WebKit/Source/devtools/scripts/build_release_applications.py

 #!/usr/bin/env python
+# -*- coding: UTF-8 -*-
 #
 # 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.
 
 """
-Release:
-  - Concatenates autostart modules, application modules' module.json descriptors,
-    and the application loader into a single script.
-  - Builds app.html referencing the application script.
-Debug:
-  - Copies the module directories into their destinations.
-  - Copies app.html as-is.
+Builds applications in release mode:
+- Concatenates autostart modules, application modules' module.json descriptors,
+and the application loader into a single script.
+- Builds app.html referencing the application script.
 """
 
 from cStringIO import StringIO
 from os import path
 from os.path import join
 from modular_build import read_file, write_file, bail_error
 import copy
 import modular_build
 import os
 import re
 import shutil
 import sys
 
 try:
     import simplejson as json
 except ImportError:
     import json
 
 import rjsmin
 
 
+def main(argv):
+    try:
+        input_path_flag_index = argv.index('--input_path')
+        input_path = argv[input_path_flag_index + 1]
+        output_path_flag_index = argv.index('--output_path')
+        output_path = argv[output_path_flag_index + 1]
+        application_names = argv[1:input_path_flag_index]
+    except:
+        print('Usage: %s app_1 app_2 ... app_N --input_path <input_path> --output_path <output_path>' % argv[0])
+        raise
+
+    loader = modular_build.DescriptorLoader(input_path)
+    for app in application_names:
+        descriptors = loader.load_application(app + '.json')
+        builder = ReleaseBuilder(app, descriptors, input_path, output_path)
+        builder.build_app()
+
+
 def resource_source_url(url):
     return '\n/*# sourceURL=' + url + ' */'
 
 
 def minify_js(javascript):
     return rjsmin.jsmin(javascript)
 
 
 def concatenated_module_filename(module_name, output_dir):
     return join(output_dir, module_name + '/' + module_name + '_module.js')
@@ skipping 14 matching lines @@
     for src_dir, dirs, files in os.walk(src):
         subpath = path.relpath(src_dir, src)
         dest_dir = path.normpath(join(dest, subpath))
         os.mkdir(dest_dir)
         for name in files:
             src_name = join(os.getcwd(), src_dir, name)
             dest_name = join(dest_dir, name)
             symlink_or_copy_file(src_name, dest_name)
 
 
-class AppBuilder:
+# Outputs:
+#   <app_name>.html
+#   <app_name>.js
+#   <module_name>_module.js
+class ReleaseBuilder(object):
     def __init__(self, application_name, descriptors, application_dir, output_dir):
         self.application_name = application_name
         self.descriptors = descriptors
         self.application_dir = application_dir
         self.output_dir = output_dir
 
     def app_file(self, extension):
         return self.application_name + '.' + extension
 
     def core_resource_names(self):
         result = []
         for module in self.descriptors.sorted_modules():
             if self.descriptors.application[module].get('type') != 'autostart':
                 continue
 
             resources = self.descriptors.modules[module].get('resources')
             if not resources:
                 continue
             for resource_name in resources:
                 result.append(path.join(module, resource_name))
         return result
 
-
-# Outputs:
-#   <app_name>.html
-#   <app_name>.js
-#   <module_name>_module.js
-class ReleaseBuilder(AppBuilder):
-    def __init__(self, application_name, descriptors, application_dir, output_dir):
-        AppBuilder.__init__(self, application_name, descriptors, application_dir, output_dir)
-
     def build_app(self):
         if self.descriptors.has_html:
             self._build_html()
         self._build_app_script()
         for module in filter(lambda desc: (not desc.get('type') or desc.get('type') == 'remote'), self.descriptors.application.values()):
             self._concatenate_dynamic_module(module['name'])
 
     def _build_html(self):
         html_name = self.app_file('html')
         output = StringIO()
         with open(join(self.application_dir, html_name), 'r') as app_input_html:
             for line in app_input_html:
                 if '<script ' in line or '<link ' in line:
                     continue
                 if '</head>' in line:
                     output.write(self._generate_include_tag(self.app_file('js')))
                 output.write(line)
 
         write_file(join(self.output_dir, html_name), output.getvalue())
         output.close()
 
     def _build_app_script(self):
         script_name = self.app_file('js')
         output = StringIO()
         self._concatenate_application_script(output)
         write_file(join(self.output_dir, script_name), minify_js(output.getvalue()))
         output.close()
 
     def _generate_include_tag(self, resource_path):
-        if (resource_path.endswith('.js')):
+        if resource_path.endswith('.js'):
             return '    <script type="text/javascript" src="%s"></script>\n' % resource_path
         else:
             assert resource_path
 
     def _release_module_descriptors(self):
         module_descriptors = self.descriptors.modules
         result = []
         for name in module_descriptors:
             module = copy.copy(module_descriptors[name])
             module_type = self.descriptors.application[name].get('type')
@@ skipping 64 matching lines @@
         output = StringIO()
         if scripts:
             modular_build.concatenate_scripts(scripts, module_dir, self.output_dir, output)
         if resources:
             self._write_module_resources(resources, output)
         output_file_path = concatenated_module_filename(module_name, self.output_dir)
         write_file(output_file_path, minify_js(output.getvalue()))
         output.close()
 
 
-# Outputs:
-#   <app_name>.html as-is
-#   <app_name>.js as-is
-#   <module_name>/<all_files>
-class DebugBuilder(AppBuilder):
-    def __init__(self, application_name, descriptors, application_dir, output_dir):
-        AppBuilder.__init__(self, application_name, descriptors, application_dir, output_dir)
-
-    def build_app(self):
-        if self.descriptors.has_html:
-            self._build_html()
-        js_name = self.app_file('js')
-        src_name = join(os.getcwd(), self.application_dir, js_name)
-        symlink_or_copy_file(src_name, join(self.output_dir, js_name), True)
-        for module_name in self.descriptors.modules:
-            module = self.descriptors.modules[module_name]
-            input_module_dir = join(self.application_dir, module_name)
-            output_module_dir = join(self.output_dir, module_name)
-            symlink_or_copy_dir(input_module_dir, output_module_dir)
-
-    def _build_html(self):
-        html_name = self.app_file('html')
-        symlink_or_copy_file(join(os.getcwd(), self.application_dir, html_name), join(self.output_dir, html_name), True)
-
-
-def build_application(application_name, loader, application_dir, output_dir, release_mode):
-    descriptors = loader.load_application(application_name + '.json')
-    if release_mode:
-        builder = ReleaseBuilder(application_name, descriptors, application_dir, output_dir)
-    else:
-        builder = DebugBuilder(application_name, descriptors, application_dir, output_dir)
-    builder.build_app()
+if __name__ == '__main__':
+    sys.exit(main(sys.argv))