- Move attribute implementation to the language class files.

- Cleanup of some dnagling unused attributes and wonky semantics.
- Attempt to explain the import mechanism/support.

Author: pcj

README.md

@@ -144,6 +144,78 @@ protobuf_repositories(
 )
 ```
 
+
+# Imports
+
+In all cases, these rules will include a `--proto_path=.` argument.
+This is functionally equivalent to `--proto_path=$(bazel info
+execution_root)`.  Therefore, when the protoc tool is invoked, it will
+'see' whatever directory struture exists at the bazel execution root
+for your workspace.  To better learn what this looks like, `cd $(bazel
+info execution_root)` and look around.  In general, it contains all
+your sourcefiles as they appear in your workspace, with an additional
+`external/WORKSPACE_NAME` directory for all dependencies used.
+
+This has implications for import statements in your protobuf
+sourcefiles, if you use them.  The two cases to consider are imports
+*within* your workspace (referred to here as 'internal' imports), and
+imports of other protobuf files in an external workspace.
+
+### Internal Imports
+
+Internal imports should require no additional parameters if your
+import statements follow the directory structure of your workspace.
+For example, the `examples/helloworld/proto/helloworld.proto` file
+imports the `examples/proto/common.proto` file.  Since this follows
+the same directory structure as the workspace, `protoc` can find it,
+and no additional arguments to a `cc_proto_library` are required for
+protoc tool.
+
+*However*, the `cc_proto_library` rule in
+`examples/helloworld/proto/BUILD:cpp` names the
+`//examples/proto:cpp`'s `cc_proto_library` rule as a dependency in
+order to (1) trigger generation of the `common.pb.{h,cc}` files AND
+(2) include those generated files in the `cc_library` rule for
+compiling the object files.
+
+Additional `--proto_path` (`-I`) arguments can be supplied via the
+`imports = []` attribute common to all rules.
+
+### External Imports
+
+The same logic applied to external imports.  The two questions to answer are
+
+1. *Can protoc "see" the imported file?* In order to satisfy this
+   requirement, pass in the full path of the required file relative to
+   your execution root.  For example, the the well-known descriptor
+   proto could be made visible to protoc via something like...
+
+```python
+java_proto_library(
+  name = 'fooprotos',
+  srcs = 'foo.proto`,
+  imports = [
+    "external/com_github_google_protobuf/src/",
+  ],
+)
+```
+
+...given that the file
+`@com_github_google_protobuf/src/google/protobuf/descriptor.proto` is
+in the package `google.protobuf`.
+
+2. *Can the `{LANG}_proto_library` rule "see" the generated protobuf
+   files (in this case `descripttor.pb.{h,cc}`.  Just because the file
+   was imported does not imply that protoc will generate outputs for
+   it, so somewhere in the `cc_library` rule dependency chain these
+   files must be present.  This could be via another
+   `cc_proto_library` rule defined elswhere, or a some other filegroup
+   or label list.  If the source is another `cc_proto_library` rule,
+   specify that in the `deps` attribute to the calling
+   `cc_proto_library` rule.  Otherwise, pass it to the `cc_srcs` or
+   perhaps `cc_deps` attribute to the calling `cc_proto_library` rule.
+   Hopefully that made sense.  It's tricky.
+
 # Contributing
 
 Contributions welcome; please create Issues or GitHub pull requests.

bzl/base/class.bzl

@@ -173,6 +173,59 @@ def post_execute(lang, self):
     pass
 
 
+def implement_compile_attributes(lang, self):
+    """Add attributes for the X_proto_compile rule"""
+
+    name = lang.name
+    attrs = self["attrs"]
+
+    # Add "gen_java = X" option where X is True if this is the first
+    # language specified.
+    flag = "gen_" + name
+    attrs[flag] = attr.bool(
+        default = True,
+    )
+
+    # Add a "gen_java_plugin_options=[]".
+    opts = flag + "_plugin_options"
+    attrs[opts] = attr.string_list()
+
+    # If there is a plugin binary, create this label now.
+    if hasattr(lang, "protobuf") and hasattr(lang.protobuf, "executable"):
+        attrs["gen_protobuf_" + name + "_plugin"] = attr.label(
+            default = Label(lang.protobuf.executable),
+            cfg = HOST_CFG,
+            executable = True,
+        )
+
+    # If this language supports gRPC, add this boolean flag in.
+    # However, if we didn't load grpc, we don't actually want to
+    # generate the label for the executable lest we actually need to
+    # have the executable available.  TODO: figure out how to write a
+    # variable in the loading phase of workspace and read it here.
+
+    if hasattr(lang, "grpc"):
+      attrs["gen_grpc_" + name] = attr.bool()
+      if hasattr(lang.grpc, "executable"):
+        attrs["gen_grpc_" + name + "_plugin"] = attr.label(
+          default = Label(lang.grpc.executable),
+          cfg = HOST_CFG,
+          executable = True,
+        )
+
+
+def implement_compile_outputs(lang, self):
+    """Add customizable outputs for the proto_compile rule"""
+    if hasattr(lang, "protobuf") and hasattr(lang.protobuf, "outputs"):
+        self["outputs"] += lang.protobuf.outputs
+    if hasattr(lang, "grpc") and hasattr(lang.grpc, "outputs"):
+        self["outputs"] += lang.grpc.outputs
+
+
+def implement_compile_output_to_genfiles(lang, self):
+    self["output_to_genfiles"] = getattr(lang, "output_to_genfiles", self["output_to_genfiles"])
+
+
 CLASS = struct(
     name = "base",
 
@@ -194,5 +247,10 @@ CLASS = struct(
     build_grpc_out = build_grpc_out,
     build_grpc_invocation = build_grpc_invocation,
     build_protoc_command = build_protoc_command,
+
     post_execute = post_execute,
+
+    implement_compile_attributes = implement_compile_attributes,
+    implement_compile_outputs = implement_compile_outputs,
+    implement_compile_output_to_genfiles = implement_compile_output_to_genfiles,
 )

bzl/go/class.bzl

@@ -2,19 +2,37 @@ load("//bzl:base/class.bzl", BASE = "CLASS")
 load("//bzl:util.bzl", "invokesuper")
 
 
-def _build_protobuf_out(lang, self):
+def implement_compile_attributes(lang, self):
+    """Override attributes for the X_proto_compile rule"""
+    invokesuper("implement_compile_attributes", lang, self)
+
+    attrs = self["attrs"]
+
+    # go_prefix is necessary for protoc-gen-go import mapping of dependent protos.
+    attrs["go_prefix"] = attr.label(
+        providers = ["go_prefix"],
+        default = Label(
+            "//:go_prefix",
+            relative_to_caller_repository = True,
+        ),
+        allow_files = False,
+        cfg = HOST_CFG,
+    )
+
+
+def build_protobuf_out(lang, self):
     """Override behavior to add a plugin option before building the --go_out option"""
     if self.get("with_grpc", False):
         self["protobuf_plugin_options"] = self.get("protobuf_plugin_options", []) + ["plugins=grpc"]
     invokesuper("build_protobuf_out", lang, self)
 
 
-def _build_grpc_out(lang, self):
+def build_grpc_out(lang, self):
     """Override behavior to skip the --grpc_out option (protoc-gen-go does not use it)"""
     pass
 
 
-def _build_imports(lang, self):
+def build_imports(lang, self):
     """@Override: for all transitive packages source file names, provide import mapping."""
     invokesuper("build_imports", lang, self)
 
@@ -26,12 +44,9 @@ def _build_imports(lang, self):
 
     for dep in ctx.attr.deps:
         provider = dep.proto
-        #print("proto provider: %s" % dir(provider))
         proto_packages = provider.transitive_packages
-        #print("proto_packages: %s" % proto_packages)
         for pkg, srcs in proto_packages.items():
             target = pkg.rsplit(':') # [0] == ctx.label.package, [1] == ctx.label.name
-            #print("target: %s" % target)
             for srcfile in srcs:
                 src = srcfile.short_path
                 dst = go_prefix + '/' + target[0]
@@ -40,6 +55,7 @@ def _build_imports(lang, self):
                     dst += "/" + target[1][:-len(".pb")]
                 self["protobuf_plugin_options"] = self.get("protobuf_plugin_options", []) + ["M%s=%s" % (src, dst)]
 
+
 CLASS = struct(
     parent = BASE,
     name = "go",
@@ -74,7 +90,8 @@ CLASS = struct(
         ],
     ),
 
-    build_protobuf_out = _build_protobuf_out,
-    build_grpc_out = _build_grpc_out,
-    build_imports = _build_imports,
+    build_protobuf_out = build_protobuf_out,
+    build_grpc_out = build_grpc_out,
+    build_imports = build_imports,
+    implement_compile_attributes = implement_compile_attributes,
 )