From 5cfc9e775d76acb37e5b554e53dff336a89d000f Mon Sep 17 00:00:00 2001 From: Joshua Haberman Date: Wed, 3 Jan 2024 13:03:49 -0800 Subject: [PATCH] Breaking Change: Dropped support for Ruby DSL, [as previously announced](https://engdoc.corp.google.com/eng/doc/devguide/proto/news/2023-12-27.md#ruby-breaking-changes). The generated code has not used the DSL since 23.0 (released May 8, 2023). PiperOrigin-RevId: 595481605 --- ruby/BUILD.bazel | 15 - ruby/Rakefile | 4 +- ruby/lib/google/protobuf/descriptor_dsl.rb | 465 ------------------ ruby/lib/google/protobuf_ffi.rb | 3 +- ruby/lib/google/protobuf_native.rb | 1 - ruby/tests/BUILD.bazel | 35 +- ruby/tests/basic.rb | 62 +-- ruby/tests/basic_proto2.rb | 20 +- ruby/tests/basic_test.proto | 28 ++ ruby/tests/basic_test_proto2.proto | 5 + ruby/tests/common_tests.rb | 20 - ruby/tests/repeated_field_test.proto | 40 ++ ruby/tests/repeated_field_test.rb | 53 +- ruby/tests/stress.proto | 12 + ruby/tests/stress.rb | 16 +- .../compiler/ruby/ruby_generated_code_pb.rb | 24 +- .../ruby/ruby_generated_code_proto2_pb.rb | 24 +- .../ruby_generated_pkg_explicit_legacy_pb.rb | 23 +- .../ruby/ruby_generated_pkg_explicit_pb.rb | 23 +- .../ruby/ruby_generated_pkg_implicit_pb.rb | 23 +- .../protobuf/compiler/ruby/ruby_generator.cc | 23 +- 21 files changed, 134 insertions(+), 785 deletions(-) delete mode 100644 ruby/lib/google/protobuf/descriptor_dsl.rb create mode 100644 ruby/tests/repeated_field_test.proto create mode 100644 ruby/tests/stress.proto diff --git a/ruby/BUILD.bazel b/ruby/BUILD.bazel index ed9d1fd352c6d..8892af5134430 100755 --- a/ruby/BUILD.bazel +++ b/ruby/BUILD.bazel @@ -229,21 +229,6 @@ filegroup( # Tests ################################################################################ -# Define this here so the descriptor paths match what we get in Rake tests. -internal_ruby_proto_library( - name = "test_ruby_protos", - srcs = ["//ruby/tests:test_protos"], - includes = [ - ".", - "ruby/tests", - "src", - ], - visibility = [ - "//ruby:__subpackages__", - ], - deps = [":well_known_ruby_protos"], -) - conformance_test( name = "conformance_test", failure_list = "//conformance:failure_list_ruby.txt", diff --git a/ruby/Rakefile b/ruby/Rakefile index 9b50e6cb65ef2..8f5d8416a3d14 100644 --- a/ruby/Rakefile +++ b/ruby/Rakefile @@ -26,6 +26,8 @@ test_protos = %w[ tests/generated_code.proto tests/generated_code_proto2.proto tests/multi_level_nesting_test.proto + tests/repeated_field_test.proto + tests/stress.proto tests/test_import.proto tests/test_import_proto2.proto tests/test_ruby_package.proto @@ -64,7 +66,7 @@ unless ENV['IN_DOCKER'] == 'true' or ENV['BAZEL'] == 'true' output_file = proto_file.sub(/\.proto$/, "_pb.rb") genproto_output << output_file file output_file => proto_file do |file_task| - sh "#{protoc_command} -I../src -I. -I./tests --ruby_out=. #{proto_file}" + sh "#{protoc_command} -I../src -I./tests --ruby_out=tests #{proto_file}" end end end diff --git a/ruby/lib/google/protobuf/descriptor_dsl.rb b/ruby/lib/google/protobuf/descriptor_dsl.rb deleted file mode 100644 index 7349b6df15bd9..0000000000000 --- a/ruby/lib/google/protobuf/descriptor_dsl.rb +++ /dev/null @@ -1,465 +0,0 @@ -#!/usr/bin/ruby -# -# Code that implements the DSL for defining proto messages. - -# Suppress warning: loading in progress, circular require considered harmful. -# This circular require is intentional to avoid missing dependency. -begin - old_verbose, $VERBOSE = $VERBOSE, nil - require 'google/protobuf/descriptor_pb' -ensure - $VERBOSE = old_verbose -end - -module Google - module Protobuf - module Internal - class AtomicCounter - def initialize - @n = 0 - @mu = Mutex.new - end - - def get_and_increment - n = @n - @mu.synchronize { - @n += 1 - } - return n - end - end - - class Builder - @@file_number = AtomicCounter.new - - def initialize(pool) - @pool = pool - @default_file = nil # Constructed lazily - end - - def add_file(name, options={}, &block) - builder = FileBuilder.new(@pool, name, options) - builder.instance_eval(&block) - internal_add_file(builder) - end - - def add_message(name, &block) - internal_default_file.add_message(name, &block) - end - - def add_enum(name, &block) - internal_default_file.add_enum(name, &block) - end - - # ---- Internal methods, not part of the DSL ---- - - def build - if @default_file - internal_add_file(@default_file) - end - end - - private def internal_add_file(file_builder) - proto = file_builder.build - serialized = Google::Protobuf::FileDescriptorProto.encode(proto) - @pool.add_serialized_file(serialized) - end - - private def internal_default_file - number = @@file_number.get_and_increment - filename = "ruby_default_file#{number}.proto" - @default_file ||= FileBuilder.new(@pool, filename) - end - end - - class FileBuilder - def initialize(pool, name, options={}) - @pool = pool - @file_proto = Google::Protobuf::FileDescriptorProto.new( - name: name, - syntax: options.fetch(:syntax, "proto3") - ) - end - - def add_message(name, &block) - builder = MessageBuilder.new(name, self, @file_proto) - builder.instance_eval(&block) - builder.internal_add_synthetic_oneofs - end - - def add_enum(name, &block) - EnumBuilder.new(name, @file_proto).instance_eval(&block) - end - - # ---- Internal methods, not part of the DSL ---- - - # These methods fix up the file descriptor to account for differences - # between the DSL and FileDescriptorProto. - - # The DSL can omit a package name; here we infer what the package is if - # was not specified. - def infer_package(names) - # Package is longest common prefix ending in '.', if any. - if not names.empty? - min, max = names.minmax - last_common_dot = nil - min.size.times { |i| - if min[i] != max[i] then break end - if min[i] == "." then last_common_dot = i end - } - if last_common_dot - return min.slice(0, last_common_dot) - end - end - - nil - end - - def rewrite_enum_default(field) - if field.type != :TYPE_ENUM or !field.has_default_value? or !field.has_type_name? - return - end - - value = field.default_value - type_name = field.type_name - - if value.empty? or value[0].ord < "0".ord or value[0].ord > "9".ord - return - end - - if type_name.empty? || type_name[0] != "." - return - end - - type_name = type_name[1..-1] - as_int = Integer(value) rescue return - - enum_desc = @pool.lookup(type_name) - if enum_desc.is_a?(Google::Protobuf::EnumDescriptor) - # Enum was defined in a previous file. - name = enum_desc.lookup_value(as_int) - if name - # Update the default value in the proto. - field.default_value = name - end - else - # See if enum was defined in this file. - @file_proto.enum_type.each { |enum_proto| - if enum_proto.name == type_name - enum_proto.value.each { |enum_value_proto| - if enum_value_proto.number == as_int - # Update the default value in the proto. - field.default_value = enum_value_proto.name - return - end - } - # We found the right enum, but no value matched. - return - end - } - end - end - - # Historically we allowed enum defaults to be specified as a number. - # In retrospect this was a mistake as descriptors require defaults to - # be specified as a label. This can make a difference if multiple - # labels have the same number. - # - # Here we do a pass over all enum defaults and rewrite numeric defaults - # by looking up their labels. This is complicated by the fact that the - # enum definition can live in either the symtab or the file_proto. - # - # We take advantage of the fact that this is called *before* enums or - # messages are nested in other messages, so we only have to iterate - # one level deep. - def rewrite_enum_defaults - @file_proto.message_type.each { |msg| - msg.field.each { |field| - rewrite_enum_default(field) - } - } - end - - # We have to do some relatively complicated logic here for backward - # compatibility. - # - # In descriptor.proto, messages are nested inside other messages if that is - # what the original .proto file looks like. For example, suppose we have this - # foo.proto: - # - # package foo; - # message Bar { - # message Baz {} - # } - # - # The descriptor for this must look like this: - # - # file { - # name: "test.proto" - # package: "foo" - # message_type { - # name: "Bar" - # nested_type { - # name: "Baz" - # } - # } - # } - # - # However, the Ruby generated code has always generated messages in a flat, - # non-nested way: - # - # Google::Protobuf::DescriptorPool.generated_pool.build do - # add_message "foo.Bar" do - # end - # add_message "foo.Bar.Baz" do - # end - # end - # - # Here we need to do a translation where we turn this generated code into the - # above descriptor. We need to infer that "foo" is the package name, and not - # a message itself. */ - - def split_parent_name(msg_or_enum) - name = msg_or_enum.name - idx = name.rindex(?.) - if idx - return name[0...idx], name[idx+1..-1] - else - return nil, name - end - end - - def get_parent_msg(msgs_by_name, name, parent_name) - parent_msg = msgs_by_name[parent_name] - if parent_msg.nil? - raise "To define name #{name}, there must be a message named #{parent_name} to enclose it" - end - return parent_msg - end - - def fix_nesting - # Calculate and update package. - msgs_by_name = @file_proto.message_type.map { |msg| [msg.name, msg] }.to_h - enum_names = @file_proto.enum_type.map { |enum_proto| enum_proto.name } - - package = infer_package(msgs_by_name.keys + enum_names) - if package - @file_proto.package = package - end - - # Update nesting based on package. - final_msgs = Google::Protobuf::RepeatedField.new(:message, Google::Protobuf::DescriptorProto) - final_enums = Google::Protobuf::RepeatedField.new(:message, Google::Protobuf::EnumDescriptorProto) - - # Note: We don't iterate over msgs_by_name.values because we want to - # preserve order as listed in the DSL. - @file_proto.message_type.each { |msg| - parent_name, msg.name = split_parent_name(msg) - if parent_name == package - final_msgs << msg - else - get_parent_msg(msgs_by_name, msg.name, parent_name).nested_type << msg - end - } - - @file_proto.enum_type.each { |enum| - parent_name, enum.name = split_parent_name(enum) - if parent_name == package - final_enums << enum - else - get_parent_msg(msgs_by_name, enum.name, parent_name).enum_type << enum - end - } - - @file_proto.message_type = final_msgs - @file_proto.enum_type = final_enums - end - - def internal_file_proto - @file_proto - end - - def build - rewrite_enum_defaults - fix_nesting - return @file_proto - end - end - - class MessageBuilder - def initialize(name, file_builder, file_proto) - @file_builder = file_builder - @msg_proto = Google::Protobuf::DescriptorProto.new( - :name => name - ) - file_proto.message_type << @msg_proto - end - - def optional(name, type, number, type_class=nil, options=nil) - internal_add_field(:LABEL_OPTIONAL, name, type, number, type_class, options) - end - - def proto3_optional(name, type, number, type_class=nil, options=nil) - internal_add_field(:LABEL_OPTIONAL, name, type, number, type_class, options, - proto3_optional: true) - end - - def required(name, type, number, type_class=nil, options=nil) - internal_add_field(:LABEL_REQUIRED, name, type, number, type_class, options) - end - - def repeated(name, type, number, type_class = nil, options=nil) - internal_add_field(:LABEL_REPEATED, name, type, number, type_class, options) - end - - def oneof(name, &block) - OneofBuilder.new(name, self).instance_eval(&block) - end - - # Defines a new map field on this message type with the given key and - # value types, tag number, and type class (for message and enum value - # types). The key type must be :int32/:uint32/:int64/:uint64, :bool, or - # :string. The value type type must be a Ruby symbol (as accepted by - # FieldDescriptor#type=) and the type_class must be a string, if - # present (as accepted by FieldDescriptor#submsg_name=). - def map(name, key_type, value_type, number, value_type_class = nil) - if key_type == :float or key_type == :double or key_type == :enum or - key_type == :message - raise ArgError, "Not an acceptable key type: " + key_type - end - entry_name = "#{@msg_proto.name}_MapEntry_#{name}" - - @file_builder.add_message entry_name do - optional :key, key_type, 1 - optional :value, value_type, 2, value_type_class - end - options = @file_builder.internal_file_proto.message_type.last.options ||= MessageOptions.new - options.map_entry = true - repeated name, :message, number, entry_name - end - - # ---- Internal methods, not part of the DSL ---- - - def internal_add_synthetic_oneofs - # We have to build a set of all names, to ensure that synthetic oneofs - # are not creating conflicts - names = {} - @msg_proto.field.each { |field| names[field.name] = true } - @msg_proto.oneof_decl.each { |oneof| names[oneof.name] = true } - - @msg_proto.field.each { |field| - if field.proto3_optional - # Prepend '_' until we are no longer conflicting. - oneof_name = field.name - while names[oneof_name] - oneof_name = "_" + oneof_name - end - names[oneof_name] = true - field.oneof_index = @msg_proto.oneof_decl.size - @msg_proto.oneof_decl << Google::Protobuf::OneofDescriptorProto.new( - name: oneof_name - ) - end - } - end - - def internal_add_field(label, name, type, number, type_class, options, - oneof_index: nil, proto3_optional: false) - # Allow passing either: - # - (name, type, number, options) or - # - (name, type, number, type_class, options) - if options.nil? and type_class.instance_of?(Hash) - options = type_class; - type_class = nil; - end - - field_proto = Google::Protobuf::FieldDescriptorProto.new( - :label => label, - :name => name, - :type => ("TYPE_" + type.to_s.upcase).to_sym, - :number => number - ) - - if type_class - # Make it an absolute type name by prepending a dot. - field_proto.type_name = "." + type_class - end - - if oneof_index - field_proto.oneof_index = oneof_index - end - - if proto3_optional - field_proto.proto3_optional = true - end - - if options - if options.key?(:default) - default = options[:default] - if !default.instance_of?(String) - # Call #to_s since all defaults are strings in the descriptor. - default = default.to_s - end - # XXX: we should be C-escaping bytes defaults. - field_proto.default_value = default.dup.force_encoding("UTF-8") - end - if options.key?(:json_name) - field_proto.json_name = options[:json_name] - end - end - - @msg_proto.field << field_proto - end - - def internal_msg_proto - @msg_proto - end - end - - class OneofBuilder - def initialize(name, msg_builder) - @msg_builder = msg_builder - oneof_proto = Google::Protobuf::OneofDescriptorProto.new( - :name => name - ) - msg_proto = msg_builder.internal_msg_proto - @oneof_index = msg_proto.oneof_decl.size - msg_proto.oneof_decl << oneof_proto - end - - def optional(name, type, number, type_class=nil, options=nil) - @msg_builder.internal_add_field( - :LABEL_OPTIONAL, name, type, number, type_class, options, - oneof_index: @oneof_index) - end - end - - class EnumBuilder - def initialize(name, file_proto) - @enum_proto = Google::Protobuf::EnumDescriptorProto.new( - :name => name - ) - file_proto.enum_type << @enum_proto - end - - def value(name, number) - enum_value_proto = Google::Protobuf::EnumValueDescriptorProto.new( - name: name, - number: number - ) - @enum_proto.value << enum_value_proto - end - end - - end - - # Re-open the class (the rest of the class is implemented in C) - class DescriptorPool - def build(&block) - builder = Internal::Builder.new(self) - builder.instance_eval(&block) - builder.build - end - end - end -end diff --git a/ruby/lib/google/protobuf_ffi.rb b/ruby/lib/google/protobuf_ffi.rb index 12616eef16836..0839b36d3f345 100644 --- a/ruby/lib/google/protobuf_ffi.rb +++ b/ruby/lib/google/protobuf_ffi.rb @@ -21,7 +21,6 @@ require 'google/protobuf/ffi/object_cache' require 'google/protobuf/ffi/repeated_field' require 'google/protobuf/ffi/message' -require 'google/protobuf/descriptor_dsl' module Google module Protobuf @@ -47,4 +46,4 @@ def self.discard_unknown(message) nil end end -end \ No newline at end of file +end diff --git a/ruby/lib/google/protobuf_native.rb b/ruby/lib/google/protobuf_native.rb index eddaa7dd42928..9605b6b54bd7b 100644 --- a/ruby/lib/google/protobuf_native.rb +++ b/ruby/lib/google/protobuf_native.rb @@ -16,5 +16,4 @@ end end -require 'google/protobuf/descriptor_dsl' require 'google/protobuf/repeated_field' diff --git a/ruby/tests/BUILD.bazel b/ruby/tests/BUILD.bazel index 57566207c0d9a..17166b11762e2 100644 --- a/ruby/tests/BUILD.bazel +++ b/ruby/tests/BUILD.bazel @@ -1,17 +1,24 @@ load("@rules_pkg//:mappings.bzl", "pkg_files", "strip_prefix") load("@rules_ruby//ruby:defs.bzl", "ruby_library", "ruby_test") +load("//ruby:defs.bzl", "internal_ruby_proto_library") ruby_library( name = "common_tests", srcs = ["common_tests.rb"], ) -filegroup( - name = "test_protos", +internal_ruby_proto_library( + name = "test_ruby_protos", srcs = glob(["*.proto"]), + includes = [ + ".", + "ruby/tests", + "src", + ], visibility = [ "//ruby:__subpackages__", ], + deps = ["//ruby:well_known_ruby_protos"], ) ruby_test( @@ -28,8 +35,8 @@ ruby_test( srcs = ["basic.rb"], deps = [ ":common_tests", + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) @@ -39,8 +46,8 @@ ruby_test( srcs = ["basic_proto2.rb"], deps = [ ":common_tests", + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) @@ -49,8 +56,8 @@ ruby_test( name = "encode_decode_test", srcs = ["encode_decode_test.rb"], deps = [ + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) @@ -59,8 +66,8 @@ ruby_test( name = "gc_test", srcs = ["gc_test.rb"], deps = [ + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) @@ -69,8 +76,8 @@ ruby_test( name = "generated_code_test", srcs = ["generated_code_test.rb"], deps = [ + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) @@ -79,8 +86,8 @@ ruby_test( name = "multi_level_nesting_test", srcs = ["multi_level_nesting_test.rb"], deps = [ + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) @@ -89,8 +96,8 @@ ruby_test( name = "object_cache_test", srcs = ["object_cache_test.rb"], deps = [ + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) @@ -99,8 +106,8 @@ ruby_test( name = "repeated_field_test", srcs = ["repeated_field_test.rb"], deps = [ + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) @@ -109,8 +116,8 @@ ruby_test( name = "ruby_version", srcs = ["ruby_version.rb"], deps = [ + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) @@ -119,8 +126,8 @@ ruby_test( name = "stress", srcs = ["stress.rb"], deps = [ + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) @@ -129,8 +136,8 @@ ruby_test( name = "type_errors", srcs = ["type_errors.rb"], deps = [ + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) @@ -139,8 +146,8 @@ ruby_test( name = "well_known_types_test", srcs = ["well_known_types_test.rb"], deps = [ + ":test_ruby_protos", "//ruby:protobuf", - "//ruby:test_ruby_protos", "@protobuf_bundle//:test-unit", ], ) diff --git a/ruby/tests/basic.rb b/ruby/tests/basic.rb index 1e5e7a341d176..4dc45e748c201 100755 --- a/ruby/tests/basic.rb +++ b/ruby/tests/basic.rb @@ -9,20 +9,9 @@ require 'json' require 'test/unit' -# ------------- generated code -------------- - module BasicTest - pool = Google::Protobuf::DescriptorPool.new - pool.build do - add_message "BadFieldNames" do - optional :dup, :int32, 1 - optional :class, :int32, 2 - end - end - - BadFieldNames = pool.lookup("BadFieldNames").msgclass - -# ------------ test cases --------------- + TestMessage = BasicTest::TestMessage + Outer = BasicTest::Outer class MessageContainerTest < Test::Unit::TestCase # Required by CommonTests module to resolve proto3 proto classes used in tests. @@ -32,32 +21,12 @@ def proto_module include CommonTests def test_issue_8311_crash - Google::Protobuf::DescriptorPool.generated_pool.build do - add_file("inner.proto", :syntax => :proto3) do - add_message "Inner" do - # Removing either of these fixes the segfault. - optional :foo, :string, 1 - optional :bar, :string, 2 - end - end - end - - Google::Protobuf::DescriptorPool.generated_pool.build do - add_file("outer.proto", :syntax => :proto3) do - add_message "Outer" do - repeated :inners, :message, 1, "Inner" - end - end - end - - outer = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("Outer").msgclass - - outer.new( + BasicTest::Outer8311.new( inners: [] )['inners'].to_s assert_raises Google::Protobuf::TypeError do - outer.new( + BasicTest::Outer8311.new( inners: [nil] ).to_s end @@ -83,29 +52,16 @@ def test_issue_9440 end def test_issue_9507 - pool = Google::Protobuf::DescriptorPool.new - pool.build do - add_message "NpeMessage" do - optional :type, :enum, 1, "TestEnum" - optional :other, :string, 2 - end - add_enum "TestEnum" do - value :Something, 0 - end - end - - msgclass = pool.lookup("NpeMessage").msgclass - - m = msgclass.new( + m = BasicTest::NpeMessage.new( other: "foo" # must be set, but can be blank ) begin - encoded = msgclass.encode(m) + encoded = BasicTest::NpeMessage.encode(m) rescue java.lang.NullPointerException flunk "NPE rescued" end - decoded = msgclass.decode(encoded) + decoded = BasicTest::NpeMessage.decode(encoded) decoded.inspect decoded.to_proto end @@ -609,12 +565,12 @@ def test_respond_to def test_file_descriptor file_descriptor = TestMessage.descriptor.file_descriptor refute_nil file_descriptor - assert_equal "tests/basic_test.proto", file_descriptor.name + assert_equal "basic_test.proto", file_descriptor.name assert_equal :proto3, file_descriptor.syntax file_descriptor = TestEnum.descriptor.file_descriptor refute_nil file_descriptor - assert_equal "tests/basic_test.proto", file_descriptor.name + assert_equal "basic_test.proto", file_descriptor.name assert_equal :proto3, file_descriptor.syntax end diff --git a/ruby/tests/basic_proto2.rb b/ruby/tests/basic_proto2.rb index 1eefc6ff8d94b..26c253437db51 100755 --- a/ruby/tests/basic_proto2.rb +++ b/ruby/tests/basic_proto2.rb @@ -9,23 +9,7 @@ require 'json' require 'test/unit' -# ------------- generated code -------------- - module BasicTestProto2 - pool = Google::Protobuf::DescriptorPool.new - pool.build do - add_file "test_proto2.proto", syntax: :proto2 do - add_message "BadFieldNames" do - optional :dup, :int32, 1 - optional :class, :int32, 2 - end - end - end - - BadFieldNames = pool.lookup("BadFieldNames").msgclass - -# ------------ test cases --------------- - class MessageContainerTest < Test::Unit::TestCase # Required by CommonTests module to resolve proto2 proto classes used in tests. def proto_module @@ -246,12 +230,12 @@ def test_respond_to def test_file_descriptor file_descriptor = TestMessage.descriptor.file_descriptor refute_nil file_descriptor - assert_equal "tests/basic_test_proto2.proto", file_descriptor.name + assert_equal "basic_test_proto2.proto", file_descriptor.name assert_equal :proto2, file_descriptor.syntax file_descriptor = TestEnum.descriptor.file_descriptor refute_nil file_descriptor - assert_equal "tests/basic_test_proto2.proto", file_descriptor.name + assert_equal "basic_test_proto2.proto", file_descriptor.name assert_equal :proto2, file_descriptor.syntax end diff --git a/ruby/tests/basic_test.proto b/ruby/tests/basic_test.proto index 8feab6ed636e9..5c9bb6012e777 100644 --- a/ruby/tests/basic_test.proto +++ b/ruby/tests/basic_test.proto @@ -285,3 +285,31 @@ message HelloRequest { optional uint32 random_name_c9 = 31; optional string version = 32; } + +message BadFieldNames { + optional int32 dup = 1; + optional int32 class = 2; +} + +// Messages to test the fix for +// https://github.com/protocolbuffers/protobuf/issues/8311. +message Inner8311 { + // Removing either of these fixes the segfault. + optional string foo = 1; + optional string bar = 2; +} + +message Outer8311 { + repeated Inner8311 inners = 1; +} + +// Messages to test the fix for +// https://github.com/protocolbuffers/protobuf/issues/9507 +message NpeMessage { + optional TestEnum9507 type = 1; + optional string other = 2; +} + +enum TestEnum9507 { + Something = 0; +} diff --git a/ruby/tests/basic_test_proto2.proto b/ruby/tests/basic_test_proto2.proto index 777b4dd776569..85d61cf6b14ac 100644 --- a/ruby/tests/basic_test_proto2.proto +++ b/ruby/tests/basic_test_proto2.proto @@ -231,3 +231,8 @@ message TestMessageSetExtension3 { extend TestMessageSet { optional TestMessageSetExtension3 message_set_extension3 = 98418655; } + +message BadFieldNames { + optional int32 dup = 1; + optional int32 class = 2; +} diff --git a/ruby/tests/common_tests.rb b/ruby/tests/common_tests.rb index 52e08459850fb..dd2ad39adc2e2 100644 --- a/ruby/tests/common_tests.rb +++ b/ruby/tests/common_tests.rb @@ -855,26 +855,6 @@ def test_protobuf_encode_decode_json_helpers assert_equal proto_module::TestMessage.decode_json([m.to_json].first), decoded_msg end - def test_def_errors - s = Google::Protobuf::DescriptorPool.new - assert_raises Google::Protobuf::TypeError do - s.build do - # enum with no default (integer value 0) - add_enum "MyEnum" do - value :A, 1 - end - end - end - assert_raises Google::Protobuf::TypeError do - s.build do - # message with required field (unsupported in proto3) - add_message "MyMessage" do - required :foo, :int32, 1 - end - end - end - end - def test_corecursive # just be sure that we can instantiate types with corecursive field-type # references. diff --git a/ruby/tests/repeated_field_test.proto b/ruby/tests/repeated_field_test.proto new file mode 100644 index 0000000000000..9bcb3fca7ccf3 --- /dev/null +++ b/ruby/tests/repeated_field_test.proto @@ -0,0 +1,40 @@ +syntax = "proto3"; + +package repeated_field_test_protos; + +message TestMessage { + optional int32 optional_int32 = 1; + optional int64 optional_int64 = 2; + optional uint32 optional_uint32 = 3; + optional uint64 optional_uint64 = 4; + optional bool optional_bool = 5; + optional float optional_float = 6; + optional double optional_double = 7; + optional string optional_string = 8; + optional bytes optional_bytes = 9; + optional TestMessage2 optional_msg = 10; + optional TestEnum optional_enum = 11; + repeated int32 repeated_int32 = 12; + repeated int64 repeated_int64 = 13; + repeated uint32 repeated_uint32 = 14; + repeated uint64 repeated_uint64 = 15; + repeated bool repeated_bool = 16; + repeated float repeated_float = 17; + repeated double repeated_double = 18; + repeated string repeated_string = 19; + repeated bytes repeated_bytes = 20; + repeated TestMessage2 repeated_msg = 21; + repeated TestEnum repeated_enum = 22; +} + +message TestMessage2 { + optional int32 foo = 1; +} + +enum TestEnum { + DEFAULT = 0; + A = 1; + B = 2; + C = 3; + V0 = 4; +} diff --git a/ruby/tests/repeated_field_test.rb b/ruby/tests/repeated_field_test.rb index 293b4e42e17b3..492d9d928fe00 100755 --- a/ruby/tests/repeated_field_test.rb +++ b/ruby/tests/repeated_field_test.rb @@ -1,9 +1,12 @@ #!/usr/bin/ruby require 'google/protobuf' +require 'repeated_field_test_pb' require 'test/unit' class RepeatedFieldTest < Test::Unit::TestCase + TestMessage = RepeatedFieldTestProtos::TestMessage + TestMessage2 = RepeatedFieldTestProtos::TestMessage2 def test_acts_like_enumerator m = TestMessage.new @@ -281,7 +284,7 @@ def test_array_settor m.repeated_msg[3] = TestMessage2.new(:foo => 1) assert_equal [nil, nil, nil, TestMessage2.new(:foo => 1)], m.repeated_msg m.repeated_enum[3] = :A - assert_equal [:Default, :Default, :Default, :A], m.repeated_enum + assert_equal [:DEFAULT, :DEFAULT, :DEFAULT, :A], m.repeated_enum # check_self_modifying_method(m.repeated_string, reference_arr) do |arr| # arr[20] = 'spacious' @@ -674,52 +677,4 @@ def fill_test_msg(test_msg) test_msg.repeated_enum << :A test_msg.repeated_enum << :B end - - - pool = Google::Protobuf::DescriptorPool.new - pool.build do - - add_message "TestMessage" do - optional :optional_int32, :int32, 1 - optional :optional_int64, :int64, 2 - optional :optional_uint32, :uint32, 3 - optional :optional_uint64, :uint64, 4 - optional :optional_bool, :bool, 5 - optional :optional_float, :float, 6 - optional :optional_double, :double, 7 - optional :optional_string, :string, 8 - optional :optional_bytes, :bytes, 9 - optional :optional_msg, :message, 10, "TestMessage2" - optional :optional_enum, :enum, 11, "TestEnum" - - repeated :repeated_int32, :int32, 12 - repeated :repeated_int64, :int64, 13 - repeated :repeated_uint32, :uint32, 14 - repeated :repeated_uint64, :uint64, 15 - repeated :repeated_bool, :bool, 16 - repeated :repeated_float, :float, 17 - repeated :repeated_double, :double, 18 - repeated :repeated_string, :string, 19 - repeated :repeated_bytes, :bytes, 20 - repeated :repeated_msg, :message, 21, "TestMessage2" - repeated :repeated_enum, :enum, 22, "TestEnum" - end - add_message "TestMessage2" do - optional :foo, :int32, 1 - end - - add_enum "TestEnum" do - value :Default, 0 - value :A, 1 - value :B, 2 - value :C, 3 - value :v0, 4 - end - end - - TestMessage = pool.lookup("TestMessage").msgclass - TestMessage2 = pool.lookup("TestMessage2").msgclass - TestEnum = pool.lookup("TestEnum").enummodule - - end diff --git a/ruby/tests/stress.proto b/ruby/tests/stress.proto new file mode 100644 index 0000000000000..517e74638c98a --- /dev/null +++ b/ruby/tests/stress.proto @@ -0,0 +1,12 @@ +syntax = "proto3"; + +package stress_test_protos; + +message TestMessage { + int32 a = 1; + repeated M b = 2; +} + +message M { + string foo = 1; +} diff --git a/ruby/tests/stress.rb b/ruby/tests/stress.rb index b688e8b0bd4df..4ad37c171cad5 100755 --- a/ruby/tests/stress.rb +++ b/ruby/tests/stress.rb @@ -1,22 +1,12 @@ #!/usr/bin/ruby require 'google/protobuf' +require 'stress_pb' require 'test/unit' module StressTest - pool = Google::Protobuf::DescriptorPool.new - pool.build do - add_message "TestMessage" do - optional :a, :int32, 1 - repeated :b, :message, 2, "M" - end - add_message "M" do - optional :foo, :string, 1 - end - end - - TestMessage = pool.lookup("TestMessage").msgclass - M = pool.lookup("M").msgclass + TestMessage = StressTestProtos::TestMessage + M = StressTestProtos::M class StressTest < Test::Unit::TestCase def get_msg diff --git a/src/google/protobuf/compiler/ruby/ruby_generated_code_pb.rb b/src/google/protobuf/compiler/ruby/ruby_generated_code_pb.rb index 6c24134efceb9..cf37b715b3ff2 100644 --- a/src/google/protobuf/compiler/ruby/ruby_generated_code_pb.rb +++ b/src/google/protobuf/compiler/ruby/ruby_generated_code_pb.rb @@ -10,29 +10,7 @@ descriptor_data = "\n\x19ruby_generated_code.proto\x12\x05\x41.B.C\x1a\'ruby_generated_code_proto2_import.proto\"\x86\x12\n\x0bTestMessage\x12\x16\n\x0eoptional_int32\x18\x01 \x01(\x05\x12\x16\n\x0eoptional_int64\x18\x02 \x01(\x03\x12\x17\n\x0foptional_uint32\x18\x03 \x01(\r\x12\x17\n\x0foptional_uint64\x18\x04 \x01(\x04\x12\x15\n\roptional_bool\x18\x05 \x01(\x08\x12\x17\n\x0foptional_double\x18\x06 \x01(\x01\x12\x16\n\x0eoptional_float\x18\x07 \x01(\x02\x12\x17\n\x0foptional_string\x18\x08 \x01(\t\x12\x16\n\x0eoptional_bytes\x18\t \x01(\x0c\x12&\n\roptional_enum\x18\n \x01(\x0e\x32\x0f.A.B.C.TestEnum\x12(\n\x0coptional_msg\x18\x0b \x01(\x0b\x32\x12.A.B.C.TestMessage\x12>\n\x1aoptional_proto2_submessage\x18\x0c \x01(\x0b\x32\x1a.A.B.C.TestImportedMessage\x12\x16\n\x0erepeated_int32\x18\x15 \x03(\x05\x12\x16\n\x0erepeated_int64\x18\x16 \x03(\x03\x12\x17\n\x0frepeated_uint32\x18\x17 \x03(\r\x12\x17\n\x0frepeated_uint64\x18\x18 \x03(\x04\x12\x15\n\rrepeated_bool\x18\x19 \x03(\x08\x12\x17\n\x0frepeated_double\x18\x1a \x03(\x01\x12\x16\n\x0erepeated_float\x18\x1b \x03(\x02\x12\x17\n\x0frepeated_string\x18\x1c \x03(\t\x12\x16\n\x0erepeated_bytes\x18\x1d \x03(\x0c\x12&\n\rrepeated_enum\x18\x1e \x03(\x0e\x32\x0f.A.B.C.TestEnum\x12(\n\x0crepeated_msg\x18\x1f \x03(\x0b\x32\x12.A.B.C.TestMessage\x12\x15\n\x0boneof_int32\x18) \x01(\x05H\x00\x12\x15\n\x0boneof_int64\x18* \x01(\x03H\x00\x12\x16\n\x0coneof_uint32\x18+ \x01(\rH\x00\x12\x16\n\x0coneof_uint64\x18, \x01(\x04H\x00\x12\x14\n\noneof_bool\x18- \x01(\x08H\x00\x12\x16\n\x0coneof_double\x18. \x01(\x01H\x00\x12\x15\n\x0boneof_float\x18/ \x01(\x02H\x00\x12\x16\n\x0coneof_string\x18\x30 \x01(\tH\x00\x12\x15\n\x0boneof_bytes\x18\x31 \x01(\x0cH\x00\x12%\n\noneof_enum\x18\x32 \x01(\x0e\x32\x0f.A.B.C.TestEnumH\x00\x12\'\n\toneof_msg\x18\x33 \x01(\x0b\x32\x12.A.B.C.TestMessageH\x00\x12@\n\x10map_int32_string\x18= \x03(\x0b\x32&.A.B.C.TestMessage.MapInt32StringEntry\x12@\n\x10map_int64_string\x18> \x03(\x0b\x32&.A.B.C.TestMessage.MapInt64StringEntry\x12\x42\n\x11map_uint32_string\x18? \x03(\x0b\x32\'.A.B.C.TestMessage.MapUint32StringEntry\x12\x42\n\x11map_uint64_string\x18@ \x03(\x0b\x32\'.A.B.C.TestMessage.MapUint64StringEntry\x12>\n\x0fmap_bool_string\x18\x41 \x03(\x0b\x32%.A.B.C.TestMessage.MapBoolStringEntry\x12\x42\n\x11map_string_string\x18\x42 \x03(\x0b\x32\'.A.B.C.TestMessage.MapStringStringEntry\x12<\n\x0emap_string_msg\x18\x43 \x03(\x0b\x32$.A.B.C.TestMessage.MapStringMsgEntry\x12>\n\x0fmap_string_enum\x18\x44 \x03(\x0b\x32%.A.B.C.TestMessage.MapStringEnumEntry\x12@\n\x10map_string_int32\x18\x45 \x03(\x0b\x32&.A.B.C.TestMessage.MapStringInt32Entry\x12>\n\x0fmap_string_bool\x18\x46 \x03(\x0b\x32%.A.B.C.TestMessage.MapStringBoolEntry\x12\x38\n\x0enested_message\x18P \x01(\x0b\x32 .A.B.C.TestMessage.NestedMessage\x1a\x35\n\x13MapInt32StringEntry\x12\x0b\n\x03key\x18\x01 \x01(\x05\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1a\x35\n\x13MapInt64StringEntry\x12\x0b\n\x03key\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1a\x36\n\x14MapUint32StringEntry\x12\x0b\n\x03key\x18\x01 \x01(\r\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1a\x36\n\x14MapUint64StringEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1a\x34\n\x12MapBoolStringEntry\x12\x0b\n\x03key\x18\x01 \x01(\x08\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1a\x36\n\x14MapStringStringEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x1aG\n\x11MapStringMsgEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12!\n\x05value\x18\x02 \x01(\x0b\x32\x12.A.B.C.TestMessage:\x02\x38\x01\x1a\x45\n\x12MapStringEnumEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x1e\n\x05value\x18\x02 \x01(\x0e\x32\x0f.A.B.C.TestEnum:\x02\x38\x01\x1a\x35\n\x13MapStringInt32Entry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x05:\x02\x38\x01\x1a\x34\n\x12MapStringBoolEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x08:\x02\x38\x01\x1a\x1c\n\rNestedMessage\x12\x0b\n\x03\x66oo\x18\x01 \x01(\x05\x42\n\n\x08my_oneof*,\n\x08TestEnum\x12\x0b\n\x07\x44\x65\x66\x61ult\x10\x00\x12\x05\n\x01\x41\x10\x01\x12\x05\n\x01\x42\x10\x02\x12\x05\n\x01\x43\x10\x03\x62\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 = [ - ["A.B.C.TestImportedMessage", "ruby_generated_code_proto2_import.proto"], - ] - 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 +pool.add_serialized_file(descriptor_data) module A module B diff --git a/src/google/protobuf/compiler/ruby/ruby_generated_code_proto2_pb.rb b/src/google/protobuf/compiler/ruby/ruby_generated_code_proto2_pb.rb index 064959825d797..053bfea8ad5e3 100644 --- a/src/google/protobuf/compiler/ruby/ruby_generated_code_proto2_pb.rb +++ b/src/google/protobuf/compiler/ruby/ruby_generated_code_proto2_pb.rb @@ -10,29 +10,7 @@ descriptor_data = "\n ruby_generated_code_proto2.proto\x12\x05\x41.B.C\x1a\'ruby_generated_code_proto2_import.proto\"\x96\x0b\n\x0bTestMessage\x12\x19\n\x0eoptional_int32\x18\x01 \x01(\x05:\x01\x31\x12\x19\n\x0eoptional_int64\x18\x02 \x01(\x03:\x01\x32\x12\x1a\n\x0foptional_uint32\x18\x03 \x01(\r:\x01\x33\x12\x1a\n\x0foptional_uint64\x18\x04 \x01(\x04:\x01\x34\x12\x1b\n\roptional_bool\x18\x05 \x01(\x08:\x04true\x12\x1a\n\x0foptional_double\x18\x06 \x01(\x01:\x01\x36\x12\x19\n\x0eoptional_float\x18\x07 \x01(\x02:\x01\x37\x12$\n\x0foptional_string\x18\x08 \x01(\t:\x0b\x64\x65\x66\x61ult str\x12*\n\x0eoptional_bytes\x18\t \x01(\x0c:\x12\\000\\001\\002@fubar\x12)\n\roptional_enum\x18\n \x01(\x0e\x32\x0f.A.B.C.TestEnum:\x01\x41\x12(\n\x0coptional_msg\x18\x0b \x01(\x0b\x32\x12.A.B.C.TestMessage\x12>\n\x1aoptional_proto2_submessage\x18\x0c \x01(\x0b\x32\x1a.A.B.C.TestImportedMessage\x12\x16\n\x0erepeated_int32\x18\x15 \x03(\x05\x12\x16\n\x0erepeated_int64\x18\x16 \x03(\x03\x12\x17\n\x0frepeated_uint32\x18\x17 \x03(\r\x12\x17\n\x0frepeated_uint64\x18\x18 \x03(\x04\x12\x15\n\rrepeated_bool\x18\x19 \x03(\x08\x12\x17\n\x0frepeated_double\x18\x1a \x03(\x01\x12\x16\n\x0erepeated_float\x18\x1b \x03(\x02\x12\x17\n\x0frepeated_string\x18\x1c \x03(\t\x12\x16\n\x0erepeated_bytes\x18\x1d \x03(\x0c\x12&\n\rrepeated_enum\x18\x1e \x03(\x0e\x32\x0f.A.B.C.TestEnum\x12(\n\x0crepeated_msg\x18\x1f \x03(\x0b\x32\x12.A.B.C.TestMessage\x12\x16\n\x0erequired_int32\x18) \x02(\x05\x12\x16\n\x0erequired_int64\x18* \x02(\x03\x12\x17\n\x0frequired_uint32\x18+ \x02(\r\x12\x17\n\x0frequired_uint64\x18, \x02(\x04\x12\x15\n\rrequired_bool\x18- \x02(\x08\x12\x17\n\x0frequired_double\x18. \x02(\x01\x12\x16\n\x0erequired_float\x18/ \x02(\x02\x12\x17\n\x0frequired_string\x18\x30 \x02(\t\x12\x16\n\x0erequired_bytes\x18\x31 \x02(\x0c\x12&\n\rrequired_enum\x18\x32 \x02(\x0e\x32\x0f.A.B.C.TestEnum\x12(\n\x0crequired_msg\x18\x33 \x02(\x0b\x32\x12.A.B.C.TestMessage\x12\x15\n\x0boneof_int32\x18= \x01(\x05H\x00\x12\x15\n\x0boneof_int64\x18> \x01(\x03H\x00\x12\x16\n\x0coneof_uint32\x18? \x01(\rH\x00\x12\x16\n\x0coneof_uint64\x18@ \x01(\x04H\x00\x12\x14\n\noneof_bool\x18\x41 \x01(\x08H\x00\x12\x16\n\x0coneof_double\x18\x42 \x01(\x01H\x00\x12\x15\n\x0boneof_float\x18\x43 \x01(\x02H\x00\x12\x16\n\x0coneof_string\x18\x44 \x01(\tH\x00\x12\x15\n\x0boneof_bytes\x18\x45 \x01(\x0cH\x00\x12%\n\noneof_enum\x18\x46 \x01(\x0e\x32\x0f.A.B.C.TestEnumH\x00\x12\'\n\toneof_msg\x18G \x01(\x0b\x32\x12.A.B.C.TestMessageH\x00\x12\x38\n\x0enested_message\x18P \x01(\x0b\x32 .A.B.C.TestMessage.NestedMessage\x1a\x1c\n\rNestedMessage\x12\x0b\n\x03\x66oo\x18\x01 \x01(\x05\x42\n\n\x08my_oneof*,\n\x08TestEnum\x12\x0b\n\x07\x44\x65\x66\x61ult\x10\x00\x12\x05\n\x01\x41\x10\x01\x12\x05\n\x01\x42\x10\x02\x12\x05\n\x01\x43\x10\x03" 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 = [ - ["A.B.C.TestImportedMessage", "ruby_generated_code_proto2_import.proto"], - ] - 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 +pool.add_serialized_file(descriptor_data) module A module B diff --git a/src/google/protobuf/compiler/ruby/ruby_generated_pkg_explicit_legacy_pb.rb b/src/google/protobuf/compiler/ruby/ruby_generated_pkg_explicit_legacy_pb.rb index bb8cc106152f9..69f774539c82d 100644 --- a/src/google/protobuf/compiler/ruby/ruby_generated_pkg_explicit_legacy_pb.rb +++ b/src/google/protobuf/compiler/ruby/ruby_generated_pkg_explicit_legacy_pb.rb @@ -8,28 +8,7 @@ descriptor_data = "\n(ruby_generated_pkg_explicit_legacy.proto\x12\x13one.two.a_three.and\"\x1e\n\x04\x46our\x12\x16\n\x0e\x61nother_string\x18\x01 \x01(\tB\x0b\xea\x02\x08\x41\x41.BB.CCb\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 +pool.add_serialized_file(descriptor_data) module AA module BB diff --git a/src/google/protobuf/compiler/ruby/ruby_generated_pkg_explicit_pb.rb b/src/google/protobuf/compiler/ruby/ruby_generated_pkg_explicit_pb.rb index 4d49ff8ffe552..f241bd927ad7e 100644 --- a/src/google/protobuf/compiler/ruby/ruby_generated_pkg_explicit_pb.rb +++ b/src/google/protobuf/compiler/ruby/ruby_generated_pkg_explicit_pb.rb @@ -8,28 +8,7 @@ descriptor_data = "\n!ruby_generated_pkg_explicit.proto\x12\x0fone.two.a_three\"\x18\n\x04\x46our\x12\x10\n\x08\x61_string\x18\x01 \x01(\tB\n\xea\x02\x07\x41::B::Cb\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 +pool.add_serialized_file(descriptor_data) module A module B diff --git a/src/google/protobuf/compiler/ruby/ruby_generated_pkg_implicit_pb.rb b/src/google/protobuf/compiler/ruby/ruby_generated_pkg_implicit_pb.rb index 7235a16ccd01e..7c652df7ec62e 100644 --- a/src/google/protobuf/compiler/ruby/ruby_generated_pkg_implicit_pb.rb +++ b/src/google/protobuf/compiler/ruby/ruby_generated_pkg_implicit_pb.rb @@ -8,28 +8,7 @@ descriptor_data = "\n!ruby_generated_pkg_implicit.proto\x12\x0fone.two.a_three\"\x18\n\x04\x46our\x12\x10\n\x08\x61_string\x18\x01 \x01(\tb\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 +pool.add_serialized_file(descriptor_data) module One module Two diff --git a/src/google/protobuf/compiler/ruby/ruby_generator.cc b/src/google/protobuf/compiler/ruby/ruby_generator.cc index 1d85046b24a19..82f1a9556a54c 100644 --- a/src/google/protobuf/compiler/ruby/ruby_generator.cc +++ b/src/google/protobuf/compiler/ruby/ruby_generator.cc @@ -253,28 +253,7 @@ void GenerateBinaryDescriptor(const FileDescriptor* file, io::Printer* printer, descriptor_data = "$descriptor_data$" 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$ ] - 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 +pool.add_serialized_file(descriptor_data) )", "descriptor_data",