protoc-gen-twirp_ruby 1.0.0 → 1.1.1

data/lib/twirp/protoc_plugin/compiler_plugin_ext/code_generator_request_ext.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "google/protobuf/compiler/plugin_pb"
+require "twirp/protoc_plugin/descriptor_ext/file_descriptor_proto_ext"
+
+class Google::Protobuf::Compiler::CodeGeneratorRequest
+  class << self
+    alias_method :old_decode, :decode
+
+    def decode(bytes)
+      request = old_decode(bytes)
+      request.send(:populate_dependency_proto_files!)
+
+      request
+    end
+  end
+
+  private
+
+  # Access the [`Google::Protobuf::RepeatedField`] of [Google::Protobuf::FileDescriptorProto]
+  # as a proper Array, memoizing the value in the process.
+  #
+  # This memoized value stabilizes the test suite when run via `rake spec` (whereas, interestingly,
+  # running standalone `rspec` was fine). I'm not certain why that is, but I wonder if it has to
+  # do with memory pressure and garbage collection that runs during `rake spec` but not `rspec`
+  # (because `rspec` loads less into memory)... and memoizing the value forces the GC to keep the
+  # `FileDescriptorProto` references around.
+  #
+  # Before this change, the `populate_dependency_proto_files!` method would execute and modify
+  # the `file_descriptor_proto`, but sometimes the changes inside the enumerator wouldn't "stick"
+  # after the enumeration went out of scope. (Again, only via the `rake spec` command, not via
+  # `rspec`). This resulted in the `dependency_proto_files` value being unexpectedly `nil` when at
+  # the very least an empty array was expected.
+  #
+  # @return [Array<Google::Protobuf::FileDescriptorProto>]
+  def proto_files
+    @proto_files ||= proto_file.to_ary
+  end
+
+  def populate_dependency_proto_files!
+    proto_files.each do |file_descriptor_proto|
+      file_descriptor_proto.dependency_proto_files = []
+
+      file_descriptor_proto.dependency.each do |dependent_file_name|
+        file_descriptor_proto.dependency_proto_files << proto_file_for(dependent_file_name)
+      end
+    end
+  end
+
+  # @param name [String]
+  # @return [Google::Protobuf::FileDescriptorProto, nil]
+  def proto_file_for(name)
+    proto_files.find { |proto_file| proto_file.name == name }
+  end
+end

data/lib/twirp/protoc_plugin/core_ext/file/delete_extension.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class File
+  # @param filename [String] a filename string (with optional path),
+  #   e.g. "some/example/hello.proto"
+  # @return [String] the filename (preserving optional path) minus the file extension,
+  #   e.g. "some/example/hello"
+  def self.delete_extension(filename)
+    filename.delete_suffix(File.extname(filename))
+  end
+end

data/lib/twirp/protoc_plugin/core_ext/string/camel_case.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "twirp/protoc_plugin/core_ext/string/capitalize_first"
+
+class String
+  # Returns the string converted to either lowerCamelCase or UpperCamelCase.
+  #
+  # Inspired by https://github.com/rails/rails/blob/6f0d1ad14b92b9f5906e44740fce8b4f1c7075dc/activesupport/lib/active_support/inflector/methods.rb#L70
+  #
+  # @param uppercase_first_letter [Boolean] true for UpperCamelCase,
+  #   false for lowerCamelCase. Defaults to true.
+  # @return [String] a copy of the chars of <code>self</code>
+  def camel_case(uppercase_first_letter = true)
+    s = if uppercase_first_letter
+      capitalize_first
+    else
+      self
+    end
+
+    s.gsub(/_([a-z\d]*)/i) do
+      $1.capitalize
+    end
+  end
+end

data/lib/twirp/protoc_plugin/core_ext/string/capitalize_first.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class String
+  # Capitalizes the first letter of the string.
+  #
+  # Inspired by https://github.com/rails/rails/blob/6f0d1ad14b92b9f5906e44740fce8b4f1c7075dc/activesupport/lib/active_support/inflector/methods.rb#L166
+  #
+  # @return [String] a string with the first letter capitalized
+  def capitalize_first
+    return "" if empty?
+
+    self[0].upcase + self[1..]
+  end
+end

data/lib/twirp/protoc_plugin/core_ext/string/snake_case.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class String
+  # Converts the string to lower_snake_case.
+  #
+  # Inspired by https://github.com/rails/rails/blob/6f0d1ad14b92b9f5906e44740fce8b4f1c7075dc/activesupport/lib/active_support/inflector/methods.rb#L99
+  #
+  # @return [String] the converted input
+  def snake_case
+    gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .downcase
+  end
+end

data/lib/twirp/protoc_plugin/descriptor_ext/file_descriptor_proto_ext.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "google/protobuf/descriptor_pb"
+require "twirp/protoc_plugin/core_ext/string/camel_case"
+
+class Google::Protobuf::FileDescriptorProto
+  # The `FileDescriptorProto` contains a `dependency` array of all of the imported file
+  # name strings, in the order in which they appear in the source file.
+  #
+  # We want to create a parallel array, but instead of just the file names, we want
+  # the _references_ to those proto file descriptors. So, we declare the attribute
+  # here. NOTE: We also override `CodeGeneratorRequest` `decode` such that it automatically
+  # populates this array when the request is decoded.
+  #
+  # @return [Array<Google::Protobuf::FileDescriptorProto>]
+  attr_accessor :dependency_proto_files
+
+  # @return [String] the output filename for the proto file's generated twirp code.
+  #   For example, given a `name` of e.g. "some/example/hello.proto", the twirp output
+  #   filename is "some/example/hello_twirp.rb"
+  def twirp_output_filename
+    File.delete_extension(name) + "_twirp.rb"
+  end
+
+  # @return [String] the file name of the generated ruby protobuf code from protoc,
+  #   without any path information and missing the ".rb" file extension.
+  #
+  #   For example, given a `name` of e.g. "some/example/hello.proto", this helper
+  #   returns "hello_rb". The ruby output is expected to be located in the same
+  #   directory as the generated twirp output file.
+  def relative_ruby_protobuf_name
+    File.basename(name, File.extname(name)) + "_pb"
+  end
+
+  # @return [Boolean] true if the proto file has at least one `service` definition,
+  #   false otherwise.
+  def has_service?
+    !service.empty?
+  end
+
+  # @return [String] the ruby module for this proto file. Gives precedence to
+  #   the `ruby_package` option if specified, then the `package` of the file
+  #   (converted to UpperCamelCase). Includes a leading top-level namespace
+  #   qualifier "::", e.g.: "::MyCompany::Example::Api". Returns `""` when neither
+  #   ruby_package nor package is specified.
+  def ruby_module
+    @ruby_module ||= begin
+      pkg = options.ruby_package unless options&.ruby_package.to_s.empty?
+      pkg ||= split_to_constants(package).join("::").to_s unless package.to_s.empty?
+
+      if pkg.nil?
+        "" # Set to "" instead of nil to properly memoize and avoid re-calculating
+      else
+        "::" + pkg
+      end
+    end
+  end
+
+  # Converts a protobuf message type to a string containing the equivalent Ruby constant,
+  # relative to the current proto file's Ruby module.
+  #
+  # Respects the `ruby_package` option, both for the current proto file and for all
+  # message types that are imported if the imported file also specifies a `ruby_package`.
+  #
+  # For example, given ...
+  #
+  #   1) the current file has `package "foo.bar";` and `option ruby_package = "Foo::Bar";`
+  #   2) an imported file has `package "other.file.baz";` and `option ruby_package = "Baz";`
+  #   3) a third imported file has `package "third.file";` without a `ruby_package` option.
+  #
+  # ... then:
+  #
+  #   ruby_type_for(".foo.bar.example_message") => "ExampleMessage"
+  #   ruby_type_for(".foo.bar.ExampleMessage.NestedMessage") => "ExampleMessage::NestedMessage"
+  #   ruby_type_for(".google.protobuf.Empty") => "::Google::Protobuf::Empty"
+  #   ruby_type_for(".other.file.baz.example_message") => "::Baz::ExampleMessage"
+  #   ruby_type_for(".third.file.example_message") => "::Third::File::ExampleMessage"
+  #
+  # @param message_type [String]
+  # @return [String]
+  def ruby_type_for(message_type)
+    ruby_type = ruby_type_map[message_type]
+
+    # For types in the same module, remove module and trailing "::"
+    ruby_type = ruby_type.delete_prefix(ruby_module + "::") unless ruby_module.empty?
+
+    ruby_type
+  end
+
+  private
+
+  # Converts either a package string like ".some.example.api" or a namespaced
+  # message like ".google.protobuf.Empty" to an Array of Strings that can be
+  # used as Ruby constants (when joined with "::").
+  #
+  # ".some.example.api" becomes ["", Some", "Example", "Api"]
+  # ".google.protobuf.Empty" becomes ["", Google", "Protobuf", "Empty"]
+  #
+  # @param package_or_message [String]
+  # @return [Array<String>]
+  def split_to_constants(package_or_message)
+    package_or_message
+      .split(".")
+      .map { |s| s.camel_case }
+  end
+
+  # @return [Hash<String, String>] the type mappings for the proto file (and all
+  #   imported proto files), keyed by the the protobuf name (starting with `.` when
+  #   package is specified). Values correspond to the fully qualified Ruby
+  #   type, respecting the `ruby_package` option of the file if present.
+  #
+  #   For example:
+  #     ".example_message" => "ExampleMessage"
+  #     ".foo.bar.ExampleMessage => "::Foo::Bar::ExampleMessage"
+  #     ".foo.bar.ExampleMessage.NestedMessage" => "::Foo::Bar::ExampleMessage::NestedMessage"
+  #     ".google.protobuf.Empty" => "Google::Protobuf::Empty"
+  #     ".common.bar.baz.other_type" => "::Common::Baz::OtherType"
+  #       (when type is imported from a proto file with package = "common.bar.baz"
+  #       and `option ruby_package = "Common::Baz";` specified)
+  def ruby_type_map
+    if @ruby_type_map.nil?
+      @ruby_type_map = build_ruby_type_map(self)
+    end
+
+    @ruby_type_map
+  end
+
+  # Loops through the messages in the proto file, and recurses through the messages in
+  # dependent proto files, to construct the ruby type map for all types within the file.
+  #
+  # @see [#ruby_type_map]
+  # @param proto_file [Google::Protobuf::FileDescriptorProto]
+  # @return [Hash<String, String>]
+  def build_ruby_type_map(proto_file)
+    type_map = {}
+
+    proto_file.message_type.each do |message_type|
+      add_message_type(type_map, proto_file, message_type)
+    end
+
+    proto_file.dependency_proto_files.each do |dependency_proto_file|
+      type_map.merge! build_ruby_type_map(dependency_proto_file)
+    end
+
+    type_map
+  end
+
+  # Adds the message type's key and value to the type map, recursively handling nested message
+  # types along the way.
+  #
+  # @param type_map [Hash<String, String>]
+  # @param proto_file [Google::Protobuf::FileDescriptorProto] The proto file containing the message type
+  # @param message_type [Google::Protobuf::DescriptorProto]
+  # @param parent_key [String, nil] In the recursive case, this is the parent message type key so
+  #   that the nested child type can be properly namespaced.
+  # @param parent_value [String, nil] In the recursive case, this is the parent message type value
+  #   so that the nested type can be properly namespaced.
+  # @return [void]
+  def add_message_type(type_map, proto_file, message_type, parent_key = nil, parent_value = nil)
+    key = type_map_key(proto_file, message_type, parent_key)
+    value = type_map_value(proto_file, message_type, parent_value)
+
+    type_map[key] = value
+
+    # Recurse over nested types, using the current message_type's key and value as the parent values
+    message_type.nested_type.each do |nested_type|
+      add_message_type(type_map, proto_file, nested_type, key, value)
+    end
+  end
+
+  # @param proto_file [Google::Protobuf::FileDescriptorProto] The proto file containing the message type
+  # @param message_type [Google::Protobuf::DescriptorProto]
+  # @param parent_key [String, nil] In the recursive case, this is the parent message type key so
+  #   that the nested child type can be properly namespaced.
+  # @return [String]
+  def type_map_key(proto_file, message_type, parent_key)
+    key_prefix = if !parent_key.nil?
+      "#{parent_key}."
+    elsif proto_file.package.to_s.empty?
+      "."
+    else
+      ".#{proto_file.package}."
+    end
+
+    "#{key_prefix}#{message_type.name}"
+  end
+
+  # @param proto_file [Google::Protobuf::FileDescriptorProto] The proto file containing the message type
+  # @param message_type [Google::Protobuf::DescriptorProto]
+  # @param parent_value [String, nil] In the recursive case, this is the parent message type value
+  #   so that the nested type can be properly namespaced.
+  # @return [String]
+  def type_map_value(proto_file, message_type, parent_value)
+    value_prefix = if !parent_value.nil?
+      "#{parent_value}::"
+    elsif proto_file.ruby_module.empty?
+      ""
+    else
+      "#{proto_file.ruby_module}::"
+    end
+
+    "#{value_prefix}#{message_type.name.camel_case}"
+  end
+end

data/lib/twirp/protoc_plugin/descriptor_ext/service_descriptor_proto_ext.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "google/protobuf/descriptor_pb"
+require "twirp/protoc_plugin/core_ext/string/camel_case"
+
+class Google::Protobuf::ServiceDescriptorProto
+  def service_class_name
+    # The generated service class name should end in "Service"; A well-named
+    # service may already end with "Service" but we can't guarantee it. Use
+    # class_name_without_service_suffix to #avoid "ServiceService"
+    class_name_without_service_suffix + "Service"
+  end
+
+  def client_class_name
+    class_name_without_service_suffix + "Client"
+  end
+
+  private
+
+  def class_name_without_service_suffix
+    name.delete_suffix("Service").camel_case
+  end
+end

data/lib/twirp/protoc_plugin/process.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "../../google/protobuf/compiler/plugin_pb"
+require "twirp/protoc_plugin/core_ext/file/delete_extension"
+require "google/protobuf/compiler/plugin_pb"
+require "twirp/protoc_plugin/compiler_plugin_ext/code_generator_request_ext"
+require "twirp/protoc_plugin/descriptor_ext/file_descriptor_proto_ext"
 require_relative "code_generator"
 
 module Twirp
@@ -10,19 +13,23 @@ module Twirp
     class << self
       # @param input [String] an encoded [Google::Protobuf::Compiler::CodeGeneratorRequest] message
       # @return [String] an encoded [Google::Protobuf::Compiler::CodeGeneratorResponse] message
-      # @raise [Twirp::ProtocPlugin::Error] when the input is unreadable
+      # @raise [ArgumentError] when a required parameter is missing, a parameter value is invalid, or
+      #   an unrecognized parameter is present on the command line
       def process(input)
         request = Google::Protobuf::Compiler::CodeGeneratorRequest.decode(input)
 
+        options = extract_options(request.parameter)
+
         response = Google::Protobuf::Compiler::CodeGeneratorResponse.new
         response.supported_features = Google::Protobuf::Compiler::CodeGeneratorResponse::Feature::FEATURE_PROTO3_OPTIONAL
 
-        request.proto_file.each do |proto_file|
+        request.proto_file.each do |proto_file| # proto_file: <Google::Protobuf::FileDescriptorProto>
           next unless request.file_to_generate.include?(proto_file.name)
+          next if options[:skip_empty] && !proto_file.has_service?
 
           file = Google::Protobuf::Compiler::CodeGeneratorResponse::File.new
-          file.name = twirp_output_filename(proto_file.name)
-          file.content = CodeGenerator.new(proto_file, relative_ruby_protobuf(proto_file.name)).generate
+          file.name = proto_file.twirp_output_filename
+          file.content = CodeGenerator.new(proto_file, proto_file.relative_ruby_protobuf_name, options).generate
 
           response.file << file
         end
@@ -32,30 +39,49 @@ module Twirp
 
       private
 
-      # @param filename [String] a filename string (with optional path),
-      #   e.g. "some/example/hello.proto"
-      # @return [String] the filename (preserving optional path) minus the file extension,
-      #   e.g. "some/example/hello"
-      def strip_extension(filename)
-        filename.sub(/#{File.extname(filename)}$/, "")
-      end
+      # @param params [String] the parameters from protoc command line in comma-separated stringified
+      #   array format, e.g. "some-flag,key1=value1".
+      #
+      #   The only valid parameter is currently the optional "skip-empty" flag.
+      # @return [Hash{Symbol => Boolean, Symbol}]
+      #   * :skip_empty [Boolean] indicating whether generation should skip creating a twirp file
+      #       for proto files that contain no services. Default false.
+      #   * :generate [Symbol] one of: :service, :client, or :both. Default :both.
+      # @raise [ArgumentError] when a required parameter is missing, a parameter value is invalid, or
+      #   an unrecognized parameter is present on the command line
+      def extract_options(params)
+        opts = {
+          skip_empty: false,
+          generate: :both
+        }
 
-      # @param filename [String] the filename (with optional path) for the proto file,
-      #   e.g. "some/example/hello.proto"
-      # @return [String] the output filename for the proto file's generated twirp code,
-      #   e.g. "some/example/hello_twirp.rb"
-      def twirp_output_filename(filename)
-        strip_extension(filename) + "_twirp.rb"
-      end
+        # Process the options passed to the plugin from `protoc`.
+        params.split(",").each do |param|
+          # In the event value contains an =, we want to leave that intact.
+          # Limit the split to just separate the key out.
+          key, value = param.split("=", 2)
+          if key == "skip-empty"
+            unless value.nil? || value.empty?
+              raise ArgumentError, "Unexpected value passed to skip-empty flag: #{value}"
+            end
+            opts[:skip_empty] = true
+          elsif key == "generate"
+            if value.nil? || value.empty?
+              raise ArgumentError, "Unexpected missing value for generate option. Please supply one of: service, client, both."
+            end
+
+            value_as_symbol = value&.to_sym
+            unless %i[service client both].include?(value_as_symbol)
+              raise ArgumentError, "The generate value must be one of: service, client, both. Unexpectedly received: #{value}"
+            end
+
+            opts[:generate] = value_as_symbol
+          else
+            raise ArgumentError, "Invalid option: #{key}"
+          end
+        end
 
-      # @param filename [String] the filename (with optional path) for the proto file,
-      #   e.g. "some/example/hello.proto"
-      # @return [String] the file name of the generated ruby protobuf code from protoc,
-      #   without any path information, minus the ".rb" extension, e.g. "hello_pb". We
-      #   expect the generated twirp file to be in the same directory as the generated
-      #   ruby output.
-      def relative_ruby_protobuf(filename)
-        File.basename(filename, File.extname(filename)) + "_pb" # no ".rb" extension
+        opts
       end
     end
   end

data/lib/twirp/protoc_plugin/version.rb

@@ -2,6 +2,6 @@
 
 module Twirp
   module ProtocPlugin
-    VERSION = "1.0.0"
+    VERSION = "1.1.1"
   end
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: protoc-gen-twirp_ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Darron Schall
 - Daniel Morrison
 - Chris Gaffney
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-05-10 00:00:00.000000000 Z
+date: 2024-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -26,20 +26,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: racc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -96,31 +82,31 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A Ruby protoc plugin generator for Twirp-Ruby.
+description: A protoc plugin that generates Twirp-Ruby services and clients. A pure
+  Ruby alternative to the Go version that ships with Twirp-Ruby.
 email: info@collectiveidea.com
 executables:
 - protoc-gen-twirp_ruby
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".standard.yml"
 - CHANGELOG.md
 - LICENSE
 - README.md
-- Rakefile
-- example/hello_world.proto
-- example/hello_world_pb.rb
-- example/hello_world_twirp.rb
 - exe/protoc-gen-twirp_ruby
 - lib/google/protobuf/compiler/plugin_pb.rb
 - lib/google/protobuf/descriptor_pb.rb
 - lib/twirp/protoc_plugin.rb
 - lib/twirp/protoc_plugin/code_generator.rb
+- lib/twirp/protoc_plugin/compiler_plugin_ext/code_generator_request_ext.rb
+- lib/twirp/protoc_plugin/core_ext/file/delete_extension.rb
+- lib/twirp/protoc_plugin/core_ext/string/camel_case.rb
+- lib/twirp/protoc_plugin/core_ext/string/capitalize_first.rb
+- lib/twirp/protoc_plugin/core_ext/string/snake_case.rb
+- lib/twirp/protoc_plugin/descriptor_ext/file_descriptor_proto_ext.rb
+- lib/twirp/protoc_plugin/descriptor_ext/service_descriptor_proto_ext.rb
 - lib/twirp/protoc_plugin/process.rb
 - lib/twirp/protoc_plugin/version.rb
-- proto/google/protobuf/compiler/plugin.proto
-- proto/google/protobuf/descriptor.proto
 - sig/twirp/protoc_plugin.rbs
 homepage: https://github.com/collectiveidea/protoc-gen-twirp_ruby
 licenses:
@@ -130,7 +116,7 @@ metadata:
   source_code_uri: https://github.com/collectiveidea/protoc-gen-twirp_ruby
   changelog_uri: https://github.com/collectiveidea/protoc-gen-twirp_ruby/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/collectiveidea/protoc-gen-twirp_ruby/issues
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -146,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.9
-signing_key:
+signing_key: 
 specification_version: 4
-summary: A Ruby protoc plugin generator for Twirp-Ruby.
+summary: A protoc plugin for generating Twirp-Ruby clients and/or services
 test_files: []

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/.standard.yml

@@ -1,6 +0,0 @@
-# For available configuration options, see:
-#   https://github.com/standardrb/standard
-ruby_version: 3.0
-
-ignore:
-  - example/hello_world_pb.rb # ignore protoc ruby_out generated code

data/Rakefile

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-require "standard/rake"
-
-task default: %i[spec standard]

data/example/hello_world.proto

@@ -1,14 +0,0 @@
-syntax = "proto3";
-package example.hello_world;
-
-service HelloWorldService {
-  rpc Hello(HelloRequest) returns (HelloResponse);
-}
-
-message HelloRequest {
-  string name = 1;
-}
-
-message HelloResponse {
-  string message = 1;
-}

data/example/hello_world_pb.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: example/hello_world.proto
-
-require 'google/protobuf'
-
-
-descriptor_data = "\n\x19\x65xample/hello_world.proto\x12\x13\x65xample.hello_world\"\x1c\n\x0cHelloRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\" \n\rHelloResponse\x12\x0f\n\x07message\x18\x01 \x01(\t2c\n\x11HelloWorldService\x12N\n\x05Hello\x12!.example.hello_world.HelloRequest\x1a\".example.hello_world.HelloResponseb\x06proto3"
-
-pool = Google::Protobuf::DescriptorPool.generated_pool
-
-begin
-  pool.add_serialized_file(descriptor_data)
-rescue TypeError
-  # Compatibility code: will be removed in the next major version.
-  require 'google/protobuf/descriptor_pb'
-  parsed = Google::Protobuf::FileDescriptorProto.decode(descriptor_data)
-  parsed.clear_dependency
-  serialized = parsed.class.encode(parsed)
-  file = pool.add_serialized_file(serialized)
-  warn "Warning: Protobuf detected an import path issue while loading generated file #{__FILE__}"
-  imports = [
-  ]
-  imports.each do |type_name, expected_filename|
-    import_file = pool.lookup(type_name).file_descriptor
-    if import_file.name != expected_filename
-      warn "- #{file.name} imports #{expected_filename}, but that import was loaded as #{import_file.name}"
-    end
-  end
-  warn "Each proto file must use a consistent fully-qualified name."
-  warn "This will become an error in the next major version."
-end
-
-module Example
-  module HelloWorld
-    HelloRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("example.hello_world.HelloRequest").msgclass
-    HelloResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("example.hello_world.HelloResponse").msgclass
-  end
-end