| #!/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. | |
| """ | |
| Utilities for the modular DevTools build. | |
| """ | |
| # pylint: skip-file | |
| import collections | |
| from os import path | |
| import os | |
| import sys | |
| # try: | |
| # import simplejson as json | |
| # except ImportError: | |
| # import json | |
| PYJSON5_DIR = os.path.join(os.path.dirname(__file__), | |
| '..', '..', 'third_party', 'pyjson5', 'src') | |
| sys.path.append(PYJSON5_DIR) | |
| import json5 as json # pylint: disable=import-error | |
| def read_file(filename): | |
| with open(path.normpath(filename), 'rt') as input: | |
| return input.read() | |
| def write_file(filename, content): | |
| if path.exists(filename): | |
| os.remove(filename) | |
| directory = path.dirname(filename) | |
| if not path.exists(directory): | |
| os.makedirs(directory) | |
| with open(filename, 'wt') as output: | |
| output.write(content) | |
| def bail_error(message): | |
| raise Exception(message) | |
| def load_and_parse_json(filename): | |
| try: | |
| return json.loads(read_file(filename)) | |
| except: | |
| print 'ERROR: Failed to parse %s' % filename | |
| raise | |
| def concatenate_scripts(file_names, module_dir, output_dir, output): | |
| for file_name in file_names: | |
| output.write('/* %s */\n' % file_name) | |
| file_path = path.join(module_dir, file_name) | |
| if not path.isfile(file_path): | |
| file_path = path.join(output_dir, path.basename(module_dir), file_name) | |
| output.write(read_file(file_path)) | |
| output.write(';') | |
| class Descriptors: | |
| def __init__(self, application_name, application_dir, application_descriptor, module_descriptors, extends, has_html, worker): | |
| self.application_name = application_name | |
| self.application_dir = application_dir | |
| self.application = application_descriptor | |
| self._cached_sorted_modules = None | |
| self.modules = module_descriptors | |
| self.extends = extends | |
| self.has_html = has_html | |
| self.worker = worker | |
| def application_json(self): | |
| result = dict() | |
| result['modules'] = self.application.values() | |
| result['has_html'] = self.has_html | |
| return json.dumps(result) | |
| def all_compiled_files(self): | |
| files = collections.OrderedDict() | |
| for name in self.sorted_modules(): | |
| module = self.modules[name] | |
| skipped_files = set(module.get('skip_compilation', [])) | |
| for script in module.get('scripts', []) + module.get('modules', []): | |
| if script not in skipped_files: | |
| files[path.normpath(path.join(self.application_dir, name, script))] = True | |
| return files.keys() | |
| def all_skipped_compilation_files(self): | |
| files = collections.OrderedDict() | |
| for name in self.sorted_modules(): | |
| module = self.modules[name] | |
| skipped_files = set(module.get('skip_compilation', [])) | |
| for script in skipped_files: | |
| files[path.join(name, script)] = True | |
| return files.keys() | |
| def module_compiled_files(self, name): | |
| files = [] | |
| module = self.modules.get(name) | |
| skipped_files = set(module.get('skip_compilation', [])) | |
| for script in module.get('scripts', []): | |
| if script not in skipped_files: | |
| files.append(script) | |
| return files | |
| def module_resources(self, name): | |
| return [name + '/' + resource for resource in self.modules[name].get('resources', [])] | |
| def sorted_modules(self): | |
| if self._cached_sorted_modules: | |
| return self._cached_sorted_modules | |
| result = [] | |
| unvisited_modules = set(self.modules) | |
| temp_modules = set() | |
| def visit(parent, name): | |
| if name not in unvisited_modules: | |
| return None | |
| if name not in self.modules: | |
| return (parent, name) | |
| if name in temp_modules: | |
| bail_error('Dependency cycle found at module "%s"' % name) | |
| temp_modules.add(name) | |
| deps = self.modules[name].get('dependencies') | |
| if deps: | |
| for dep_name in deps: | |
| bad_dep = visit(name, dep_name) | |
| if bad_dep: | |
| return bad_dep | |
| unvisited_modules.remove(name) | |
| temp_modules.remove(name) | |
| result.append(name) | |
| return None | |
| while len(unvisited_modules): | |
| for next in unvisited_modules: | |
| break | |
| failure = visit(None, next) | |
| if failure: | |
| # failure[0] can never be None | |
| bail_error('Unknown module "%s" encountered in dependencies of "%s"' % (failure[1], failure[0])) | |
| self._cached_sorted_modules = result | |
| return result | |
| def sorted_dependencies_closure(self, module_name): | |
| visited = set() | |
| def sorted_deps_for_module(name): | |
| result = [] | |
| desc = self.modules[name] | |
| deps = desc.get('dependencies', []) | |
| for dep in deps: | |
| result += sorted_deps_for_module(dep) | |
| if name not in visited: | |
| result.append(name) | |
| visited.add(name) | |
| return result | |
| return sorted_deps_for_module(module_name) | |
| class DescriptorLoader: | |
| def __init__(self, application_dir): | |
| self.application_dir = application_dir | |
| def load_application(self, application_descriptor_name): | |
| all_module_descriptors = {} | |
| result = self._load_application(application_descriptor_name, all_module_descriptors) | |
| return result | |
| def load_applications(self, application_descriptor_names): | |
| all_module_descriptors = {} | |
| all_application_descriptors = {} | |
| for application_descriptor_name in application_descriptor_names: | |
| descriptors = {} | |
| result = self._load_application(application_descriptor_name, descriptors) | |
| for name in descriptors: | |
| all_module_descriptors[name] = descriptors[name] | |
| for name in result.application: | |
| all_application_descriptors[name] = result.application[name] | |
| return Descriptors('all', self.application_dir, all_application_descriptors, all_module_descriptors, None, False, False) | |
| def _load_application(self, application_descriptor_name, all_module_descriptors): | |
| module_descriptors = {} | |
| application_descriptor_filename = path.join(self.application_dir, application_descriptor_name + '.json') | |
| descriptor_json = load_and_parse_json(application_descriptor_filename) | |
| application_descriptor = {desc['name']: desc for desc in descriptor_json['modules']} | |
| extends = descriptor_json['extends'] if 'extends' in descriptor_json else None | |
| if extends: | |
| extends = self._load_application(extends, all_module_descriptors) | |
| has_html = True if 'has_html' in descriptor_json and descriptor_json['has_html'] else False | |
| worker = True if 'worker' in descriptor_json and descriptor_json['worker'] else False | |
| for (module_name, module) in application_descriptor.items(): | |
| if all_module_descriptors.get(module_name): | |
| bail_error('Duplicate definition of module "%s" in %s' % (module_name, application_descriptor_filename)) | |
| module_descriptors[module_name] = self._read_module_descriptor(module_name, application_descriptor_filename) | |
| all_module_descriptors[module_name] = module_descriptors[module_name] | |
| for module in module_descriptors.values(): | |
| for dep in module.get('dependencies', []): | |
| if dep not in all_module_descriptors: | |
| bail_error('Module "%s" (dependency of "%s") not listed in application descriptor %s' % | |
| (dep, module['name'], application_descriptor_filename)) | |
| return Descriptors(application_descriptor_name, self.application_dir, application_descriptor, module_descriptors, extends, | |
| has_html, worker) | |
| def _read_module_descriptor(self, module_name, application_descriptor_filename): | |
| json_filename = path.join(self.application_dir, module_name, 'module.json') | |
| if not path.exists(json_filename): | |
| bail_error('Module descriptor %s referenced in %s is missing' % (json_filename, application_descriptor_filename)) | |
| module_json = load_and_parse_json(json_filename) | |
| module_json['name'] = module_name | |
| return module_json |