"""Support for protocol buffers"""
load(
":private/haskell_impl.bzl",
_haskell_library_impl = "haskell_library_impl",
)
load("@bazel_skylib//lib:paths.bzl", "paths")
load(
"@io_tweag_rules_haskell//haskell:providers.bzl",
"HaskellInfo",
"HaskellLibraryInfo",
"HaskellProtobufInfo",
)
def _capitalize_first_letter(c):
"""Capitalize the first letter of the input. Unlike the built-in
`capitalize()` method, doesn't lower-case the other characters. This helps
mimic the behavior of `proto-lens-protoc`, which turns `Foo/Bar/BAZ.proto`
into `Foo/Bar/BAZ.hs` (rather than `Foo/Bar/Baz.hs`).
Args:
c: A non-empty string word.
Returns:
The input with the first letter upper-cased.
"""
return c[0].capitalize() + c[1:]
def _camel_case(comp):
"""Camel-case the input string, preserving any existing capital letters.
"""
# Split on both "-" and "_", matching the behavior of proto-lens-protoc.
# Be sure to ignore any empty segments from input with leading or trailing
# delimiters.
return "".join([
_capitalize_first_letter(c2)
for c1 in comp.split("_")
for c2 in c1.split("-")
if len(c2) > 0
])
def _proto_lens_output_file(path):
"""The output file from `proto-lens-protoc` when run on the given `path`.
"""
path = path[:-len(".proto")]
result = "/".join([_camel_case(p) for p in path.split("/")]) + ".hs"
return "Proto/" + result
def _proto_lens_fields_file(path):
"""The fields file from `proto-lens-protoc` when run on the given `path`.
"""
path = path[:-len(".proto")]
result = "/".join([_camel_case(p) for p in path.split("/")]) + "_Fields.hs"
return "Proto/" + result
def _proto_path(proto, proto_source_roots):
"""A path to the proto file which matches any import statements."""
proto_path = proto.path
for p in proto_source_roots:
if proto_path.startswith(p):
return paths.relativize(proto_path, p)
return paths.relativize(
proto_path,
paths.join(proto.root.path, proto.owner.workspace_root),
)
def _haskell_proto_aspect_impl(target, ctx):
pb = ctx.toolchains["@io_tweag_rules_haskell//protobuf:toolchain"].tools
args = ctx.actions.args()
src_prefix = paths.join(
ctx.label.workspace_root,
ctx.label.package,
)
args.add("--plugin=protoc-gen-haskell=" + pb.plugin.path)
hs_files = []
inputs = []
direct_proto_paths = [target.proto.proto_source_root]
transitive_proto_paths = target.proto.transitive_proto_path
args.add_all([
"-I{0}={1}".format(_proto_path(s, transitive_proto_paths), s.path)
for s in target.proto.transitive_sources.to_list()
])
inputs.extend(target.proto.transitive_sources.to_list())
for src in target.proto.direct_sources:
inputs.append(src)
# As with the native rules, require the .proto file to be in the same
# Bazel package as the proto_library rule. This allows us to put the
# output .hs file next to the input .proto file. Unfortunately Skylark
# doesn't let us check the package of the file directly, so instead we
# just look at its short_path and rely on the proto_library rule itself
# to check for consistency. We use the file's path rather than its
# dirname/basename in case it's in a subdirectory; for example, if the
# proto_library rule is in "foo/BUILD" but the .proto file is
# "foo/bar/baz.proto".
if not src.path.startswith(paths.join(src.root.path, src_prefix)):
fail("Mismatch between rule context " + str(ctx.label.package) +
" and source file " + src.short_path)
if src.basename[-6:] != ".proto":
fail("bad extension for proto file " + src)
args.add(src.path)
hs_files.append(ctx.actions.declare_file(
_proto_lens_output_file(
_proto_path(src, direct_proto_paths),
),
))
hs_files.append(ctx.actions.declare_file(
_proto_lens_fields_file(
_proto_path(src, direct_proto_paths),
),
))
args.add_all([
"--proto_path=" + target.proto.proto_source_root,
"--haskell_out=no-runtime:" + paths.join(
hs_files[0].root.path,
src_prefix,
),
])
ctx.actions.run(
inputs = depset([pb.protoc, pb.plugin] + inputs),
outputs = hs_files,
mnemonic = "HaskellProtoc",
executable = pb.protoc,
arguments = [args],
)
patched_attrs = {
"compiler_flags": [],
"src_strip_prefix": "",
"repl_interpreted": True,
"repl_ghci_args": [],
"version": "",
"linkstatic": False,
"_ghci_script": ctx.attr._ghci_script,
"_ghci_repl_wrapper": ctx.attr._ghci_repl_wrapper,
"hidden_modules": [],
"exports": {},
"name": "proto-autogen-" + ctx.rule.attr.name,
"srcs": hs_files,
"deps": ctx.rule.attr.deps +
ctx.toolchains["@io_tweag_rules_haskell//protobuf:toolchain"].deps,
"prebuilt_dependencies": ctx.toolchains["@io_tweag_rules_haskell//protobuf:toolchain"].prebuilt_deps,
"plugins": [],
"_cc_toolchain": ctx.attr._cc_toolchain,
}
patched_ctx = struct(
actions = ctx.actions,
attr = struct(**patched_attrs),
bin_dir = ctx.bin_dir,
disabled_features = ctx.rule.attr.features,
executable = struct(
_ls_modules = ctx.executable._ls_modules,
),
# Necessary for CC interop (see cc.bzl).
features = ctx.rule.attr.features,
file = ctx.file,
files = struct(
srcs = hs_files,
_cc_toolchain = ctx.files._cc_toolchain,
extra_srcs = depset(),
),
genfiles_dir = ctx.genfiles_dir,
label = ctx.label,
toolchains = ctx.toolchains,
var = ctx.var,
)
# TODO this pattern match is very brittle. Let's not do this. The
# order should match the order in the return value expression in
# haskell_library_impl().
[hs_info, cc_info, coverage_info, default_info, library_info] = _haskell_library_impl(patched_ctx)
return [
cc_info, # CcInfo
hs_info, # HaskellInfo
library_info, # HaskellLibraryInfo
# We can't return DefaultInfo here because target already provides that.
HaskellProtobufInfo(files = default_info.files),
]
_haskell_proto_aspect = aspect(
_haskell_proto_aspect_impl,
attr_aspects = ["deps"],
attrs = {
"_ghci_script": attr.label(
allow_single_file = True,
default = Label("@io_tweag_rules_haskell//haskell:assets/ghci_script"),
),
"_ghci_repl_wrapper": attr.label(
allow_single_file = True,
default = Label("@io_tweag_rules_haskell//haskell:private/ghci_repl_wrapper.sh"),
),
"_ls_modules": attr.label(
executable = True,
cfg = "host",
default = Label("@io_tweag_rules_haskell//haskell:ls_modules"),
),
"_cc_toolchain": attr.label(
default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
),
},
toolchains = [
"@io_tweag_rules_haskell//haskell:toolchain",
"@io_tweag_rules_haskell//protobuf:toolchain",
],
)
def _haskell_proto_library_impl(ctx):
dep = ctx.attr.deps[0] # FIXME
return [
dep[CcInfo],
dep[HaskellInfo],
dep[HaskellLibraryInfo],
DefaultInfo(files = dep[HaskellProtobufInfo].files),
]
haskell_proto_library = rule(
_haskell_proto_library_impl,
attrs = {
"deps": attr.label_list(
mandatory = True,
allow_files = False,
aspects = [_haskell_proto_aspect],
doc = "List of `proto_library` targets to use for generation.",
),
},
toolchains = [
"@io_tweag_rules_haskell//haskell:toolchain",
"@io_tweag_rules_haskell//protobuf:toolchain",
],
)
"""Generate Haskell library allowing to use protobuf definitions with help
of [`proto-lens`](https://github.com/google/proto-lens#readme).
Example:
```bzl
proto_library(
name = "foo_proto",
srcs = ["foo.proto"],
)
haskell_proto_library(
name = "foo_haskell_proto",
deps = [":foo_proto"],
)
```
`haskell_proto_library` targets require `haskell_proto_toolchain` to be
registered.
"""
def _protobuf_toolchain_impl(ctx):
if ctx.attr.prebuilt_deps:
print("""The attribute 'prebuilt_deps' has been deprecated,
use the 'deps' attribute instead.
""")
return [
platform_common.ToolchainInfo(
name = ctx.label.name,
tools = struct(
plugin = ctx.executable.plugin,
protoc = ctx.executable.protoc,
),
deps = ctx.attr.deps,
prebuilt_deps = ctx.attr.prebuilt_deps,
),
]
_protobuf_toolchain = rule(
_protobuf_toolchain_impl,
attrs = {
"protoc": attr.label(
executable = True,
cfg = "host",
allow_single_file = True,
mandatory = True,
doc = "protoc compiler",
),
"plugin": attr.label(
executable = True,
cfg = "host",
allow_single_file = True,
mandatory = True,
doc = "proto-lens-protoc plugin for protoc",
),
"deps": attr.label_list(
doc = "List of other Haskell libraries to be linked to protobuf libraries.",
),
"prebuilt_deps": attr.string_list(
doc = "Non-Bazel supplied Cabal dependencies for protobuf libraries.",
),
},
)
def haskell_proto_toolchain(
name,
plugin,
deps = [],
prebuilt_deps = [],
protoc = Label("@com_google_protobuf//:protoc"),
**kwargs):
"""Declare a Haskell protobuf toolchain.
You need at least one of these declared somewhere in your `BUILD` files
for the `haskell_proto_library` rules to work. Once declared, you then
need to *register* the toolchain using `register_toolchains` in your
`WORKSPACE` file (see example below).
Example:
In a `BUILD` file:
```bzl
haskell_proto_toolchain(
name = "protobuf-toolchain",
protoc = "@com_google_protobuf//:protoc",
plugin = "@hackage-proto-lens-protoc//:bin/proto-lens-protoc",
prebuilt_deps = [
"base",
"bytestring",
"containers",
"data-default-class",
"lens-family",
"lens-labels",
"proto-lens",
"text",
],
)
```
The `prebuilt_deps` and `deps` arguments allow to specify Haskell
libraries to use to compile the auto-generated source files.
In `WORKSPACE` you could have something like this:
```bzl
http_archive(
name = "com_google_protobuf",
sha256 = "cef7f1b5a7c5fba672bec2a319246e8feba471f04dcebfe362d55930ee7c1c30",
strip_prefix = "protobuf-3.5.0",
urls = ["https://github.com/google/protobuf/archive/v3.5.0.zip"],
)
nixpkgs_package(
name = "protoc_gen_haskell",
repository = "@nixpkgs",
attribute_path = "haskell.packages.ghc822.proto-lens-protoc
)
register_toolchains(
"//tests:ghc", # assuming you called your Haskell toolchain "ghc"
"//tests:protobuf-toolchain",
)
```
"""
impl_name = name + "-impl"
_protobuf_toolchain(
name = impl_name,
plugin = plugin,
deps = deps,
prebuilt_deps = prebuilt_deps,
protoc = protoc,
visibility = ["//visibility:public"],
**kwargs
)
native.toolchain(
name = name,
toolchain_type = "@io_tweag_rules_haskell//protobuf:toolchain",
toolchain = ":" + impl_name,
exec_compatible_with = [
"@bazel_tools//platforms:x86_64",
],
)
