From ab437f2bb2100360f8d119530b0a020228baa4cc Mon Sep 17 00:00:00 2001 From: Google APIs Date: Fri, 17 May 2019 15:14:59 -0700 Subject: [PATCH] Synchronize new proto/yaml changes. PiperOrigin-RevId: 248796470 --- repository_rules.bzl | 146 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 146 insertions(+) create mode 100644 repository_rules.bzl diff --git a/repository_rules.bzl b/repository_rules.bzl new file mode 100644 index 00000000..b1b0bb64 --- /dev/null +++ b/repository_rules.bzl @@ -0,0 +1,146 @@ +"""Repository rules and macros which are expected to be called from WORKSPACE file of either +googleapis itself or any third_party repository which consumes googleapis as its dependency. +""" + +def _switched_rules_impl(ctx): + disabled_rule_script = """ +def {rule_name}(**kwargs): + print("Ignoring {rule_name}(name = %s)" % kwargs.get("name", None)) +""" + enabled_native_rule_script = """ +{rule_name} = native.{rule_name} +""" + enabled_rule_script = """ +load("{file_label}", "{rule_names}") +""" + rules = [] + for rule_name in ctx.attr.disabled_rules: + if not rule_name: + continue + rules.append(disabled_rule_script.format(rule_name = rule_name)) + + for enabled_native_rule in ctx.attr.enabled_native_rules: + rules.append(enabled_native_rule_script.format(rule_name = enabled_native_rule)) + + for file_label, enabled_rules in ctx.attr.enabled_rules.items(): + if not enabled_rules: + continue + rule_names = "\", \"".join(enabled_rules.split(":")) + rules.append(enabled_rule_script.format(file_label = file_label, rule_names = rule_names)) + + ctx.file("BUILD.bazel", "") + ctx.file("imports.bzl", "".join(rules)) + +switched_rules = repository_rule( + implementation = _switched_rules_impl, + attrs = { + "enabled_rules": attr.label_keyed_string_dict( + allow_files = True, + allow_empty = True, + mandatory = False, + default = {}, + ), + "enabled_native_rules": attr.string_list( + mandatory = False, + allow_empty = True, + default = [], + ), + "disabled_rules": attr.string_list( + mandatory = False, + allow_empty = True, + default = [], + ), + }, +) + +def _switch_rules(enabled, out, rules_dict, native_rules = []): + if enabled: + for k, vals in rules_dict.items(): + out.enabled_rules[k] = ":".join(vals) + out.enabled_native_rules.extend(native_rules) + else: + out.disabled_rules.extend([sub_val for val in rules_dict.values() for sub_val in val]) + out.disabled_rules.extend(native_rules) + +def enabled_rules( + name, + proto = False, + java = False, + go = False, + cc = False, + python = False, + php = False, + ruby = False, + js = False, + csharp = False): + """Determines which language-specific rules should be enabled during build. All non-enabled + language-specific rules will default to no-op implementations. Examples of the language-specific + rules are: java_gapic_library (Java-specific), go_proto_library (Go-specific), + proto_library_with_info (proto-specific) etc. Note, proto_library rule is always enabled. + + To use this rule and enable Java and Go rules add the following in the external repository which + imports com_google_googleapis repository: + + load("@com_google_googleapis//:repository_rules.bzl", "enabled_rules") + + enabled_rules( + name = "com_google_googleapis_imports", + go = True, + java = True, + proto = True, + ) + + Args: + name (str): name of a target, is expected to be "com_google_googleapis_imports". + proto (bool): Enable custom proto rules (like proto_library_with_info). False by default. + java (bool): Enable Java specific rules. False by default. + go (bool): Enable Go specific rules. False by default. + cc (bool): Enable C++ specific rules. False by default. Not implemented yet. + python (bool): Enable Python-specific rules. False by default. Not implemented yet. + php (bool): Enable PHP specific rules. False by default. Not implemented yet. + ruby (bool): Enable Ruby specific rules. False by default. Not implemented yet. + js (bool): Enable JavaScript specific rules. False by default. Not implemented yet. + csharp (bool): Enable C# specific rules. False by default. Not implemented yet. + """ + + rules = struct(enabled_rules = {}, enabled_native_rules = [], disabled_rules = []) + + _switch_rules( + enabled = proto, + out = rules, + rules_dict = { + "@com_google_api_codegen//rules_gapic:gapic.bzl": ["proto_library_with_info"], + }, + ) + + _switch_rules( + enabled = java, + out = rules, + rules_dict = { + "@io_grpc_grpc_java//:java_grpc_library.bzl": ["java_grpc_library"], + "@com_google_api_codegen//rules_gapic/java:java_gapic.bzl": ["java_gapic_library"], + "@com_google_api_codegen//rules_gapic/java:java_gapic_pkg.bzl": ["java_gapic_assembly_gradle_pkg"], + }, + native_rules = [ + "java_proto_library", + "java_test", + ], + ) + + _switch_rules( + enabled = go, + out = rules, + rules_dict = { + "@io_bazel_rules_go//proto:def.bzl": ["go_proto_library"], + "@io_bazel_rules_go//go:def.bzl": ["go_library", "go_test"], + "@com_google_api_codegen//rules_gapic/go:go_gapic.bzl": ["go_gapic_srcjar", "go_gapic_library"], + "@com_google_api_codegen//rules_gapic/go:go_gapic_pkg.bzl": ["go_gapic_assembly_pkg"], + }, + ) + + switched_rules( + name = name, + enabled_rules = rules.enabled_rules, + enabled_native_rules = rules.enabled_native_rules, + disabled_rules = rules.disabled_rules, + )