Add closure_ts_archive rule

Author: pcj

rules/defs.bzl

@@ -1,3 +1,5 @@
 load("//rules/private:closure_ts_compile.bzl", _closure_ts_compile = "closure_ts_compile")
+load("//rules/private:closure_ts_archive.bzl", _closure_ts_archive = "closure_ts_archive")
 
 closure_ts_compile = _closure_ts_compile
+closure_ts_archive = _closure_ts_archive

rules/private/closure_ts_archive.bzl

@@ -0,0 +1,78 @@
+"""closure_ts_archive builds zip files of closure js sources"""
+
+load(":closure_ts_compile.bzl", "ClosureTsCompileInfo")
+
+def _get_zip_runfiles_path(path):
+    if path.startswith("../"):
+        parts = path.split("/")
+        path = "/".join(parts[2:])
+    return path
+
+def _zip_action(ctx):
+    srcs = ctx.files.srcs
+
+    transitive_outs = [dep[ClosureTsCompileInfo].transitive_outs for dep in ctx.attr.deps]
+    direct_outs = [dep[ClosureTsCompileInfo].direct_outs for dep in ctx.attr.deps]
+    if ctx.attr.transitive:
+        inputs = depset(srcs, transitive = transitive_outs)
+    else:
+        inputs = depset(srcs, transitive = direct_outs)
+
+    def map_zip_runfiles(file):
+        return "{}={}".format(
+            _get_zip_runfiles_path(file.short_path),
+            file.path,
+        )
+
+    manifest = ctx.actions.args()
+    manifest.use_param_file("@%s", use_always = True)
+    manifest.set_param_file_format("multiline")
+    manifest.add_all(inputs, map_each = map_zip_runfiles, allow_closure = True)
+
+    zip_cli_args = ctx.actions.args()
+    zip_cli_args.add("cC")
+    zip_cli_args.add(ctx.outputs.zip)
+
+    ctx.actions.run(
+        executable = ctx.executable._zipper,
+        arguments = [zip_cli_args, manifest],
+        inputs = inputs,
+        outputs = [ctx.outputs.zip],
+        use_default_shell_env = True,
+        mnemonic = "ClosureTsZip",
+        progress_message = "Building zip: %{label}",
+    )
+
+def _closure_ts_archive_impl(ctx):
+    _zip_action(ctx)
+
+    return [
+        DefaultInfo(
+            files = depset([ctx.outputs.zip]),
+        ),
+    ]
+
+closure_ts_archive = rule(
+    implementation = _closure_ts_archive_impl,
+    attrs = {
+        "srcs": attr.label_list(
+            doc = "additional sources to add to the archive",
+            allow_files = True,
+        ),
+        "deps": attr.label_list(
+            doc = "closure ts compile dependencies to archive",
+            providers = [ClosureTsCompileInfo],
+        ),
+        "transitive": attr.bool(
+            doc = "archive transitive dependencies into a single archive",
+        ),
+        "_zipper": attr.label(
+            cfg = "exec",
+            executable = True,
+            default = "@bazel_tools//tools/zip:zipper",
+        ),
+    },
+    outputs = {
+        "zip": "%{name}.js.zip",
+    },
+)

rules/private/closure_ts_compile.bzl

@@ -3,7 +3,10 @@
 load("@bazel_skylib//lib:paths.bzl", "paths")
 
 ClosureTsCompileInfo = provider(doc = "info about a closure ts compile rule", fields = {
-    "sources": "DepSet<File>: direct + transitive sources",
+    "direct_srcs": "DepSet<File>: direct sources",
+    "transitive_srcs": "DepSet<File>: transitive sources",
+    "direct_outs": "DepSet<File>: direct outputs",
+    "transitive_outs": "DepSet<File>: transitive outputs",
 })
 
 def _output_for_ts_input(ctx, src):
@@ -13,58 +16,54 @@ def _output_for_ts_input(ctx, src):
 def _output_for_externs(ctx):
     return ctx.actions.declare_file(ctx.label.name + ".externs.js")
 
-def _tsickle_action(ctx):
-    direct = ctx.files.srcs
-    transitive = [dep[ClosureTsCompileInfo].sources for dep in ctx.attr.deps]
+def _closure_ts_compile_impl(ctx):
+    direct_srcs = ctx.files.srcs
+    transitive_srcs = [dep[ClosureTsCompileInfo].transitive_srcs for dep in ctx.attr.deps]
+    transitive_outs = [dep[ClosureTsCompileInfo].transitive_outs for dep in ctx.attr.deps]
 
     args = ctx.actions.args()
-    args.add_all([src.short_path for src in direct])
+    args.add_all(direct_srcs)
 
     env = {
         "BAZEL_BINDIR": ctx.bin_dir.path,
-        "BAZEL_WORKSPACE": ctx.label.workspace_name,
         "BAZEL_PACKAGE": ctx.label.package,
     }
 
     direct_ts = []
     direct_dts = []
-    for src in direct:
+    for src in direct_srcs:
         if src.basename.endswith(".d.ts"):
             direct_dts.append(src)
         else:
             direct_ts.append(src)
 
-    outputs = [_output_for_ts_input(ctx, f) for f in direct_ts]
+    direct_outs = [_output_for_ts_input(ctx, f) for f in direct_ts]
     if len(direct_dts) > 0:
         externs_output = _output_for_externs(ctx)
-        outputs.append(externs_output)
-        env["EXTERNS_PATH"] = externs_output.short_path
+        direct_outs.append(externs_output)
+        env["EXTERNS_PATH"] = externs_output.short_path.replace("../", "external/")
 
-    inputs = depset(direct = direct, transitive = transitive)
+    all_srcs = depset(direct = direct_srcs, transitive = transitive_srcs)
+    all_outs = depset(direct = direct_outs, transitive = transitive_outs)
 
     ctx.actions.run(
         mnemonic = "TsickleCompile",
         executable = ctx.executable._compiler,
         arguments = [args],
-        inputs = inputs,
-        outputs = outputs,
+        inputs = all_srcs,
+        outputs = direct_outs,
         env = env,
     )
 
-    return struct(
-        inputs = inputs,
-        outputs = outputs,
-    )
-
-def _closure_ts_compile_impl(ctx):
-    result = _tsickle_action(ctx)
-
     return [
         DefaultInfo(
-            files = depset(result.outputs),
+            files = depset(direct_outs),
         ),
         ClosureTsCompileInfo(
-            sources = result.inputs,
+            direct_srcs = direct_srcs,
+            transitive_srcs = all_srcs,
+            direct_outs = depset(direct_outs),
+            transitive_outs = all_outs,
         ),
     ]