| #!/usr/bin/env python3 | |
| # | |
| # Copyright 2013 The Flutter Authors. All rights reserved. | |
| # Use of this source code is governed by a BSD-style license that can be | |
| # found in the LICENSE file. | |
| """Utility for dart_pkg and dart_pkg_app rules""" | |
| import argparse | |
| import errno | |
| import json | |
| import os | |
| import shutil | |
| import subprocess | |
| import sys | |
| USE_LINKS = sys.platform != 'win32' | |
| DART_ANALYZE = os.path.join( | |
| os.path.dirname(os.path.abspath(__file__)), 'dart_analyze.py' | |
| ) | |
| def dart_filter(path): | |
| if os.path.isdir(path): | |
| return True | |
| _, ext = os.path.splitext(path) | |
| # .dart includes '.mojom.dart' | |
| return ext == '.dart' | |
| def ensure_dir_exists(path): | |
| abspath = os.path.abspath(path) | |
| if not os.path.exists(abspath): | |
| os.makedirs(abspath) | |
| def has_pubspec_yaml(paths): | |
| for path in paths: | |
| _, filename = os.path.split(path) | |
| if filename == 'pubspec.yaml': | |
| return True | |
| return False | |
| def link(from_root, to_root): | |
| ensure_dir_exists(os.path.dirname(to_root)) | |
| try: | |
| os.unlink(to_root) | |
| except OSError as err: | |
| if err.errno == errno.ENOENT: | |
| pass | |
| try: | |
| os.symlink(from_root, to_root) | |
| except OSError as err: | |
| if err.errno == errno.EEXIST: | |
| pass | |
| def copy(from_root, to_root, filter_func=None): | |
| if not os.path.exists(from_root): | |
| return | |
| if os.path.isfile(from_root): | |
| ensure_dir_exists(os.path.dirname(to_root)) | |
| shutil.copy(from_root, to_root) | |
| return | |
| ensure_dir_exists(to_root) | |
| for root, dirs, files in os.walk(from_root): | |
| # filter_func expects paths not names, so wrap it to make them absolute. | |
| wrapped_filter = None | |
| if filter_func: | |
| wrapped_filter = lambda name, rt=root: filter_func(os.path.join(rt, name)) | |
| for name in filter(wrapped_filter, files): | |
| from_path = os.path.join(root, name) | |
| root_rel_path = os.path.relpath(from_path, from_root) | |
| to_path = os.path.join(to_root, root_rel_path) | |
| to_dir = os.path.dirname(to_path) | |
| if not os.path.exists(to_dir): | |
| os.makedirs(to_dir) | |
| shutil.copy(from_path, to_path) | |
| dirs[:] = list(filter(wrapped_filter, dirs)) | |
| def copy_or_link(from_root, to_root, filter_func=None): | |
| if USE_LINKS: | |
| link(from_root, to_root) | |
| else: | |
| copy(from_root, to_root, filter_func) | |
| def link_if_possible(from_root, to_root): | |
| if USE_LINKS: | |
| link(from_root, to_root) | |
| def remove_if_exists(path): | |
| try: | |
| os.remove(path) | |
| except OSError as err: | |
| if err.errno != errno.ENOENT: | |
| raise | |
| def list_files(from_root, filter_func=None): | |
| file_list = [] | |
| for root, dirs, files in os.walk(from_root): | |
| # filter_func expects paths not names, so wrap it to make them absolute. | |
| wrapped_filter = None | |
| if filter_func: | |
| wrapped_filter = lambda name, rt=root: filter_func(os.path.join(rt, name)) | |
| for name in filter(wrapped_filter, files): | |
| path = os.path.join(root, name) | |
| file_list.append(path) | |
| dirs[:] = list(filter(wrapped_filter, dirs)) | |
| return file_list | |
| def remove_broken_symlink(path): | |
| if not USE_LINKS: | |
| return | |
| try: | |
| link_path = os.readlink(path) | |
| except OSError as err: | |
| # Path was not a symlink. | |
| if err.errno == errno.EINVAL: | |
| pass | |
| else: | |
| if not os.path.exists(link_path): | |
| remove_if_exists(path) | |
| def remove_broken_symlinks(root_dir): | |
| if not USE_LINKS: | |
| return | |
| for current_dir, _, child_files in os.walk(root_dir): | |
| for filename in child_files: | |
| path = os.path.join(current_dir, filename) | |
| remove_broken_symlink(path) | |
| def analyze_entrypoints(dart_sdk, package_root, entrypoints): | |
| cmd = ['python', DART_ANALYZE] | |
| cmd.append('--dart-sdk') | |
| cmd.append(dart_sdk) | |
| cmd.append('--entrypoints') | |
| cmd.extend(entrypoints) | |
| cmd.append('--package-root') | |
| cmd.append(package_root) | |
| cmd.append('--no-hints') | |
| try: | |
| subprocess.check_output(cmd, stderr=subprocess.STDOUT) | |
| except subprocess.CalledProcessError as err: | |
| print('Failed analyzing %s' % entrypoints) | |
| print(err.output) | |
| return err.returncode | |
| return 0 | |
| def main(): | |
| parser = argparse.ArgumentParser(description='Generate a dart-pkg') | |
| parser.add_argument( | |
| '--dart-sdk', | |
| action='store', | |
| metavar='dart_sdk', | |
| help='Path to the Dart SDK.' | |
| ) | |
| parser.add_argument( | |
| '--package-name', | |
| action='store', | |
| metavar='package_name', | |
| help='Name of package', | |
| required=True | |
| ) | |
| parser.add_argument( | |
| '--pkg-directory', | |
| metavar='pkg_directory', | |
| help='Directory where dart_pkg should go', | |
| required=True | |
| ) | |
| parser.add_argument( | |
| '--package-root', | |
| metavar='package_root', | |
| help='packages/ directory', | |
| required=True | |
| ) | |
| parser.add_argument( | |
| '--stamp-file', | |
| metavar='stamp_file', | |
| help='timestamp file', | |
| required=True | |
| ) | |
| parser.add_argument( | |
| '--entries-file', | |
| metavar='entries_file', | |
| help='script entries file', | |
| required=True | |
| ) | |
| parser.add_argument( | |
| '--package-sources', | |
| metavar='package_sources', | |
| help='Package sources', | |
| nargs='+' | |
| ) | |
| parser.add_argument( | |
| '--package-entrypoints', | |
| metavar='package_entrypoints', | |
| help='Package entry points for analyzer', | |
| nargs='*', | |
| default=[] | |
| ) | |
| parser.add_argument( | |
| '--sdk-ext-directories', | |
| metavar='sdk_ext_directories', | |
| help='Directory containing .dart sources', | |
| nargs='*', | |
| default=[] | |
| ) | |
| parser.add_argument( | |
| '--sdk-ext-files', | |
| metavar='sdk_ext_files', | |
| help='List of .dart files that are part of sdk_ext.', | |
| nargs='*', | |
| default=[] | |
| ) | |
| parser.add_argument( | |
| '--sdk-ext-mappings', | |
| metavar='sdk_ext_mappings', | |
| help='Mappings for SDK extension libraries.', | |
| nargs='*', | |
| default=[] | |
| ) | |
| parser.add_argument( | |
| '--read_only', | |
| action='store_true', | |
| dest='read_only', | |
| help='Package is a read only package.', | |
| default=False | |
| ) | |
| args = parser.parse_args() | |
| # We must have a pubspec.yaml. | |
| assert has_pubspec_yaml(args.package_sources) | |
| target_dir = os.path.join(args.pkg_directory, args.package_name) | |
| target_packages_dir = os.path.join(target_dir, 'packages') | |
| lib_path = os.path.join(target_dir, 'lib') | |
| ensure_dir_exists(lib_path) | |
| mappings = {} | |
| for mapping in args.sdk_ext_mappings: | |
| library, path = mapping.split(',', 1) | |
| mappings[library] = '../sdk_ext/%s' % path | |
| sdkext_path = os.path.join(lib_path, '_sdkext') | |
| if mappings: | |
| with open(sdkext_path, 'w') as stream: | |
| json.dump( | |
| mappings, stream, sort_keys=True, indent=2, separators=(',', ': ') | |
| ) | |
| else: | |
| remove_if_exists(sdkext_path) | |
| # Copy or symlink package sources into pkg directory. | |
| common_source_prefix = os.path.dirname( | |
| os.path.commonprefix(args.package_sources) | |
| ) | |
| for source in args.package_sources: | |
| relative_source = os.path.relpath(source, common_source_prefix) | |
| target = os.path.join(target_dir, relative_source) | |
| copy_or_link(source, target) | |
| entrypoint_targets = [] | |
| for source in args.package_entrypoints: | |
| relative_source = os.path.relpath(source, common_source_prefix) | |
| target = os.path.join(target_dir, relative_source) | |
| copy_or_link(source, target) | |
| entrypoint_targets.append(target) | |
| # Copy sdk-ext sources into pkg directory | |
| sdk_ext_dir = os.path.join(target_dir, 'sdk_ext') | |
| for directory in args.sdk_ext_directories: | |
| sdk_ext_sources = list_files(directory, dart_filter) | |
| common_prefix = os.path.commonprefix(sdk_ext_sources) | |
| for source in sdk_ext_sources: | |
| relative_source = os.path.relpath(source, common_prefix) | |
| target = os.path.join(sdk_ext_dir, relative_source) | |
| copy_or_link(source, target) | |
| common_source_prefix = os.path.dirname( | |
| os.path.commonprefix(args.sdk_ext_files) | |
| ) | |
| for source in args.sdk_ext_files: | |
| relative_source = os.path.relpath(source, common_source_prefix) | |
| target = os.path.join(sdk_ext_dir, relative_source) | |
| copy_or_link(source, target) | |
| # Symlink packages/ | |
| package_path = os.path.join(args.package_root, args.package_name) | |
| copy_or_link(lib_path, package_path) | |
| # Link dart-pkg/$package/packages to dart-pkg/packages | |
| link_if_possible(args.package_root, target_packages_dir) | |
| # Remove any broken symlinks in target_dir and package root. | |
| remove_broken_symlinks(target_dir) | |
| remove_broken_symlinks(args.package_root) | |
| # If any entrypoints are defined, write them to disk so that the analyzer | |
| # test can find them. | |
| with open(args.entries_file, 'w') as file: | |
| for entrypoint in entrypoint_targets: | |
| file.write(entrypoint + '\n') | |
| # Write stamp file. | |
| with open(args.stamp_file, 'w'): | |
| pass | |
| return 0 | |
| if __name__ == '__main__': | |
| sys.exit(main()) |