#!/usr/bin/env vpython # -*- 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, and the application loader into a single script. """ from io import StringIO from os import path from os.path import join import copy import os import re import shutil import sys import subprocess from modular_build import read_file, write_file, bail_error import modular_build import rjsmin try: import simplejson as json except ImportError: import json try: original_sys_path = sys.path sys.path = sys.path + [path.join(os.path.dirname(os.path.realpath(__file__)), '..')] import devtools_paths finally: sys.path = original_sys_path FRONT_END_DIRECTORY = path.join(os.path.dirname(path.abspath(__file__)), '..', '..', 'front_end') def main(argv): try: input_path_flag_index = argv.index('--input_path') input_path = argv[input_path_flag_index + 1] output_path_gen_flag_index = argv.index('--output_path_gen') output_path_gen = argv[output_path_gen_flag_index + 1] application_names = argv[1:input_path_flag_index] use_rollup = '--rollup' in argv except: print('Usage: %s app_1 app_2 ... app_N --input_path --output_path --rollup true' % argv[0]) raise loader = modular_build.DescriptorLoader(input_path) for app in application_names: descriptors = loader.load_application(app) builder = ReleaseBuilder(app, descriptors, input_path, output_path_gen, use_rollup) 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 + '/' + path.basename(module_name) + '_module.js') # Outputs: # .js # _module.js class ReleaseBuilder(object): def __init__(self, application_name, descriptors, application_dir, output_path_gen_dir, use_rollup): self.application_name = application_name self.descriptors = descriptors self.application_dir = application_dir self.output_path_gen_dir = output_path_gen_dir self.use_rollup = use_rollup def app_file(self, extension): return path.join('entrypoints', self.application_name, self.application_name + '.' + extension) def autorun_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 def build_app(self): self._build_app_script() for module in filter(lambda desc: (not desc.get('type')), self.descriptors.application.values()): self._concatenate_dynamic_module(module['name']) def _build_app_script(self): script_name = self.app_file('js') output = StringIO() self._concatenate_application_script(output) minified_content = minify_js(output.getvalue()) write_file(join(self.output_path_gen_dir, script_name), minified_content) output.close() 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') resources = module.get('resources', None) if resources: # Resources are already baked into _module. del module['resources'] if not module_type == 'autostart': # We load the entrypoint of a module no matter what. # Therefore, we don't need to declare any files for # the default case. However, if a module still has # a legacy file, the Runtime performs an array # contains check and will load that instead. module_files_to_load = [] declared_module_files = module.get('modules', []) legacyFileName = path.basename(name) + '-legacy.js' if legacyFileName in declared_module_files: module_files_to_load += [legacyFileName] # Non-autostart modules are vulcanized. module['modules'] = [path.basename(name) + '_module.js' ] + module_files_to_load result.append(module) return json.dumps(result) def _write_module_resources(self, resource_names, output): for resource_name in resource_names: resource_name = path.normpath(resource_name).replace('\\', '/') output.write('RootModule.Runtime.cachedResources.set("%s", "' % resource_name) resource_content = read_file(path.join(self.application_dir, resource_name)) if not (resource_name.endswith('.html') or resource_name.endswith('md')): resource_content += resource_source_url(resource_name) resource_content = resource_content.replace('\\', '\\\\') resource_content = resource_content.replace('\n', '\\n') resource_content = resource_content.replace('"', '\\"') output.write(resource_content) output.write('");\n') def _concatenate_autostart_modules(self, output): non_autostart = set() 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)) else: non_autostart.add(name) def _concatenate_application_script(self, output): output.write('Root.allDescriptors.push(...%s);' % self._release_module_descriptors()) if self.descriptors.extends: output.write( 'Root.applicationDescriptor.modules.push(...%s);' % json.dumps(list(self.descriptors.application.values()))) else: output.write('Root.applicationDescriptor = %s;' % self.descriptors.application_json()) output.write("import * as RootModule from '../../core/root/root.js';") self._write_module_resources(self.autorun_resource_names(), output) output.write(minify_js(read_file(join(self.application_dir, self.app_file('js'))))) self._concatenate_autostart_modules(output) def _concatenate_dynamic_module(self, module_name): module = self.descriptors.modules[module_name] modules = module.get('modules') resources = self.descriptors.module_resources(module_name) module_dir = join(self.application_dir, module_name) output = StringIO() if resources: relative_file_name = '../core/root/root.js' if "/" in module_name: relative_file_name = ( '../' * module_name.count('/')) + relative_file_name output.write("import * as RootModule from '%s';" % relative_file_name) self._write_module_resources(resources, output) minified_content = minify_js(output.getvalue()) write_file( concatenated_module_filename(module_name, self.output_path_gen_dir), minified_content) output.close() if __name__ == '__main__': sys.exit(main(sys.argv))