| load(":coverage.bzl", "coverage_java_test") |
| load(":functions.bzl", "create_java_compiler_args_srcs", "create_option_file", "explicit_target", "label_workspace_path", "workspace_path") |
| load(":groovy.bzl", "groovy_impl") |
| load(":kotlin.bzl", "kotlin_impl") |
| load(":utils.bzl", "fileset", "java_jarjar", "singlejar") |
| |
| # This is a custom implementation of label "tags". |
| # A label of the form: |
| # "//package/directory:rule[tag1, tag2]" |
| # Gets split up into a tuple containing the label, and the array of tags: |
| # ("//package/directory:rule", ["tag1", "tag2"]) |
| # Returns the split up tuple. |
| def _get_label_and_tags(label): |
| if not label.endswith("]"): |
| return label, [] |
| rfind = label.rfind("[") |
| if rfind == -1: |
| print("Malformed tagged label: " + label) |
| return label, [] |
| return label[:rfind], [tag.strip() for tag in label[rfind + 1:-1].split(",")] |
| |
| # Returns the paths of the given files relative to any of the roots. Were |
| # files is a list of File objects, and roots is a list strings represnting |
| # paths of directories relative to the package |
| # If a file is not found to be inside any of the given roots, it is ignored. |
| def relative_paths(ctx, files, roots): |
| package_prefixes = ctx.attr.package_prefixes |
| translated_package_prefixes = {root: prefix.replace(".", "/") for (root, prefix) in package_prefixes.items()} |
| |
| paths = [] |
| for file in files: |
| for root in roots: |
| path = label_workspace_path(ctx.label) + "/" + root |
| if file.path.startswith(path): |
| relpath = file.path[len(path) + 1:] |
| if root in translated_package_prefixes: |
| relpath = translated_package_prefixes[root] + "/" + relpath |
| paths.append((relpath, file)) |
| return paths |
| |
| def resources_impl(ctx, name, roots, resources, resources_jar): |
| zipper_args = ["c", resources_jar.path] |
| zipper_files = "".join([k + "=" + v.path + "\n" for k, v in relative_paths(ctx, resources, roots)]) |
| zipper_list = create_option_file(ctx, name + ".res.lst", zipper_files) |
| zipper_args += ["@" + zipper_list.path] |
| ctx.action( |
| inputs = resources + [zipper_list], |
| outputs = [resources_jar], |
| executable = ctx.executable._zipper, |
| arguments = zipper_args, |
| progress_message = "Creating zip...", |
| mnemonic = "zipper", |
| ) |
| |
| def accumulate_provider(provider, deps, runtime, compile_time): |
| deps += [provider] |
| runtime += provider.transitive_runtime_jars |
| compile_time += provider.full_compile_jars |
| return deps, runtime, compile_time |
| |
| def _iml_module_jar_impl( |
| ctx, |
| name, |
| roots, |
| java_srcs, |
| kotlin_srcs, |
| groovy_srcs, |
| form_srcs, |
| resources, |
| output_jar, |
| java_deps, |
| form_deps, |
| exports, |
| friends, |
| transitive_compile_time_jars, |
| transitive_runtime_jars): |
| jars = [] |
| sourcepath = [] |
| forms = [] |
| |
| java_jar = ctx.actions.declare_file(name + ".java.jar") if java_srcs else None |
| kotlin_jar = ctx.actions.declare_file(name + ".kotlin.jar") if kotlin_srcs else None |
| groovy_jar = ctx.actions.declare_file(name + ".groovy.jar") if groovy_srcs else None |
| |
| # Groovy |
| if groovy_srcs: |
| groovy_deps = [java_jar] if java_jar else [] |
| groovy_deps += [kotlin_jar] if kotlin_jar else [] |
| groovy_deps += list(transitive_runtime_jars) |
| stub_jar = ctx.actions.declare_file(name + ".groovy_stubs.src.jar") |
| groovy_impl(ctx, roots, groovy_srcs, groovy_deps, transitive_runtime_jars, groovy_jar, stub_jar) |
| sourcepath += [stub_jar] |
| jars += [groovy_jar] |
| |
| # Kotlin |
| kotlin_providers = [] |
| if kotlin_srcs: |
| kotlin_providers += [kotlin_impl( |
| ctx, |
| name, |
| roots, |
| java_srcs, |
| kotlin_srcs, |
| transitive_compile_time_jars, |
| ctx.attr.package_prefixes, |
| kotlin_jar, |
| friends, |
| )] |
| |
| jars += [kotlin_jar] |
| |
| # Java |
| if java_srcs: |
| compiled_java = ctx.actions.declare_file(name + ".pjava.jar") if form_srcs else java_jar |
| formc_input_jars = [compiled_java] + ([kotlin_jar] if kotlin_jar else []) |
| |
| java_provider = java_common.compile( |
| ctx, |
| source_files = java_srcs, |
| output = compiled_java, |
| deps = java_deps + kotlin_providers, |
| javac_opts = java_common.default_javac_opts(ctx, java_toolchain_attr = "_java_toolchain"), |
| java_toolchain = ctx.attr._java_toolchain, |
| host_javabase = ctx.attr._host_javabase, |
| sourcepath = sourcepath, |
| ) |
| |
| # Forms |
| if form_srcs: |
| forms += relative_paths(ctx, form_srcs, roots) |
| args, option_files = create_java_compiler_args_srcs( |
| ctx, |
| [form.path for form in form_srcs] + [k + "=" + v.path for k, v in form_deps] + [f.path for f in formc_input_jars], |
| java_jar, |
| transitive_runtime_jars, |
| ) |
| ctx.action( |
| inputs = [v for _, v in form_deps] + form_srcs + formc_input_jars + option_files + transitive_runtime_jars.to_list(), |
| outputs = [java_jar], |
| mnemonic = "formc", |
| arguments = args, |
| executable = ctx.executable._formc, |
| ) |
| |
| jars += [java_jar] |
| |
| if form_srcs and not java_srcs: |
| fail("Forms only supported with java sources") |
| |
| # Resources |
| if resources: |
| resources_jar = ctx.actions.declare_file(name + ".res.jar") |
| resources_impl(ctx, name, roots, resources, resources_jar) |
| jars += [resources_jar] |
| |
| ctx.action( |
| inputs = jars, |
| outputs = [output_jar], |
| mnemonic = "module", |
| arguments = [output_jar.path] + [jar.path for jar in jars], |
| executable = ctx.executable._singlejar, |
| ) |
| |
| providers = [] |
| providers += [java_common.create_provider( |
| compile_time_jars = [output_jar], |
| runtime_jars = [output_jar], |
| transitive_compile_time_jars = [output_jar] + list(transitive_compile_time_jars), |
| transitive_runtime_jars = [output_jar] + list(transitive_runtime_jars), |
| use_ijar = False, |
| )] |
| providers += exports |
| |
| return java_common.merge(providers), forms |
| |
| def _iml_module_impl(ctx): |
| names = [iml.basename[:-4] for iml in ctx.files.iml_files if iml.basename.endswith(".iml")] |
| |
| transitive_data = depset() |
| java_deps = [] |
| form_deps = [] |
| |
| transitive_runtime_jars = depset(order = "preorder") |
| transitive_compile_time_jars = depset(order = "preorder") |
| |
| for this_dep in ctx.attr.deps: |
| if hasattr(this_dep, "module"): |
| transitive_data += this_dep.module.transitive_data |
| form_deps += this_dep.module.forms |
| if java_common.provider in this_dep: |
| java_deps, transitive_runtime_jars, transitive_compile_time_jars = accumulate_provider( |
| this_dep[java_common.provider], |
| java_deps, |
| transitive_runtime_jars, |
| transitive_compile_time_jars, |
| ) |
| |
| test_java_deps = [] |
| test_form_deps = [] |
| transitive_test_runtime_jars = depset([ctx.outputs.production_jar], order = "preorder") |
| transitive_test_compile_time_jars = depset([ctx.outputs.production_jar], order = "preorder") |
| |
| for this_dep in ctx.attr.test_deps: |
| if java_common.provider in this_dep: |
| test_java_deps, transitive_test_runtime_jars, transitive_test_compile_time_jars = accumulate_provider( |
| this_dep[java_common.provider], |
| test_java_deps, |
| transitive_test_runtime_jars, |
| transitive_test_compile_time_jars, |
| ) |
| if hasattr(this_dep, "module"): |
| transitive_data += this_dep.module.transitive_data |
| test_form_deps += this_dep.module.test_forms |
| test_java_deps, transitive_test_runtime_jars, transitive_test_compile_time_jars = accumulate_provider( |
| this_dep.module.test_provider, |
| test_java_deps, |
| transitive_test_runtime_jars, |
| transitive_test_compile_time_jars, |
| ) |
| |
| exports = [] |
| test_exports = [] |
| for export in ctx.attr.exports: |
| if java_common.provider in export: |
| exports += [export[java_common.provider]] |
| if hasattr(export, "module"): |
| test_exports += [export.module.test_provider] |
| |
| module_jars = ctx.outputs.production_jar |
| module_runtime = transitive_runtime_jars |
| |
| transitive_data += depset(ctx.files.iml_files + ctx.files.data) |
| |
| main_provider, main_forms = _iml_module_jar_impl( |
| ctx, |
| ctx.label.name, |
| ctx.attr.roots, |
| ctx.files.java_srcs, |
| ctx.files.kotlin_srcs, |
| ctx.files.groovy_srcs, |
| ctx.files.form_srcs, |
| ctx.files.resources, |
| ctx.outputs.production_jar, |
| java_deps, |
| form_deps, |
| exports, |
| [], |
| transitive_compile_time_jars, |
| transitive_runtime_jars, |
| ) |
| |
| test_provider, test_forms = _iml_module_jar_impl( |
| ctx, |
| ctx.label.name + "_test", |
| ctx.attr.test_roots, |
| ctx.files.java_test_srcs, |
| ctx.files.kotlin_test_srcs, |
| ctx.files.groovy_test_srcs, |
| ctx.files.form_test_srcs, |
| ctx.files.test_resources, |
| ctx.outputs.test_jar, |
| [main_provider] + test_java_deps, |
| test_form_deps, |
| exports + test_exports, |
| [ctx.outputs.production_jar], |
| transitive_test_compile_time_jars, |
| transitive_test_runtime_jars, |
| ) |
| |
| return struct( |
| module = struct( |
| module_jars = module_jars, |
| module_runtime = module_runtime, |
| transitive_data = transitive_data, |
| forms = main_forms, |
| test_forms = test_forms, |
| java_deps = java_deps, |
| test_provider = test_provider, |
| main_provider = main_provider, |
| names = names, |
| ), |
| providers = [main_provider], |
| ) |
| |
| _iml_module_ = rule( |
| attrs = { |
| "iml_files": attr.label_list( |
| allow_files = True, |
| allow_empty = False, |
| mandatory = True, |
| ), |
| "java_srcs": attr.label_list(allow_files = True), |
| "kotlin_srcs": attr.label_list(allow_files = True), |
| "groovy_srcs": attr.label_list(allow_files = True), |
| "form_srcs": attr.label_list(allow_files = True), |
| "java_test_srcs": attr.label_list(allow_files = True), |
| "kotlin_test_srcs": attr.label_list(allow_files = True), |
| "groovy_test_srcs": attr.label_list(allow_files = True), |
| "form_test_srcs": attr.label_list(allow_files = True), |
| "javacopts": attr.string_list(), |
| "resources": attr.label_list(allow_files = True), |
| "test_resources": attr.label_list(allow_files = True), |
| "package_prefixes": attr.string_dict(), |
| "test_class": attr.string(), |
| "exports": attr.label_list(), |
| "roots": attr.string_list(), |
| "test_roots": attr.string_list(), |
| "deps": attr.label_list(), |
| "test_deps": attr.label_list(), |
| "data": attr.label_list(allow_files = True), |
| "test_data": attr.label_list(allow_files = True), |
| "_java_toolchain": attr.label(default = Label("@bazel_tools//tools/jdk:current_java_toolchain")), |
| "_host_javabase": attr.label(default = Label("@bazel_tools//tools/jdk:current_host_java_runtime")), |
| "_zipper": attr.label( |
| default = Label("@bazel_tools//tools/zip:zipper"), |
| cfg = "host", |
| executable = True, |
| ), |
| "_singlejar": attr.label( |
| default = Label("//tools/base/bazel:singlejar"), |
| cfg = "host", |
| executable = True, |
| ), |
| "_kotlinc": attr.label( |
| default = Label("//tools/base/bazel:kotlinc"), |
| cfg = "host", |
| executable = True, |
| ), |
| "_bootclasspath": attr.label( |
| default = Label("//prebuilts/studio/jdk:bootclasspath"), |
| cfg = "host", |
| ), |
| "_kotlin": attr.label( |
| default = Label("//prebuilts/tools/common/kotlin-plugin-ij:Kotlin/kotlinc/lib/kotlin-stdlib"), |
| allow_files = True, |
| ), |
| "_groovyc": attr.label( |
| default = Label("//tools/base/bazel:groovyc"), |
| cfg = "host", |
| executable = True, |
| ), |
| "_groovystub": attr.label( |
| default = Label("//tools/base/bazel:groovy_stub_gen"), |
| cfg = "host", |
| executable = True, |
| ), |
| "_formc": attr.label( |
| executable = True, |
| cfg = "host", |
| default = Label("//tools/base/bazel:formc"), |
| allow_files = True, |
| ), |
| }, |
| fragments = ["java"], |
| outputs = { |
| "production_jar": "%{name}.jar", |
| "test_jar": "%{name}_test.jar", |
| }, |
| implementation = _iml_module_impl, |
| ) |
| |
| def _iml_runtime_impl(ctx): |
| providers = [ctx.attr.iml_module.module.main_provider] |
| module_runtime = depset() |
| transitive_data = depset() |
| names = [] |
| module_jars = None |
| |
| for dep in ctx.attr.runtime_deps: |
| if java_common.provider in dep: |
| providers += [dep[java_common.provider]] |
| if hasattr(dep, "runtime_info"): |
| fail("runtime should not depend on runtime") |
| if hasattr(dep, "module"): |
| module_runtime += dep.module.module_runtime |
| module_jars = dep.module.module_jars |
| transitive_data += dep.module.transitive_data |
| names = dep.module.names |
| |
| combined_provider = java_common.merge(providers) |
| |
| # for name in ctx.attr.iml_module.module.names: |
| module_runtime += combined_provider.transitive_runtime_jars |
| |
| return struct( |
| providers = [combined_provider], |
| runtime_info = struct( |
| module_runtime = module_runtime, |
| module_jars = module_jars, |
| transitive_data = transitive_data, |
| names = names, |
| ), |
| ) |
| |
| _iml_runtime = rule( |
| attrs = { |
| "iml_module": attr.label(), |
| "runtime_deps": attr.label_list(), |
| }, |
| fragments = ["java"], |
| implementation = _iml_runtime_impl, |
| ) |
| |
| def _iml_test_module_impl(ctx): |
| providers = [ctx.attr.iml_module.module.test_provider] |
| for dep in ctx.attr.runtime_deps: |
| if java_common.provider in dep: |
| providers += [dep[java_common.provider]] |
| if hasattr(dep, "module"): |
| providers += [dep.module.test_provider] |
| combined = java_common.merge(providers) |
| return struct( |
| providers = [combined], |
| ) |
| |
| _iml_test_module_ = rule( |
| attrs = { |
| "iml_module": attr.label(), |
| "runtime_deps": attr.label_list(), |
| }, |
| fragments = ["java"], |
| implementation = _iml_test_module_impl, |
| ) |
| |
| # Macro implementation of an iml_module "rule". |
| # This rule corresponds to the building artifacts needed to build an IntelliJ module. |
| # Instantiating this rule looks similar to an .iml definition: |
| # |
| # iml_module( |
| # # The name of the module used to generate the rules |
| # name = "module_name", |
| # # A list of directories containing the sources (.iml use directories as oposed to files) |
| # srcs = ["src/main/java"], |
| # # The directories with the test sources. |
| # test_srcs = ["src/test/java"], |
| # # The directories with the production resources |
| # resources = ["src/main/resources"] |
| # # The directories with the test resources |
| # test_resources = ["src/test/resources"], |
| # # A tag enhanced list of dependency tags. These dependencies can contain a |
| # # list of tags after the label. The supported tags are: |
| # # module: It treats the dependency as a module dependency, making |
| # # production and test sources depend on each other correctly. |
| # # test: This dependency is included and available for test sources only. |
| # deps = [ |
| # "//path/to/module:name[module]", |
| # "//path/to/libs:junit-4.12[test]", |
| # "//a/module/only/needed/in/tests:name[module, test]", |
| # "//a/standard/java/dependency:dep", |
| # ], |
| # ) |
| # |
| # This macro generates the following rules visible to the user: |
| # |
| # "module_name": A Java library compiled from the production sources |
| # "module_name_testlib": A Java library compiled from the test sources |
| # "module_name_tests": A java test rule that runs the tests found in "libmodule_name_testlib.jar" |
| def iml_module( |
| name, |
| srcs = [], |
| package_prefixes = {}, |
| test_srcs = [], |
| exclude = [], |
| resources = [], |
| res_zips = [], |
| test_resources = [], |
| deps = [], |
| runtime_deps = [], |
| test_runtime_deps = [], |
| manual_test_runtime_deps = [], |
| visibility = [], |
| exports = [], |
| plugins = [], |
| javacopts = [], |
| test_data = [], |
| test_timeout = "moderate", |
| test_class = "com.android.testutils.JarTestSuite", |
| test_shard_count = None, |
| tags = None, |
| test_tags = None, |
| back_target = 0, |
| iml_files = None, |
| bundle_data = [], |
| test_main_class = None, |
| back_deps = []): |
| if name == "intellij.groovy": |
| test_srcs = [] # workaround for b/111900968 |
| |
| prod_deps = [] |
| test_deps = [] |
| for dep in deps: |
| label, label_tags = _get_label_and_tags(dep) |
| if "test" not in label_tags: |
| prod_deps += [label] |
| test_deps += [label] |
| |
| srcs = split_srcs(srcs, resources, exclude) |
| split_test_srcs = split_srcs(test_srcs, test_resources, exclude) |
| _iml_module_( |
| name = name, |
| tags = tags, |
| visibility = visibility, |
| java_srcs = srcs.javas, |
| kotlin_srcs = srcs.kotlins, |
| groovy_srcs = srcs.groovies, |
| form_srcs = srcs.forms, |
| resources = srcs.resources, |
| roots = srcs.roots, |
| java_test_srcs = split_test_srcs.javas, |
| kotlin_test_srcs = split_test_srcs.kotlins, |
| groovy_test_srcs = split_test_srcs.groovies, |
| form_test_srcs = split_test_srcs.forms, |
| test_resources = split_test_srcs.resources, |
| test_roots = split_test_srcs.roots, |
| package_prefixes = package_prefixes, |
| javacopts = javacopts, |
| iml_files = iml_files, |
| exports = exports, |
| deps = prod_deps + ["//tools/base/bazel:langtools"], |
| test_deps = test_deps + ["//tools/base/bazel:langtools"], |
| data = bundle_data, |
| test_data = test_data, |
| test_class = test_class, |
| ) |
| |
| _iml_runtime( |
| name = name + "_runtime", |
| tags = tags, |
| iml_module = ":" + name, |
| runtime_deps = runtime_deps + [":" + name], |
| visibility = visibility, |
| ) |
| |
| # Only add test utils to other than itself. |
| test_utils = [] if name == "studio.testutils" else ["//tools/base/testutils:studio.android.sdktools.testutils"] |
| _iml_test_module_( |
| name = name + "_testlib", |
| tags = tags, |
| iml_module = ":" + name, |
| testonly = True, |
| visibility = visibility, |
| runtime_deps = runtime_deps + test_runtime_deps + [ |
| ":" + name + "_runtime", |
| "//tools/base/bazel:langtools", |
| ] + test_utils, |
| ) |
| |
| test_tags = tags + test_tags if tags and test_tags else (tags if tags else test_tags) |
| if test_srcs: |
| coverage_java_test( |
| name = name + "_tests", |
| tags = test_tags, |
| runtime_deps = manual_test_runtime_deps + [":" + name + "_testlib"], |
| timeout = test_timeout, |
| shard_count = test_shard_count, |
| data = test_data, |
| jvm_flags = ["-Dtest.suite.jar=" + name + "_test.jar"], |
| test_class = test_class, |
| visibility = visibility, |
| main_class = test_main_class, |
| ) |
| |
| def split_srcs(src_dirs, res_dirs, exclude): |
| roots = src_dirs + res_dirs |
| exts = ["java", "kt", "groovy", "DS_Store", "form", "flex"] |
| excludes = [] |
| for root in roots: |
| excludes += [root + "/**/*." + ext for ext in exts] |
| |
| resources = native.glob( |
| include = [src + "/**" for src in roots], |
| exclude = excludes, |
| ) |
| javas = native.glob([src + "/**/*.java" for src in src_dirs], exclude) |
| kotlins = native.glob([src + "/**/*.kt" for src in src_dirs], exclude) |
| groovies = native.glob([src + "/**/*.groovy" for src in src_dirs], exclude) |
| forms = native.glob([src + "/**/*.form" for src in src_dirs], exclude) |
| return struct( |
| roots = roots, |
| resources = resources, |
| javas = javas, |
| kotlins = kotlins, |
| groovies = groovies, |
| forms = forms, |
| ) |
| |
| def _iml_project_impl(ctx): |
| imls = [] |
| deps = [] |
| inputs = [] |
| |
| module_jars = dict() |
| module_runtime = dict() |
| transitive_data = depset() |
| |
| for dep in ctx.attr.modules: |
| if hasattr(dep, "runtime_info"): |
| for name in dep.runtime_info.names: |
| module_runtime[name] = dep.runtime_info.module_runtime |
| module_jars[name] = dep.runtime_info.module_jars |
| transitive_data += dep.runtime_info.transitive_data |
| if hasattr(dep, "module"): |
| fail("Don't depend on modules directly: " + str(dep.label)) |
| |
| for dep in ctx.attr.libraries + ctx.attr.modules: |
| if java_common.provider in dep: |
| transitive_data += dep[java_common.provider].transitive_runtime_jars |
| |
| text = "" |
| transitive_data += module_jars.values() |
| for name, files in module_runtime.items(): |
| transitive_data += files |
| text += name + ": " + module_jars[name].path |
| for file in files: |
| text += ":" + file.path |
| text += "\n" |
| |
| module_info = ctx.new_file(ctx.label.name + ".module_info") |
| ctx.file_action( |
| output = module_info, |
| content = text, |
| ) |
| |
| artifacts = "" |
| for dep in ctx.attr.artifacts: |
| artifacts += dep.label.name + ": " + dep.artifact.path + "\n" |
| artifact_info = ctx.new_file(ctx.label.name + ".artifact_info") |
| ctx.file_action( |
| output = artifact_info, |
| content = artifacts, |
| ) |
| |
| outs = [ctx.outputs.win, ctx.outputs.win32, ctx.outputs.mac, ctx.outputs.linux, ctx.outputs.output] |
| |
| args = [ |
| "--win", |
| ctx.outputs.win.path, |
| "--win32", |
| ctx.outputs.win32.path, |
| "--mac", |
| ctx.outputs.mac.path, |
| "--linux", |
| ctx.outputs.linux.path, |
| "--bin_dir", |
| ctx.var["BINDIR"], |
| "--gen_dir", |
| ctx.var["GENDIR"], |
| "--build", |
| ctx.file.build.path, |
| "--tmp", |
| module_info.path + ".tmp", |
| "--out", |
| ctx.outputs.output.path, |
| "--module_info", |
| module_info.path, |
| "--artifact_info", |
| artifact_info.path, |
| ] |
| |
| ctx.action( |
| mnemonic = "Ant", |
| inputs = [ctx.file.build, module_info, artifact_info] + ctx.files.data + ctx.files.artifacts + list(transitive_data), |
| outputs = outs, |
| executable = ctx.executable.ant, |
| # We cannot enable this yet, because Mac's sandbox throws an error |
| # execution_requirements = { "block-network" : "1" }, |
| arguments = args, |
| ) |
| |
| _iml_project = rule( |
| attrs = { |
| "modules": attr.label_list( |
| non_empty = True, |
| ), |
| "artifacts": attr.label_list( |
| ), |
| "libraries": attr.label_list( |
| ), |
| "data": attr.label_list( |
| allow_files = True, |
| ), |
| "deps": attr.label_list( |
| ), |
| "ant": attr.label( |
| executable = True, |
| cfg = "host", |
| ), |
| "build": attr.label( |
| allow_files = True, |
| single_file = True, |
| ), |
| }, |
| outputs = { |
| "win": "%{name}.win.zip", |
| "win32": "%{name}.win32.zip", |
| "mac": "%{name}.mac.zip", |
| "linux": "%{name}.tar.gz", |
| "output": "%{name}.log", |
| }, |
| implementation = _iml_project_impl, |
| ) |
| |
| def normalize_label(label): |
| if ":" not in label: |
| label = label + ":" + label[label.rfind("/") + 1:] |
| return label |
| |
| def iml_project(name, modules = [], **kwargs): |
| normalized_modules = [normalize_label(module) for module in modules] |
| _iml_project( |
| name = name, |
| testonly = True, # since "_testlib" entries are added programmatically to modules list here |
| modules = [n + "_runtime" for n in normalized_modules] + [n + "_testlib" for n in normalized_modules], |
| **kwargs |
| ) |
| |
| def _iml_artifact_impl(ctx): |
| jars = [] |
| |
| if ctx.files.files: |
| files_jar = ctx.actions.declare_file(ctx.label.name + ".files.jar") |
| |
| zipper_args = ["c", files_jar.path] |
| zipper_files = "".join([d + "/" + f.basename + "=" + f.path + "\n" for d, f in zip(ctx.attr.dirs, ctx.files.files)]) |
| zipper_list = create_option_file(ctx, ctx.label.name + ".files.lst", zipper_files) |
| zipper_args += ["@" + zipper_list.path] |
| ctx.action( |
| inputs = ctx.files.files + [zipper_list], |
| outputs = [files_jar], |
| executable = ctx.executable._zipper, |
| arguments = zipper_args, |
| progress_message = "Creating files artifact jar...", |
| mnemonic = "zipper", |
| ) |
| jars += [files_jar] |
| for module in ctx.attr.modules: |
| if java_common.provider in module: |
| jars += list(module[java_common.provider].compile_jars) |
| |
| ctx.action( |
| inputs = jars, |
| outputs = [ctx.outputs.artifact], |
| mnemonic = "artifact", |
| arguments = [ctx.outputs.artifact.path] + [jar.path for jar in jars], |
| executable = ctx.executable._singlejar, |
| ) |
| return struct(artifact = ctx.outputs.artifact) |
| |
| _iml_artifact = rule( |
| attrs = { |
| "dirs": attr.string_list(), |
| "files": attr.label_list(allow_files = True), |
| "modules": attr.label_list(), |
| "_zipper": attr.label( |
| default = Label("@bazel_tools//tools/zip:zipper"), |
| cfg = "host", |
| executable = True, |
| ), |
| "_singlejar": attr.label( |
| default = Label("//tools/base/bazel:singlejar"), |
| cfg = "host", |
| executable = True, |
| ), |
| }, |
| outputs = { |
| "artifact": "%{name}.jar", |
| }, |
| implementation = _iml_artifact_impl, |
| ) |
| |
| def iml_artifact(name, dirs = {}, modules = [], **kwargs): |
| # Reverse the map so we can use a label to string dict |
| files = dict() |
| for d, fs in dirs.items(): |
| for f in fs: |
| files[f] = d |
| |
| dir_list = [] |
| file_list = [] |
| for d, fs in dirs.items(): |
| for f in fs: |
| dir_list += [d] |
| file_list += [f] |
| |
| _iml_artifact( |
| name = name, |
| dirs = dir_list, |
| files = file_list, |
| modules = modules, |
| **kwargs |
| ) |
