protobuf 3.7.0.pre2 → 3.7.0.pre3

data/lib/protobuf/generators/base.rb

@@ -15,16 +15,10 @@ module Protobuf
         end
 
         unless ENV.key?('PB_NO_TAG_WARNINGS')
-          range = (tags.min)..(tags.max)
-          if range.respond_to?(:size)
-            expected_size = range.size
-          else
-            expected_size = range.to_a.size
-          end
-
+          expected_size = tags.max - tags.min + 1
           if tags.size < expected_size
             ::Protobuf::CodeGenerator.print_tag_warning_suppress
-            ::Protobuf::CodeGenerator.warn("#{type_name} object should have #{expected_size} tags (#{range.begin}..#{range.end}), but found #{tags.size} tags.")
+            ::Protobuf::CodeGenerator.warn("#{type_name} object should have #{expected_size} tags (#{tags.min}..#{tags.max}), but found #{tags.size} tags.")
           end
         end
       end
@@ -42,18 +36,18 @@ module Protobuf
         ".#{type_namespace.join('.')}"
       end
 
-      def run_once(label, &block)
+      def run_once(label)
         tracker_ivar = "@_#{label}_compiled"
         value_ivar = "@_#{label}_compiled_value"
 
         if instance_variable_get(tracker_ivar)
           return instance_variable_get(value_ivar)
-        else
-          return_value = block.call
-          instance_variable_set(tracker_ivar, true)
-          instance_variable_set(value_ivar, return_value)
-          return return_value
         end
+
+        return_value = yield
+        instance_variable_set(tracker_ivar, true)
+        instance_variable_set(value_ivar, return_value)
+        return_value
       end
 
       def to_s
@@ -65,6 +59,27 @@ module Protobuf
         @type_namespace ||= @namespace + [descriptor.name]
       end
 
+      def serialize_value(value)
+        case value
+        when Message
+          fields = value.each_field.map do |field, inner_value|
+            next unless value.field?(field.name)
+            serialized_inner_value = serialize_value(inner_value)
+            "#{field.fully_qualified_name.inspect} => #{serialized_inner_value}"
+          end.compact
+          "{ #{fields.join(', ')} }"
+        when Enum
+          "::#{value.parent_class}::#{value.name}"
+        when String
+          value.inspect
+        when nil
+          "nil"
+        when Array
+          '[' + value.map { |x| serialize_value(x) }.join(', ') + ']'
+        else
+          value
+        end
+      end
     end
   end
 end

data/lib/protobuf/generators/enum_generator.rb

@@ -1,20 +1,17 @@
 require 'protobuf/generators/base'
+require 'protobuf/generators/option_generator'
 
 module Protobuf
   module Generators
     class EnumGenerator < Base
 
-      def allow_alias?
-        descriptor.options.try(:allow_alias!) { false }
-      end
-
       def compile
         run_once(:compile) do
           tags = []
 
           print_class(descriptor.name, :enum) do
-            if allow_alias?
-              puts "set_option :allow_alias"
+            if descriptor.options
+              print OptionGenerator.new(descriptor.options, current_indent).to_s
               puts
             end
 
@@ -24,7 +21,7 @@ module Protobuf
             end
           end
 
-          unless allow_alias?
+          unless descriptor.options.try(:allow_alias)
             self.class.validate_tags(fully_qualified_type_namespace, tags)
           end
         end

data/lib/protobuf/generators/field_generator.rb

@@ -7,9 +7,9 @@ module Protobuf
       ##
       # Constants
       #
-      PROTO_INFINITY_DEFAULT          = /^inf$/i.freeze
-      PROTO_NEGATIVE_INFINITY_DEFAULT = /^-inf$/i.freeze
-      PROTO_NAN_DEFAULT               = /^nan$/i.freeze
+      PROTO_INFINITY_DEFAULT          = /^inf$/i
+      PROTO_NEGATIVE_INFINITY_DEFAULT = /^-inf$/i
+      PROTO_NAN_DEFAULT               = /^nan$/i
       RUBY_INFINITY_DEFAULT           = '::Float::INFINITY'.freeze
       RUBY_NEGATIVE_INFINITY_DEFAULT  = '-::Float::INFINITY'.freeze
       RUBY_NAN_DEFAULT                = '::Float::NAN'.freeze
@@ -84,6 +84,13 @@ module Protobuf
                              opts[:packed] = 'true' if packed?
                              opts[:deprecated] = 'true' if deprecated?
                              opts[:extension] = 'true' if extension?
+                             if descriptor.options
+                               descriptor.options.each_field do |field_option|
+                                 next unless descriptor.options.field?(field_option.name)
+                                 option_value = descriptor.options[field_option.name]
+                                 opts[field_option.fully_qualified_name] = serialize_value(option_value)
+                               end
+                             end
                              opts
                            end
       end
@@ -108,7 +115,13 @@ module Protobuf
       private
 
       def enum_default_value
-        "#{type_name}::#{verbatim_default_value}"
+        optionally_upcased_default =
+          if ENV.key?('PB_UPCASE_ENUMS')
+            verbatim_default_value.upcase
+          else
+            verbatim_default_value
+          end
+        "#{type_name}::#{optionally_upcased_default}"
       end
 
       def float_double_default_value

data/lib/protobuf/generators/file_generator.rb

@@ -12,7 +12,8 @@ module Protobuf
         super
         @output_file = ::Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(:name => file_name)
         @extension_fields = Hash.new { |h, k| h[k] = [] }
-        @known_messages = []
+        @known_messages = {}
+        @known_enums = {}
         @dangling_messages = {}
       end
 
@@ -31,6 +32,7 @@ module Protobuf
           print_package do
             inject_optionable
             group = GroupGenerator.new(current_indent)
+            group.add_options(descriptor.options) if descriptor.options
             group.add_enums(descriptor.enum_type, :namespace => [descriptor.package])
             group.add_message_declarations(descriptor.message_type)
             group.add_messages(descriptor.message_type, :extension_fields => @extension_fields, :namespace => [descriptor.package])
@@ -39,6 +41,7 @@ module Protobuf
 
             group.add_header(:enum, 'Enum Classes')
             group.add_header(:message_declaration, 'Message Classes')
+            group.add_header(:options, 'File Options')
             group.add_header(:message, 'Message Fields')
             group.add_header(:extended_message, 'Extended Message Fields')
             group.add_header(:service, 'Service Classes')
@@ -49,8 +52,16 @@ module Protobuf
       end
 
       def unknown_extensions
-        @unknown_extensions ||= @extension_fields.reject do |k, _|
-          @known_messages.include?(k)
+        @unknown_extensions ||= @extension_fields.map do |message_name, fields|
+          message_klass = modulize(message_name).safe_constantize
+          if message_klass
+            unknown_fields = fields.reject do |field|
+              @known_messages[message_name] && message_klass.get_field(field.name, true)
+            end
+            [message_name, unknown_fields]
+          else
+            [message_name, fields]
+          end
         end
       end
 
@@ -72,12 +83,10 @@ module Protobuf
         end
         # Record all the message descriptor name's we encounter (should be the whole tree).
         if descriptor.is_a?(::Google::Protobuf::DescriptorProto)
-          if fully_qualified_token?(descriptor.name)
-            @known_messages << descriptor.name
-          else
-            fully_qualified_namespace = ".#{namespaces.join('.')}"
-            @known_messages << fully_qualified_namespace
-          end
+          @known_messages[fully_qualified_namespace || descriptor.name] = descriptor
+        elsif descriptor.is_a?(::Google::Protobuf::EnumDescriptorProto)
+          @known_enums[fully_qualified_namespace || descriptor.name] = descriptor
+          return
         end
 
         descriptor.extension.each do |field_descriptor|
@@ -87,7 +96,7 @@ module Protobuf
           @extension_fields[field_descriptor.extendee] << field_descriptor
         end
 
-        [:message_type, :nested_type].each do |type|
+        [:message_type, :nested_type, :enum_type].each do |type|
           next unless descriptor.respond_to_has_and_present?(type)
 
           descriptor.public_send(type).each do |type_descriptor|
@@ -132,6 +141,38 @@ module Protobuf
         end.call
       end
 
+      def eval_unknown_extensions!
+        @@evaled_dependencies ||= Set.new # rubocop:disable Style/ClassVars
+        @@all_messages ||= {} # rubocop:disable Style/ClassVars
+        @@all_enums ||= {} # rubocop:disable Style/ClassVars
+
+        map_extensions(descriptor, [descriptor.package])
+        @known_messages.each do |name, descriptor|
+          @@all_messages[name] = descriptor
+        end
+        @known_enums.each do |name, descriptor|
+          @@all_enums[name] = descriptor
+        end
+
+        # create package namespace
+        print_package {}
+        eval_code
+
+        unknown_extensions.each do |extendee, fields|
+          eval_dependencies(extendee)
+          fields.each do |field|
+            eval_dependencies(field.type_name)
+          end
+        end
+        group = GroupGenerator.new(0)
+        group.add_extended_messages(unknown_extensions, false)
+        print group.to_s
+        eval_code
+      rescue => e
+        warn "Error loading unknown extensions #{descriptor.name.inspect} error=#{e}"
+        raise e
+      end
+
       private
 
       def convert_filename(filename, for_require = true)
@@ -142,6 +183,76 @@ module Protobuf
         token[0] == '.'
       end
 
+      def eval_dependencies(name, namespace = nil)
+        name = "#{namespace}.#{name}" if namespace && !fully_qualified_token?(name)
+        return if name.empty? || @@evaled_dependencies.include?(name) || modulize(name).safe_constantize
+
+        # if name = .foo.bar.Baz look for classes / modules named ::Foo::Bar and ::Foo
+        # module == pure namespace (e.g. the descriptor package name)
+        # class == nested messages
+        create_ruby_namespace_heiarchy(name)
+
+        if (message = @@all_messages[name])
+          # Create the blank namespace in case there are nested types
+          eval_message_code(name)
+
+          message.nested_type.each do |nested_type|
+            eval_dependencies(nested_type.name, name) unless nested_type.name.empty?
+          end
+          message.field.each do |field|
+            eval_dependencies(field.type_name, name) unless field.type_name.empty?
+          end
+          message.enum_type.each do |enum_type|
+            eval_dependencies(enum_type.name, name)
+          end
+
+          # Check @@evaled_dependencies again in case there was a dependency
+          # loop that already loaded this message
+          return if @@evaled_dependencies.include?(name)
+          eval_message_code(name, message.field)
+          @@evaled_dependencies << name
+
+        elsif (enum = @@all_enums[name])
+          # Check @@evaled_dependencies again in case there was a dependency
+          # loop that already loaded this enum
+          return if @@evaled_dependencies.include?(name)
+          namespace = name.split(".")
+          eval_enum_code(enum, namespace[0..-2].join("."))
+          @@evaled_dependencies << name
+        else
+          fail "Error loading unknown dependencies, could not find message or enum #{name.inspect}"
+        end
+      end
+
+      def eval_message_code(fully_qualified_namespace, fields = [])
+        group = GroupGenerator.new(0)
+        group.add_extended_messages({ fully_qualified_namespace => fields }, false)
+        print group.to_s
+        eval_code
+      end
+
+      def eval_enum_code(enum, fully_qualified_namespace)
+        group = GroupGenerator.new(0)
+        group.add_enums([enum], :namespace => [fully_qualified_namespace])
+        print group.to_s
+        eval_code(modulize(fully_qualified_namespace).safe_constantize || Object)
+      end
+
+      def eval_code(context = Object)
+        warn "#{context.inspect}.module_eval #{print_contents.inspect}" if ENV['PB_DEBUG']
+        context.module_eval print_contents.to_s
+        @io.truncate(0)
+        @io.rewind
+      end
+
+      def create_ruby_namespace_heiarchy(namespace)
+        loop do
+          namespace, _match, _tail = namespace.rpartition(".")
+          break if namespace.empty?
+          eval_dependencies(namespace)
+        end
+      end
+
       def inject_optionable
         return if descriptor.package.empty? && !ENV.key?('PB_ALLOW_DEFAULT_PACKAGE_NAME')
         puts "::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }"

data/lib/protobuf/generators/group_generator.rb

@@ -2,6 +2,7 @@ require 'protobuf/generators/enum_generator'
 require 'protobuf/generators/extension_generator'
 require 'protobuf/generators/field_generator'
 require 'protobuf/generators/message_generator'
+require 'protobuf/generators/option_generator'
 require 'protobuf/generators/service_generator'
 
 module Protobuf
@@ -18,10 +19,14 @@ module Protobuf
         @comments = {}
         @handlers = {}
         @indent_level = indent_level
-        @order = [:enum, :message_declaration, :message, :extended_message, :service]
+        @order = [:enum, :message_declaration, :options, :message, :extended_message, :service]
         init_printer(indent_level)
       end
 
+      def add_options(option_descriptor)
+        @groups[:options] << OptionGenerator.new(option_descriptor, indent_level)
+      end
+
       def add_enums(enum_descriptors, options)
         enum_descriptors.each do |enum_descriptor|
           @groups[:enum] << EnumGenerator.new(enum_descriptor, indent_level, options)
@@ -32,8 +37,9 @@ module Protobuf
         @comments[type] = message
       end
 
-      def add_extended_messages(extended_messages)
+      def add_extended_messages(extended_messages, skip_empty_fields = true)
         extended_messages.each do |message_type, field_descriptors|
+          next if skip_empty_fields && field_descriptors.empty?
           @groups[:extended_message] << ExtensionGenerator.new(message_type, field_descriptors, indent_level)
         end
       end
@@ -98,7 +104,7 @@ module Protobuf
             end
           end
 
-          puts if type == :message_declaration
+          puts if type == :message_declaration || type == :options
         end
       end
 

data/lib/protobuf/generators/message_generator.rb

@@ -42,6 +42,8 @@ module Protobuf
             print_class(descriptor.name, nil) do
               group = GroupGenerator.new(current_indent)
               group.add_messages(descriptor.nested_type, :extension_fields => @extension_fields, :namespace => type_namespace)
+              group.add_comment(:options, 'Message Options')
+              group.add_options(descriptor.options) if options?
               group.add_message_fields(descriptor.field)
               self.class.validate_tags(fully_qualified_type_namespace, descriptor.field.map(&:number))
 
@@ -52,7 +54,7 @@ module Protobuf
 
               group.add_extension_fields(message_extension_fields)
 
-              group.order = [:message, :field, :extension_range, :extension_field]
+              group.order = [:message, :options, :field, :extension_range, :extension_field]
               print group.to_s
             end
           end
@@ -69,6 +71,10 @@ module Protobuf
         descriptor.field.count > 0
       end
 
+      def options?
+        descriptor.options
+      end
+
       def nested_enums?
         descriptor.enum_type.count > 0
       end
@@ -85,7 +91,7 @@ module Protobuf
         if @only_declarations
           nested_types?
         else
-          fields? || nested_messages? || extensions?
+          fields? || nested_messages? || extensions? || options?
         end
       end
 

data/lib/protobuf/generators/option_generator.rb

@@ -0,0 +1,17 @@
+require 'protobuf/generators/base'
+
+module Protobuf
+  module Generators
+    class OptionGenerator < Base
+      def compile
+        run_once(:compile) do
+          descriptor.each_field.map do |field, value|
+            next unless descriptor.field?(field.name)
+            serialized_value = serialize_value(value)
+            puts "set_option #{field.fully_qualified_name.inspect}, #{serialized_value}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/generators/printable.rb

@@ -93,14 +93,14 @@ module Protobuf
       # If a block is given, call the block from within an indent block.
       # Otherwise, end the block on the same line.
       #
-      def print_block(name, parent_klass, type, &block)
+      def print_block(name, parent_klass, type)
         name = modulize(name)
         block_def = "#{type} #{name}"
         block_def += " < #{parent_class(parent_klass)}" if parent_klass
 
         if block_given?
           puts block_def
-          indent { block.call }
+          indent { yield }
           puts "end"
           puts
         else

data/lib/protobuf/generators/service_generator.rb

@@ -1,4 +1,5 @@
 require 'protobuf/generators/base'
+require 'protobuf/generators/option_generator'
 
 module Protobuf
   module Generators
@@ -7,18 +8,41 @@ module Protobuf
       def compile
         run_once(:compile) do
           print_class(descriptor.name, :service) do
+            print OptionGenerator.new(descriptor.options, current_indent).to_s if descriptor.options
             descriptor.method.each do |method_descriptor|
-              puts build_method(method_descriptor)
+              print_method(method_descriptor)
             end
           end
         end
       end
 
-      def build_method(method_descriptor)
+      private
+
+      def print_method(method_descriptor)
         request_klass = modulize(method_descriptor.input_type)
         response_klass = modulize(method_descriptor.output_type)
         name = ENV.key?('PB_USE_RAW_RPC_NAMES') ? method_descriptor.name : method_descriptor.name.underscore
-        "rpc :#{name}, #{request_klass}, #{response_klass}"
+        options = {}
+        if method_descriptor.options
+          method_descriptor.options.each_field do |field_option|
+            option_value = method_descriptor.options[field_option.name]
+            next unless method_descriptor.options.field?(field_option.name)
+            options[field_option.fully_qualified_name] = serialize_value(option_value)
+          end
+        end
+
+        rpc = "rpc :#{name}, #{request_klass}, #{response_klass}"
+
+        if options.empty?
+          puts rpc
+          return
+        end
+
+        puts rpc + " do"
+        options.each do |option_name, value|
+          indent { puts "set_option #{option_name.inspect}, #{value}" }
+        end
+        puts "end"
       end
 
     end

data/lib/protobuf/lifecycle.rb

@@ -9,7 +9,7 @@ module Protobuf
           yield(*args)
         end
       end
-      alias_method :on, :register
+      alias :on register
 
       def trigger(event_name, *args)
         event_name = normalized_event_name(event_name)

data/lib/protobuf/message/fields.rb

@@ -134,25 +134,23 @@ module Protobuf
           #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
           #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
 
-          if options[:extension]
-            base_name = fully_qualified_field_name.to_s.split('.').last.to_sym
-            if field_store[base_name]
-              # Case 3
-              if field_store[base_name].extension?
-                remove_existing_accessors(base_name)
-                simple_name = nil
-              # Case 2
+          simple_name =
+            if options[:extension]
+              base_name = fully_qualified_field_name.to_s.split('.').last.to_sym
+              if field_store[base_name]
+                # Case 3
+                if field_store[base_name].extension?
+                  remove_existing_accessors(base_name)
+                end
+                nil
+              # Case 4
               else
-                simple_name = nil
+                base_name
               end
-            # Case 4
             else
-              simple_name = base_name
+              # Case 1
+              fully_qualified_field_name
             end
-          else
-            # Case 1
-            simple_name = fully_qualified_field_name
-          end
 
           field = ::Protobuf::Field.build(self, rule, type_class, fully_qualified_field_name,
                                           tag, simple_name, options)

data/lib/protobuf/message/serialization.rb

@@ -63,15 +63,15 @@ module Protobuf
       ##
       # Instance Aliases
       #
-      alias_method :parse_from_string, :decode
-      alias_method :deserialize, :decode
-      alias_method :parse_from, :decode_from
-      alias_method :deserialize_from, :decode_from
-      alias_method :to_s, :encode
-      alias_method :bytes, :encode
-      alias_method :serialize, :encode
-      alias_method :serialize_to_string, :encode
-      alias_method :serialize_to, :encode_to
+      alias :parse_from_string decode
+      alias :deserialize decode
+      alias :parse_from decode_from
+      alias :deserialize_from decode_from
+      alias :to_s encode
+      alias :bytes encode
+      alias :serialize encode
+      alias :serialize_to_string encode
+      alias :serialize_to encode_to
 
       private
 

data/lib/protobuf/message.rb

@@ -150,17 +150,13 @@ module Protobuf
     end
 
     def [](name)
-      if (field = self.class.get_field(name, true))
-        if field.repeated?
-          @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(field)
-        elsif @values.key?(field.fully_qualified_name)
-          @values[field.fully_qualified_name]
-        else
-          field.default_value
-        end
-      else
-        fail ArgumentError, "invalid field name=#{name.inspect}"
-      end
+      field = self.class.get_field(name, true)
+      return @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(field) if field.repeated?
+
+      @values.fetch(field.fully_qualified_name, field.default_value)
+    rescue # not having a field should be the exceptional state
+      raise if field
+      fail ArgumentError, "invalid field name=#{name.inspect}"
     end
 
     def []=(name, value)
@@ -170,17 +166,17 @@ module Protobuf
     ##
     # Instance Aliases
     #
-    alias_method :to_hash_value, :to_hash
-    alias_method :to_proto_hash, :to_hash
-    alias_method :responds_to_has?, :respond_to_has?
-    alias_method :respond_to_and_has?, :respond_to_has?
-    alias_method :responds_to_and_has?, :respond_to_has?
-    alias_method :respond_to_has_present?, :respond_to_has_and_present?
-    alias_method :respond_to_and_has_present?, :respond_to_has_and_present?
-    alias_method :respond_to_and_has_and_present?, :respond_to_has_and_present?
-    alias_method :responds_to_has_present?, :respond_to_has_and_present?
-    alias_method :responds_to_and_has_present?, :respond_to_has_and_present?
-    alias_method :responds_to_and_has_and_present?, :respond_to_has_and_present?
+    alias :to_hash_value to_hash
+    alias :to_proto_hash to_hash
+    alias :responds_to_has? respond_to_has?
+    alias :respond_to_and_has? respond_to_has?
+    alias :responds_to_and_has? respond_to_has?
+    alias :respond_to_has_present? respond_to_has_and_present?
+    alias :respond_to_and_has_present? respond_to_has_and_present?
+    alias :respond_to_and_has_and_present? respond_to_has_and_present?
+    alias :responds_to_has_present? respond_to_has_and_present?
+    alias :responds_to_and_has_present? respond_to_has_and_present?
+    alias :responds_to_and_has_and_present? respond_to_has_and_present?
 
     ##
     # Private Instance Methods
@@ -195,15 +191,15 @@ module Protobuf
             ::Protobuf.deprecator.deprecation_warning("#{self.class}#[#{name}]=nil", "use an empty array instead of nil")
             return
           end
-          if value.is_a?(Array)
-            value = value.compact
-          else
+          unless value.is_a?(Array)
             fail TypeError, <<-TYPE_ERROR
                 Expected repeated value of type '#{field.type_class}'
                 Got '#{value.class}' for repeated protobuf field #{field.name}
             TYPE_ERROR
           end
 
+          value = value.compact
+
           if value.empty?
             @values.delete(field.fully_qualified_name)
           else
@@ -211,12 +207,10 @@ module Protobuf
             @values[field.fully_qualified_name].replace(value)
           end
         else
-          if value.nil?
+          if value.nil? # rubocop:disable Style/IfInsideElse
             @values.delete(field.fully_qualified_name)
-          elsif field.acceptable?(value)
-            @values[field.fully_qualified_name] = field.coerce!(value)
           else
-            fail TypeError, "Unacceptable value #{value} for field #{field.name} of type #{field.type_class}"
+            @values[field.fully_qualified_name] = field.coerce!(value)
           end
         end
       else