DevTools: extract modules (with extensions)

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

 #!/usr/bin/env python
 # -*- coding: UTF-8 -*-
 #
 # Copyright 2016 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.
 
 """
 Builds applications in release mode:
 - Concatenates autostart modules, application modules' module.json descriptors,
@@ skipping 12 matching lines @@
 
 from modular_build import read_file, write_file, bail_error
 import modular_build
 import rjsmin
 
 try:
     import simplejson as json
 except ImportError:
     import json
 
+special_case_namespaces_path = path.join(path.dirname(path.dirname(path.abspath(__file__))), 'special_case_namespaces.json')
+
 
 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])
@@ skipping 43 matching lines @@
 # 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
+        with open(special_case_namespaces_path) as json_file:
+            self._special_case_namespaces = json.load(json_file)
 
     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
 
@@ skipping 76 matching lines @@
         sorted_module_names = self.descriptors.sorted_modules()
         for name in sorted_module_names:
             desc = self.descriptors.modules[name]
             name = desc['name']
             type = self.descriptors.application[name].get('type')
             if type == 'autostart':
                 deps = set(desc.get('dependencies', []))
                 non_autostart_deps = deps & non_autostart
                 if len(non_autostart_deps):
                     bail_error('Non-autostart dependencies specified for the autostarted module "%s": %s' % (name, non_autostart_deps))
-
-                namespace = name.replace('_lazy', '')
-                if namespace == 'sdk' or namespace == 'ui':
-                    namespace = namespace.upper();
-                namespace = "".join(map(lambda x: x[0].upper() + x[1:], namespace.split('_')))
+                namespace = self._map_module_to_namespace(name)
                 output.write('\n/* Module %s */\n' % name)
                 output.write('\nself[\'%s\'] = self[\'%s\'] || {};\n' % (namespace, namespace))
                 modular_build.concatenate_scripts(desc.get('scripts'), join(self.application_dir, name), self.output_dir, output)
             else:
                 non_autostart.add(name)
 
+    def _map_module_to_namespace(self, module):
+        camel_case_namespace = "".join(map(lambda x: x[0].upper() + x[1:], module.split('_')))
+        return self._special_case_namespaces.get(module, camel_case_namespace)
+
     def _concatenate_application_script(self, output):
         runtime_contents = read_file(join(self.application_dir, 'Runtime.js'))
         runtime_contents = re.sub('var allDescriptors = \[\];', 'var allDescriptors = %s;' % self._release_module_descriptors().replace('\\', '\\\\'), runtime_contents, 1)
         output.write('/* Runtime.js */\n')
         output.write(runtime_contents)
         output.write('\n/* Autostart modules */\n')
         self._concatenate_autostart_modules(output)
         output.write('/* Application descriptor %s */\n' % self.app_file('json'))
         output.write('applicationDescriptor = ')
         output.write(self.descriptors.application_json())
@@ skipping 12 matching lines @@
             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()
 
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv))