| # Copyright 2015 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. |
| |
| # Rules to generate zipped applications for Dart. |
| # Rules to generate dart-pkg and dart-pkg/packages. |
| |
| import("//build/module_args/mojo.gni") |
| import("//build/module_args/dart.gni") |
| |
| # Creates a dartzip package. |
| template("dartzip_package") { |
| package_target_name = "$target_name" |
| package_output = "$target_out_dir/$target_name.dartzip" |
| |
| if (defined(invoker.uses_pub) && invoker.uses_pub) { |
| # Repackage all dependencies pulled in via "pub get" in a dartzip file. |
| action("${package_target_name}_repackage") { |
| target_dir = get_label_info(":$target_name", "dir") |
| script = rebase_path("mojo/public/tools/gn/zip.py", ".", mojo_sdk_root) |
| |
| package_name = "$package_target_name" |
| if (defined(invoker.package_name_override)) { |
| package_name = invoker.package_name_override |
| } |
| |
| # Get a list of the files in packages/ as inputs. |
| list_packages_contents_script = |
| rebase_path("mojo/public/tools/dart_list_packages_contents.py", |
| ".", |
| mojo_sdk_root) |
| rebase_target_dir = rebase_path(target_dir, root_build_dir) |
| inputs = exec_script(list_packages_contents_script, |
| [ |
| "--target-directory", |
| rebase_target_dir, |
| "--package-name", |
| package_name, |
| ], |
| "list lines", |
| [ target_dir + "/pubspec.lock" ]) |
| |
| # Zip up all the pulled-in files relative to their location in the |
| # packages dir. |
| output = "$target_out_dir/$target_name.dartzip" |
| outputs = [ |
| output, |
| ] |
| rebase_base_dir = rebase_target_dir |
| rebase_inputs = rebase_path(inputs, root_build_dir) |
| rebase_output = rebase_path(output, root_build_dir) |
| args = [ |
| "--base-dir=$rebase_base_dir", |
| "--inputs=$rebase_inputs", |
| "--output=$rebase_output", |
| ] |
| } |
| } |
| |
| action("${package_target_name}_package") { |
| script = |
| rebase_path("mojo/public/tools/dart_package.py", ".", mojo_sdk_root) |
| |
| inputs = invoker.sources |
| |
| deps = [] |
| zip_inputs = [] |
| |
| if (defined(invoker.uses_pub) && invoker.uses_pub) { |
| deps += [ ":${package_target_name}_repackage" ] |
| } |
| |
| if (defined(invoker.deps)) { |
| deps += invoker.deps |
| foreach(d, deps) { |
| dep_name = get_label_info(d, "name") |
| dep_target_out_dir = get_label_info(d, "target_out_dir") |
| zip_inputs += [ "$dep_target_out_dir/$dep_name.dartzip" ] |
| } |
| } |
| |
| if (defined(invoker.datadeps)) { |
| datadeps = invoker.datadeps |
| } |
| |
| output = package_output |
| outputs = [ |
| output, |
| ] |
| |
| rebase_base_dir = |
| rebase_path(get_label_info(":$package_target_name", "dir"), |
| root_build_dir) |
| if (defined(invoker.base_dir)) { |
| rebase_base_dir = invoker.base_dir |
| } |
| rebase_inputs = rebase_path(inputs, root_build_dir) |
| rebase_zip_inputs = rebase_path(zip_inputs, root_build_dir) |
| rebase_output = rebase_path(output, root_build_dir) |
| |
| args = [ |
| "--base-dir=$rebase_base_dir", |
| "--inputs=$rebase_inputs", |
| "--zip-inputs=$rebase_zip_inputs", |
| "--output=$rebase_output", |
| ] |
| } |
| |
| action(target_name) { |
| script = |
| rebase_path("mojo/public/tools/dart_analyze.py", ".", mojo_sdk_root) |
| |
| sources = [ |
| package_output, |
| ] |
| |
| args = [ |
| "--dart-sdk", |
| rebase_path(dart_sdk_root), |
| "--dartzip-file", |
| rebase_path(package_output), |
| "--stamp-file", |
| rebase_path("$target_gen_dir/${package_target_name}_analyze.stamp"), |
| "--no-hints", |
| ] |
| |
| public_deps = [ |
| ":${package_target_name}_package", |
| ] |
| if (defined(invoker.deps)) { |
| deps = invoker.deps |
| } |
| |
| if (defined(invoker.datadeps)) { |
| datadeps = invoker.datadeps |
| } |
| |
| outputs = [ |
| "$target_gen_dir/${package_target_name}_analyze.stamp", |
| ] |
| } |
| } |
| |
| # Use this template to generate a .mojo dart application. One of the source |
| # files should be named main.dart and contain a main function as the |
| # entry point. Dependencies of dart_packaged_application targets should be |
| # either mojom targets (and specified using the mojom_deps variable) or |
| # dartzip_package targets. |
| template("dartzip_packaged_application") { |
| package_name = "${target_name}_package" |
| package_output = "$target_out_dir/$package_name.dartzip" |
| |
| if (defined(invoker.output_name)) { |
| mojo_output = "$root_out_dir/" + invoker.output_name + ".mojo" |
| } else { |
| mojo_output = "$root_out_dir/" + target_name + ".mojo" |
| } |
| |
| dartzip_package(package_name) { |
| sources = invoker.sources |
| if (defined(invoker.deps)) { |
| deps = invoker.deps |
| } |
| if (defined(invoker.uses_pub)) { |
| uses_pub = invoker.uses_pub |
| } |
| if (defined(invoker.mojom_deps)) { |
| mojom_deps = invoker.mojom_deps |
| } |
| if (defined(invoker.datadeps)) { |
| datadeps = invoker.datadeps |
| } |
| } |
| |
| action(target_name) { |
| script = rebase_path("mojo/public/tools/prepend.py", ".", mojo_sdk_root) |
| |
| input = package_output |
| inputs = [ |
| input, |
| ] |
| |
| output = mojo_output |
| outputs = [ |
| output, |
| ] |
| |
| deps = [ |
| ":$package_name", |
| ] |
| if (defined(invoker.deps)) { |
| deps += invoker.deps |
| } |
| if (defined(invoker.mojom_deps)) { |
| deps += invoker.mojom_deps |
| } |
| if (defined(invoker.datadeps)) { |
| datadeps = invoker.datadeps |
| } |
| |
| line = "#!mojo mojo:dart_content_handler" |
| if (is_debug || (defined(invoker.strict) && invoker.strict == true)) { |
| line = "#!mojo mojo:dart_content_handler?strict=true" |
| } |
| |
| rebase_input = rebase_path(input, root_build_dir) |
| rebase_output = rebase_path(output, root_build_dir) |
| args = [ |
| "--input=$rebase_input", |
| "--output=$rebase_output", |
| "--line=$line", |
| ] |
| } |
| } |
| |
| # Creates a gen/dart-pkg/package_name directory containing symlinks to package |
| # sources. Also copies any mojom dependencies into lib/mojom. |
| # |
| # sources |
| # List of non-entrypoint sources to include in the package. |
| # |
| # entrypoints (optional) |
| # List of package entrypoints to pass to the analyzer. If no entry points |
| # are defined, the analyzer is not run. |
| # |
| # pkg_dir (optional) |
| # Directory containing the package sources. This overrides sources and |
| # entrypoints. The analyzer will not be run. |
| # |
| # deps (optional) |
| # List of other dart_pkg targets for Dart packages imported by this |
| # dart_pkg, as well as the mojom targets needed by this dart_pkg. |
| # |
| # datadeps (optional) |
| # |
| # sdk_ext_directory (optional) |
| # Directory containing sdk-ext .dart sources. |
| # |
| # sdk_ext_files (optional) |
| # List of sources to include in sdk-ext. |
| # |
| # sdk_ext_mappings (optional) |
| # Mappings for dart libraries that are part of of sdk_ext. |
| # |
| template("dart_pkg") { |
| if (defined(invoker.pkg_dir)) { |
| pubspec_yaml_path = rebase_path("pubspec.yaml", "", invoker.pkg_dir) |
| } else { |
| pubspec_yaml_path = rebase_path("pubspec.yaml") |
| } |
| dart_package_name_script = |
| rebase_path("mojo/public/tools/dart_package_name.py", ".", mojo_sdk_root) |
| package_name = exec_script(dart_package_name_script, |
| [ |
| "--pubspec", |
| pubspec_yaml_path, |
| ], |
| "trim string", |
| [ pubspec_yaml_path ]) |
| |
| pkg_directory = rebase_path("$root_gen_dir/dart-pkg") |
| package_root = rebase_path("$root_gen_dir/dart-pkg/packages") |
| stamp_file = "$root_gen_dir/dart-pkg/${package_name}.stamp" |
| output_dir = "$root_gen_dir/dart-pkg/${package_name}" |
| |
| assert(defined(invoker.sources) || defined(invoker.pkg_dir)) |
| |
| action(target_name) { |
| deps = [] |
| if (defined(invoker.deps)) { |
| deps += invoker.deps |
| } |
| |
| datadeps = [] |
| if (defined(invoker.datadeps)) { |
| datadeps += invoker.datadeps |
| } |
| |
| list_mojoms_script = |
| rebase_path("mojo/public/tools/dart_list_mojoms.py", ".", mojo_sdk_root) |
| mojom_sources = [] |
| foreach(d, deps) { |
| root_prefix = rebase_path(".", "", mojo_sdk_root) |
| source_directory = rebase_path(get_label_info(d, "dir")) |
| mojom_sources += exec_script(list_mojoms_script, |
| [ |
| source_directory, |
| root_prefix, |
| ], |
| "list lines") |
| } |
| |
| sdk_ext_directory = [] |
| if (defined(invoker.sdk_ext_directory)) { |
| sdk_ext_directory += [ invoker.sdk_ext_directory ] |
| } |
| |
| sdk_ext_files = [] |
| if (defined(invoker.sdk_ext_files)) { |
| sdk_ext_files += invoker.sdk_ext_files |
| } |
| |
| sdk_ext_mappings = [] |
| if (defined(invoker.sdk_ext_mappings)) { |
| sdk_ext_mappings += invoker.sdk_ext_mappings |
| } |
| |
| script = rebase_path("mojo/public/tools/dart_pkg.py", ".", mojo_sdk_root) |
| outputs = [ |
| output_dir, |
| stamp_file, |
| ] |
| |
| entrypoints = [] |
| if (defined(invoker.entrypoints)) { |
| entrypoints += invoker.entrypoints |
| } |
| |
| sources = [] |
| if (defined(invoker.sources)) { |
| sources += invoker.sources |
| } else { |
| assert(defined(invoker.pkg_dir)) |
| list_script = rebase_path("build/ls.py", ".", mojo_sdk_root) |
| sources += exec_script(list_script, |
| [ |
| "--target-directory", |
| rebase_path(invoker.pkg_dir), |
| ], |
| "list lines") |
| } |
| |
| inputs = [ |
| list_mojoms_script, |
| script, |
| ] + rebase_path(sources) |
| |
| args = [ |
| "--package-name", |
| package_name, |
| "--dart-sdk", |
| rebase_path(dart_sdk_root), |
| "--gen-directory", |
| rebase_path("$root_gen_dir/dart-gen"), |
| "--pkg-directory", |
| pkg_directory, |
| "--package-root", |
| package_root, |
| "--stamp-file", |
| rebase_path(stamp_file), |
| "--package-sources", |
| ] + rebase_path(sources) + [ "--package-entrypoints" ] + |
| rebase_path(entrypoints) + [ "--mojom-sources" ] + |
| rebase_path(mojom_sources, "", mojo_sdk_root) + |
| [ "--sdk-ext-directories" ] + rebase_path(sdk_ext_directory) + |
| [ "--sdk-ext-files" ] + rebase_path(sdk_ext_files) + |
| [ "--sdk-ext-mappings" ] + sdk_ext_mappings |
| } |
| } |
