feat: add full_name callback to proto messages

lib/protobuf.ex

@@ -82,6 +82,9 @@ defmodule Protobuf do
         Protobuf.Builder.new!(__MODULE__, attrs)
       end
 
+      @impl unquote(__MODULE__)
+      def full_name(), do: @options[:full_name]
+
       @impl unquote(__MODULE__)
       def transform_module() do
         nil
@@ -175,6 +178,12 @@ defmodule Protobuf do
   """
   @callback transform_module() :: module() | nil
 
+  @doc """
+  Returns the fully qualified name of the descriptor's target.
+  """
+  @doc since: "0.15.0"
+  @callback full_name() :: String.t()
+
   @doc """
   Decodes the given binary data interpreting it as the Protobuf message `module`.
 

lib/protobuf/protoc/generator/enum.ex

@@ -19,11 +19,17 @@ defmodule Protobuf.Protoc.Generator.Enum do
   def generate(%Context{namespace: ns} = ctx, %Google.Protobuf.EnumDescriptorProto{} = desc) do
     msg_name = Util.mod_name(ctx, ns ++ [Macro.camelize(desc.name)])
 
+    full_name =
+      ([ctx.package] ++ ctx.namespace ++ [desc.name])
+      |> Enum.reject(&is_nil/1)
+      |> Enum.join(".")
+
     use_options =
       Util.options_to_str(%{
         syntax: ctx.syntax,
         enum: true,
-        protoc_gen_elixir_version: "\"#{Util.version()}\""
+        protoc_gen_elixir_version: "\"#{Util.version()}\"",
+        full_name: "\"#{full_name}\""
       })
 
     descriptor_fun_body =

lib/protobuf/protoc/generator/message.ex

@@ -36,6 +36,11 @@ defmodule Protobuf.Protoc.Generator.Message do
     fields = get_fields(ctx, desc)
     extensions = get_extensions(desc)
 
+    full_name =
+      ([ctx.package] ++ ctx.namespace ++ [desc.name])
+      |> Enum.reject(&is_nil/1)
+      |> Enum.join(".")
+
     descriptor_fun_body =
       if ctx.gen_descriptors? do
         Util.descriptor_fun_body(desc)
@@ -52,7 +57,7 @@ defmodule Protobuf.Protoc.Generator.Message do
          message_template(
            comment: Comment.get(ctx),
            module: msg_name,
-           use_options: msg_opts_str(ctx, desc.options),
+           use_options: msg_opts_str(ctx, desc.options, full_name),
            oneofs: desc.oneof_decl,
            fields: gen_fields(ctx.syntax, fields),
            descriptor_fun_body: descriptor_fun_body,
@@ -98,14 +103,15 @@ defmodule Protobuf.Protoc.Generator.Message do
     ":#{f[:name]}, #{f[:number]}, #{label_str}type: #{f[:type]}#{opts_str}"
   end
 
-  defp msg_opts_str(%{syntax: syntax}, opts) do
+  defp msg_opts_str(%{syntax: syntax}, opts, full_name) do
     msg_options = opts
 
     opts = %{
       syntax: syntax,
       map: msg_options && msg_options.map_entry,
       deprecated: msg_options && msg_options.deprecated,
-      protoc_gen_elixir_version: "\"#{Util.version()}\""
+      protoc_gen_elixir_version: "\"#{Util.version()}\"",
+      full_name: "\"#{full_name}\""
     }
 
     str = Util.options_to_str(opts)

mix.exs

@@ -172,6 +172,12 @@ defmodule Protobuf.Mixfile do
       "./generated",
       ["test/protobuf/protoc/proto/no_package.proto"]
     )
+
+    protoc!(
+      "-I test/protobuf/protoc/proto --elixir_opt=include_docs=true",
+      "./generated",
+      ["test/protobuf/protoc/proto/full_name.proto"]
+    )
   end
 
   defp gen_bench_protos(_args) do

test/protobuf/protobuf_test.exs

@@ -2,9 +2,9 @@ defmodule Protobuf.ProtobufTest do
   use ExUnit.Case, async: false
 
   test "load_extensions/0 is a noop" do
-    assert loaded_extensions() == 18
+    assert loaded_extensions() == 19
     Protobuf.load_extensions()
-    assert loaded_extensions() == 18
+    assert loaded_extensions() == 19
   end
 
   describe "encode/1" do

test/protobuf/protoc/generator/enum_test.exs

@@ -28,17 +28,21 @@ defmodule Protobuf.Protoc.Generator.EnumTest do
     assert [{compiled_mod, bytecode}] = Code.compile_string(msg)
     assert inspect(compiled_mod) == module
 
-    assert msg =~ "defmodule #{module} do\n"
-    assert msg =~ "use Protobuf, enum: true, protoc_gen_elixir_version: \"#{Util.version()}\"\n"
+    assert msg == """
+           defmodule ProtobufProtocGeneratorEnumTestEnumFoo do
+             @moduledoc false
 
-    refute msg =~ "defstruct "
+             use Protobuf,
+               enum: true,
+               full_name: "ProtobufProtocGeneratorEnumTestEnumFoo",
+               protoc_gen_elixir_version: "#{Util.version()}"
 
-    assert msg =~ """
              field :A, 0
              field :B, 1
              field :HAS_UNDERSCORES, 2
              field :HAS_UNDERSCORES_X, 3
              field :HAS_UNDERSCORES_, 4
+           end
            """
 
     assert TestHelpers.get_type_spec_as_string(compiled_mod, bytecode, :t) ==
@@ -68,7 +72,9 @@ defmodule Protobuf.Protoc.Generator.EnumTest do
     assert inspect(compiled_mod) == module
 
     assert msg =~ "defmodule #{module} do\n"
-    assert msg =~ "use Protobuf, enum: true, protoc_gen_elixir_version: \"#{Util.version()}\"\n"
+
+    assert msg =~
+             "use Protobuf,\n    enum: true,\n    full_name: \"ProtobufProtocGeneratorEnumTestEnumFooDesc\",\n    protoc_gen_elixir_version: \"#{Util.version()}\"\n\n"
 
     refute msg =~ "defstruct "
 

test/protobuf/protoc/generator/message_test.exs

@@ -7,19 +7,21 @@ defmodule Protobuf.Protoc.Generator.MessageTest do
   alias Protobuf.TestHelpers
 
   test "generate/2 has right name" do
-    ctx = %Context{}
+    ctx = %Context{package: "pkg.name"}
     desc = %Google.Protobuf.DescriptorProto{name: "Foo"}
     {[], [{_mod, msg}]} = Generator.generate(ctx, desc)
-    assert msg =~ "defmodule Foo do\n"
-    assert msg =~ "use Protobuf, protoc_gen_elixir_version: \"#{Util.version()}\"\n"
+    assert msg =~ "defmodule Pkg.Name.Foo do\n"
+
+    assert msg =~
+             "use Protobuf, full_name: \"pkg.name.Foo\", protoc_gen_elixir_version: \"#{Util.version()}\"\n"
 
     assert [{compiled_mod, bytecode}] = Code.compile_string(msg)
 
     assert TestHelpers.get_type_spec_as_string(compiled_mod, bytecode, :t) ==
              Macro.to_string(
                quote(
                  do:
-                   t() :: %Foo{
+                   t() :: %Pkg.Name.Foo{
                      __unknown_fields__: [Protobuf.unknown_field()]
                    }
                )
@@ -81,7 +83,9 @@ defmodule Protobuf.Protoc.Generator.MessageTest do
     }
 
     {[], [{_mod, msg}]} = Generator.generate(ctx, desc)
-    assert msg =~ "use Protobuf, map: true, protoc_gen_elixir_version: \"#{Util.version()}\"\n"
+
+    assert msg =~
+             "use Protobuf, full_name: \"pkg.name.Foo\", map: true, protoc_gen_elixir_version: \"#{Util.version()}\"\n"
   end
 
   test "generate/2 has right fields" do
@@ -611,12 +615,16 @@ defmodule Protobuf.Protoc.Generator.MessageTest do
     }
 
     {[[{_mod, msg}]], _} = Generator.generate(ctx, desc)
-    assert msg =~ "defmodule Foo.Nested.EnumFoo do\n"
-    assert msg =~ "use Protobuf, enum: true, protoc_gen_elixir_version: \"#{Util.version()}\"\n"
 
-    assert msg =~ """
+    assert msg == """
+           defmodule Foo.Nested.EnumFoo do
+             @moduledoc false
+
+             use Protobuf, enum: true, full_name: "Foo.Nested.EnumFoo", protoc_gen_elixir_version: "#{Util.version()}"
+
              field :a, 0
              field :b, 1
+           end
            """
   end
 

test/protobuf/protoc/generator_integration_test.exs

@@ -87,4 +87,11 @@ defmodule Protobuf.Protoc.GeneratorIntegrationTest do
     assert NoPackageMessage.NumberMappingEntry.__message_props__().map?
     assert NoPackageMessage.decode(output) == input
   end
+
+  test "full_name/0 returns expected value for generated modules from full_name.proto" do
+    assert Foo.Bar.Unit.full_name() == "foo.bar.Unit"
+    assert Foo.Bar.Message.full_name() == "foo.bar.Message"
+    assert Foo.Bar.Message.NestedMessage.full_name() == "foo.bar.Message.NestedMessage"
+    assert Foo.Bar.Message.NestedMessage.Kind.full_name() == "foo.bar.Message.NestedMessage.Kind"
+  end
 end

test/protobuf/protoc/proto/full_name.proto

@@ -0,0 +1,34 @@
+// From: https://protobuf.com/docs/language-spec#fully-qualified-names
+syntax = "proto3";                            // Fully-qualified name
+                                              //----------------------
+package foo.bar;                              // foo.bar
+                                              //
+import "google/protobuf/descriptor.proto";    //
+                                              //
+message Message {                             // foo.bar.Message
+    oneof id {                                // foo.bar.Message.id
+      string name = 1;                        // foo.bar.Message.name
+      uint64 num = 2;                         // foo.bar.Message.num
+    }                                         //
+    message NestedMessage {                   // foo.bar.Message.NestedMessage
+      extend google.protobuf.MessageOptions { //
+        string fizz = 49999;                  // foo.bar.Message.NestedMessage.fizz
+      }                                       //
+      option (NestedMessage.fizz) = "buzz";   //
+      enum Kind {                             // foo.bar.Message.NestedMessage.Kind
+        NULL = 0;                             // foo.bar.Message.NestedMessage.NULL
+        PRIMARY = 1;                          // foo.bar.Message.NestedMessage.PRIMARY
+        SECONDARY = 2;                        // foo.bar.Message.NestedMessage.SECONDARY
+      }                                       //
+      Kind kind = 1;                          // foo.bar.Message.NestedMessage.kind
+    }                                         //
+    NestedMessage extra = 3;                  // foo.bar.Message.extra
+}                                             //
+                                              //
+enum Unit {                                   // foo.bar.Unit
+  VOID = 0;                                   // foo.bar.VOID
+}                                             //
+                                              //
+service FooService {                          // foo.bar.FooService
+  rpc Bar(Message) returns (Message);         // foo.bar.FooService.Bar
+}                                             //

test/protobuf/protoc/proto/test.proto

@@ -153,3 +153,4 @@ enum MapEnum {
   HELLO = 0;
   WORLD = 2;
 }
+