- Renamed 'protos' attribute to 'srcs' to better match convention.

- Renamed implicit target '_pb' to '.pb' for better aesthetics.
- Cleanup print statements.
- Implement cc_srcs, go_srcs, java_srcs macro attributes to clarify intent with library rules.
- Implement cc_deps, go_deps, java_deps macro attributes to clarify intent with library rules.
- *_proto_compile attribute 'deps' now requires 'proto' provider for transitive data.
- Build file cleanup.
- README cleanup.

Author: pcj

bzl/base/class.bzl

@@ -68,7 +68,7 @@ def build_imports(lang, self):
     #print("ctx.attr.imports: %s" % type(ctx.attr.imports))
     for target in ctx.attr.imports:
         for srcfile in target.files:
-            print("srcfile: %s" % srcfile.path)
+            #print("srcfile: %s" % srcfile.path)
             dstfile = ctx.new_file(srcfile.path)
             #dstfile = ctx.new_file(srcfile.path)
             # By declaring that the proto action (happening later)
@@ -89,7 +89,7 @@ def build_imports(lang, self):
             #self["srcs"] += [dstfile]
 
             #self["go_plugin_options"] = self.get("go_plugin_options", []) + ["M" + srcfile.path + "="]
-    self["paths"] += [self["outdir"]]
+    #self["paths"] += [self["outdir"]]
 
 def build_plugin_out(name, key, lang, self):
     #print("build_plugin_out(%s, %s)" % (name, key))

bzl/cpp/README.md

@@ -26,12 +26,12 @@ load("@org_pubref_rules_protobuf//bzl:cpp/rules.bzl", "cc_proto_library")
 ```
 
 Invoke the rule.  Pass the set of protobuf source files to the
-`protos` attribute.
+`srcs` attribute.
 
 ```python
 cc_proto_library(
   name = "protolib",
-  protos = ["my.proto"],
+  srcs = ["my.proto"],
   with_grpc = True,
 )
 ```

bzl/cpp/rules.bzl

@@ -6,28 +6,29 @@ cc_proto_compile = implement(["cpp"])
 
 def cc_proto_library(
     name,
-    protos,
     copy_protos_to_genfiles = False,
     deps = [],
     grpc_plugin = None,
     grpc_plugin_options = [],
     imports = [],
     lang = CPP,
     paths = [],
-    proto_compile = cc_proto_compile,
     protobuf_plugin_options = [],
     protobuf_plugin = None,
+    proto_compile = cc_proto_compile,
     protoc = EXECUTABLE,
     srcs = [],
     verbose = 0,
     visibility = None,
     with_grpc = False,
+    cc_deps = [],
+    cc_srcs = [],
     **kwargs):
 
   args = {}
-  args["name"] = name + "_pb"
+  args["name"] = name + ".pb"
   args["copy_protos_to_genfiles"] = copy_protos_to_genfiles
-  args["deps"] = deps
+  args["deps"] = [d + ".pb" for d in deps]
   args["imports"] = imports
   args["gen_" + lang.name] = True
   args["gen_grpc_" + lang.name] = with_grpc
@@ -36,22 +37,22 @@ def cc_proto_library(
   args["gen_grpc_" + lang.name + "_plugin"] = grpc_plugin
   args["paths"] = paths
   args["protoc"] = protoc
-  args["protos"] = protos
+  args["protos"] = srcs
   args["verbose"] = verbose
   args["with_grpc"] = with_grpc
 
   proto_compile(**args)
 
   if with_grpc and hasattr(lang, "grpc"):
-    proto_deps = [str(Label(dep)) for dep in getattr(lang.grpc, "compile_deps", [])]
+    deps += [str(Label(dep)) for dep in getattr(lang.grpc, "compile_deps", [])]
   elif hasattr(lang, "protobuf"):
-    proto_deps = [str(Label(dep)) for dep in getattr(lang.protobuf, "compile_deps", [])]
+    deps += [str(Label(dep)) for dep in getattr(lang.protobuf, "compile_deps", [])]
 
-  cc_deps = list(set(deps + proto_deps))
+  deps = list(set(deps + cc_deps))
 
   native.cc_library(
     name = name,
-    srcs = srcs + [name + "_pb"],
-    deps = cc_deps,
+    srcs = cc_srcs + [name + ".pb"],
+    deps = deps,
     **kwargs
   )

bzl/go/README.md

@@ -24,12 +24,12 @@ load("@org_pubref_rules_protobuf//bzl:go/rules.bzl", "go_proto_library")
 ```
 
 Invoke the rule.  Pass the set of protobuf source files to the
-`protos` attribute.
+`srcs` attribute.
 
 ```python
 go_proto_library(
   name = "protolib",
-  protos = ["my.proto"],
+  srcs = ["my.proto"],
   with_grpc = True,
 )
 ```
@@ -86,7 +86,7 @@ go_prefix("github.com/my_organization_name")
 # //go/app_1/BUILD
 go_proto_library(
   name = "protolib",
-  protos = ["my.proto"],
+  srcs = ["my.proto"],
   with_grpc = True,
 )
 ```

bzl/go/class.bzl

@@ -23,43 +23,23 @@ def _build_imports(lang, self):
         fail("Bazel context is required for build_imports")
 
     go_prefix = ctx.attr.go_prefix.go_prefix
-    #print("go prefix: %s" % dir(go_prefix))
 
-    print("ctx.attr.deps: %s" % ctx.attr.deps)
-
-    for dep in ctx.attr.proto_deps:
-        print("ctx.attr.dep[i]: %s" % dir(dep))
+    for dep in ctx.attr.deps:
         provider = dep.proto
-        print("proto provider: %s" % dir(provider))
+        #print("proto provider: %s" % dir(provider))
         proto_packages = provider.transitive_packages
-        print("proto_packages: %s" % proto_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)
+            #print("target: %s" % target)
             for srcfile in srcs:
                 src = srcfile.short_path
                 dst = go_prefix + '/' + target[0]
-                if target[1] != "go_default_library_pb":
-                    # slice off the '_pb' from 'mylib_pb'
-                    dst += "/" + target[1][:-len("_pb")]
+                if target[1] != "go_default_library.pb":
+                    # slice off the '.pb' from 'mylib.protos'
+                    dst += "/" + target[1][:-len(".pb")]
                 self["protobuf_plugin_options"] = self.get("protobuf_plugin_options", []) + ["M%s=%s" % (src, dst)]
 
-    # #print("ctx.attr.imports: %s" % type(ctx.attr.imports))
-    # for target in ctx.attr.imports:
-    #     label = target.label
-    #     print("target: %s" % dir(target.label))
-    #     for srcfile in target.files:
-    #         print("srcfile: %s" % dir(srcfile))
-    #         src = srcfile.short_path
-    #         # The destination mapping is the go_prefix +
-    #         dst = go_prefix + '/' + srcfile.dirname
-    #         if ctx.label.name != "go_default_library":
-    #             # slice off the '_pb' from 'mylib_pb'
-    #             dst += "/" + ctx.label.name[:-len("_pb")]
-    #         self["protobuf_plugin_options"] = self.get("protobuf_plugin_options", []) + ["M%s=%s" % (src, dst)]
-
-    #         srcfile.basename[:-len(".proto")]
-
 CLASS = struct(
     parent = BASE,
     name = "go",

bzl/go/rules.bzl

@@ -6,57 +6,53 @@ go_proto_compile = implement(["go"])
 
 def go_proto_library(
     name,
-    protos,
     copy_protos_to_genfiles = True,
     deps = [],
     grpc_plugin = None,
     grpc_plugin_options = [],
     imports = [],
     lang = GO,
     paths = [],
-    proto_compile = go_proto_compile,
-    #proto_deps = [],
     protobuf_plugin_options = [],
     protobuf_plugin = None,
+    proto_compile = go_proto_compile,
     protoc = EXECUTABLE,
     srcs = [],
     verbose = 0,
     visibility = None,
     with_grpc = False,
+    go_deps = [],
+    go_srcs = [],
     **kwargs):
 
   args = {}
-  args["name"] = name + "_pb"
+  args["name"] = name + ".pb"
   args["copy_protos_to_genfiles"] = copy_protos_to_genfiles
-  args["deps"] = deps
+  args["deps"] = [d + ".pb" for d in deps]
   args["imports"] = imports
   args["gen_" + lang.name] = True
   args["gen_grpc_" + lang.name] = with_grpc
   args["gen_protobuf_" + lang.name + "_plugin"] = protobuf_plugin
   args["gen_" + lang.name + "_plugin_options"] = protobuf_plugin_options
   args["gen_grpc_" + lang.name + "_plugin"] = grpc_plugin
   args["paths"] = paths
-  args["proto_deps"] = [d + "_pb" for d in deps]
   args["protoc"] = protoc
-  args["protos"] = protos
+  args["protos"] = srcs
   args["verbose"] = verbose
   args["with_grpc"] = with_grpc
 
   proto_compile(**args)
 
   if with_grpc and hasattr(lang, "grpc"):
-    proto_deps = [str(Label(dep)) for dep in getattr(lang.grpc, "compile_deps", [])]
+    deps += [str(Label(dep)) for dep in getattr(lang.grpc, "compile_deps", [])]
   elif hasattr(lang, "protobuf"):
-    proto_deps = [str(Label(dep)) for dep in getattr(lang.protobuf, "compile_deps", [])]
-
-  go_deps = list(set(deps + proto_deps))
+    deps += [str(Label(dep)) for dep in getattr(lang.protobuf, "compile_deps", [])]
 
-  #print("go_deps %s" % dir(go_deps[0]))
-  #go_deps = [d for d in go_deps if hasattr(d, "foo")]
+  deps = list(set(deps + go_deps))
 
   go_library(
      name = name,
-     srcs = srcs + [ name + "_pb"],
-     deps = go_deps,
+     srcs = go_srcs + [ name + ".pb"],
+     deps = deps,
      **kwargs
   )

bzl/grpc_gateway/rules.bzl

@@ -19,7 +19,7 @@ def grpc_gateway_proto_library(
 
   result = protoc_genrule(
     spec = [lang],
-    name = name + "_pb_gw",
+    name = name + ".pb.gw",
     protos = protos,
     protoc = protoc,
     protobuf_plugin = protobuf_plugin,

bzl/java/README.md

@@ -24,12 +24,12 @@ load("@org_pubref_rules_protobuf//bzl:java/rules.bzl", "java_proto_library")
 ```
 
 Invoke the rule.  Pass the set of protobuf source files to the
-`protos` attribute.
+`srcs` attribute.
 
 ```python
 java_proto_library(
   name = "protolib",
-  protos = ["my.proto"],
+  srcs = ["my.proto"],
   with_grpc = True,
 )
 ```
@@ -64,8 +64,8 @@ One could also specify all the sources needed in the
 ```python
 java_proto_library(
   name = "mylib",
-  protos = ["my.proto"],
-  srcs = ['MyApp.java'],
+  srcs = ["my.proto"],
+  java_srcs = ['MyApp.java'],
   with_grpc = True,
 )
 ```

bzl/java/rules.bzl

@@ -5,37 +5,40 @@ java_proto_compile = implement(["java"])
 
 def java_proto_library(
     name,
-    protos,
-    lang = JAVA,
-    proto_compile = java_proto_compile,
-    srcs = [],
+    copy_protos_to_genfiles = False,
+    deps = [],
+    grpc_plugin = None,
+    grpc_plugin_options = [],
     imports = [],
-    visibility = None,
-    testonly = 0,
-    protoc = EXECUTABLE,
+    lang = JAVA,
+    paths = [],
     protobuf_plugin_options = [],
     protobuf_plugin = None,
-    grpc_plugin = None,
-    grpc_plugin_options = [],
+    proto_compile = java_proto_compile,
+    protoc = EXECUTABLE,
+    srcs = [],
     verbose = 0,
+    visibility = None,
     with_grpc = False,
-    deps = [],
+    java_deps = [],
+    java_srcs = [],
     **kwargs):
 
   args = {}
-  args["name"] = name + "_pb"
-  args["deps"] = deps
+  args["name"] = name + ".pb"
   args["copy_protos_to_genfiles"] = False
-  args["protos"] = protos
-  args["verbose"] = verbose
+  args["deps"] = [d + "_pb" for d in deps]
   args["imports"] = imports
-  args["protoc"] = protoc
-  args["with_grpc"] = with_grpc
   args["gen_" + lang.name] = True
   args["gen_grpc_" + lang.name] = with_grpc
   args["gen_protobuf_" + lang.name + "_plugin"] = protobuf_plugin
   args["gen_" + lang.name + "_plugin_options"] = protobuf_plugin_options
   args["gen_grpc_" + lang.name + "_plugin"] = grpc_plugin
+  args["paths"] = paths
+  args["protoc"] = protoc
+  args["protos"] = srcs
+  args["verbose"] = verbose
+  args["with_grpc"] = with_grpc
 
   proto_compile(**args)
 
@@ -44,13 +47,11 @@ def java_proto_library(
   elif hasattr(lang, "protobuf"):
     deps += [str(Label(dep)) for dep in getattr(lang.protobuf, "compile_deps", [])]
 
-  #print("java_proto_library compile deps: %s" % deps)
-
-  deps = list(set(deps))
+  deps = list(set(deps + java_deps))
 
   native.java_library(
     name = name,
-    srcs = srcs + [name + "_pb.srcjar"],
+    srcs = java_srcs + [name + ".pb.srcjar"],
     deps = deps,
     **kwargs
   )

bzl/javanano/rules.bzl

@@ -4,9 +4,8 @@ load("//bzl:java/rules.bzl", "java_proto_library")
 
 android_proto_compile = implement(["javanano"])
 
-def android_proto_library(name, protos, **kwargs):
+def android_proto_library(name, **kwargs):
   java_proto_library(name,
-                     protos,
                      lang=JAVANANO,
                      proto_compile = android_proto_compile,
                      **kwargs)