| #!/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 |