protobuffy 3.6.0 → 4.0.0

data/lib/protobuf/field/uint64_field.rb

@@ -19,4 +19,3 @@ module Protobuf
     end
   end
 end
-

data/lib/protobuf/field/varint_field.rb

@@ -8,6 +8,7 @@ module Protobuf
       # Constants
       #
 
+      CACHE_LIMIT = 2048
       INT32_MAX  =  2**31 - 1
       INT32_MIN  = -2**31
       INT64_MAX  =  2**63 - 1
@@ -23,7 +24,16 @@ module Protobuf
         0
       end
 
-      def self.encode(value)
+      # Because all tags and enums are calculated as VarInt it is "most common" to have
+      # values < CACHE_LIMIT (low numbers) which is defaulting to 1024
+      def self.cached_varint(value)
+        @_varint_cache ||= {}
+        (@_varint_cache[value] ||= encode(value, false)).dup
+      end
+
+      def self.encode(value, use_cache = true)
+        return cached_varint(value) if use_cache && value >= 0 && value <= CACHE_LIMIT
+
         bytes = []
         until value < 128
           bytes << (0x80 | (value & 0x7f))
@@ -32,30 +42,38 @@ module Protobuf
         (bytes << value).pack('C*')
       end
 
+      # Load the cache of VarInts on load of file
+      (0..CACHE_LIMIT).each do |cached_value|
+        cached_varint(cached_value)
+      end
+
       ##
       # Public Instance Methods
       #
-
       def acceptable?(val)
-        (val > self.class.min || val < self.class.max)
+        int_val = if val.is_a?(Integer)
+                    return true if val >= 0 && val < INT32_MAX # return quickly for smallest integer size, hot code path
+                    val
+                  else
+                    coerce!(val)
+                  end
+
+        int_val >= self.class.min && int_val <= self.class.max
       rescue
         false
       end
 
+      def coerce!(val)
+        return val.to_i if val.is_a?(Numeric)
+        Integer(val, 10)
+      end
+
       def decode(value)
         value
       end
 
       def encode(value)
-        return [value].pack('C') if value < 128
-
-        bytes = []
-        until value == 0
-          bytes << (0x80 | (value & 0x7f))
-          value >>= 7
-        end
-        bytes[-1] &= 0x7f
-        bytes.pack('C*')
+        ::Protobuf::Field::VarintField.encode(value)
       end
 
       def wire_type
@@ -65,4 +83,3 @@ module Protobuf
     end
   end
 end
-

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
@@ -62,10 +56,30 @@ module Protobuf
       end
 
       def type_namespace
-        @type_namespace ||= @namespace + [ descriptor.name ]
+        @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
@@ -32,11 +29,11 @@ module Protobuf
 
       def build_value(enum_value_descriptor)
         name = enum_value_descriptor.name
+        name.upcase! if ENV.key?('PB_UPCASE_ENUMS')
         number = enum_value_descriptor.number
-        return "define :#{name}, #{number}"
+        "define :#{name}, #{number}"
       end
 
     end
   end
 end
-

data/lib/protobuf/generators/extension_generator.rb

@@ -16,7 +16,7 @@ module Protobuf
           print_class(@message_type, :message) do
             group = GroupGenerator.new(current_indent)
             group.add_extension_fields(@field_descriptors)
-            group.order = [ :extension_field ]
+            group.order = [:extension_field]
             print group.to_s
           end
         end
@@ -25,4 +25,3 @@ module Protobuf
     end
   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
@@ -20,18 +20,24 @@ module Protobuf
       attr_reader :field_options
 
       def applicable_options
-        @applicable_options ||= field_options.map { |k, v| ":#{k} => #{v}" }
+        # Note on the strange use of `#inspect`:
+        #   :boom.inspect #=> ":boom"
+        #   :".boom.foo".inspect #=> ":\".boom.foo\""
+        # An alternative to `#inspect` would be always adding double quotes,
+        # but the generatated code looks un-idiomatic:
+        #   ":\"#{:boom}\"" #=> ":\"boom\"" <-- Note the unnecessary double quotes
+        @applicable_options ||= field_options.map { |k, v| "#{k.inspect} => #{v}" }
       end
 
       def default_value
         @default_value ||= begin
                              if defaulted?
                                case descriptor.type.name
-                               when :TYPE_ENUM then
+                               when :TYPE_ENUM
                                  enum_default_value
-                               when :TYPE_STRING, :TYPE_BYTES then
+                               when :TYPE_STRING, :TYPE_BYTES
                                  string_default_value
-                               when :TYPE_FLOAT, :TYPE_DOUBLE then
+                               when :TYPE_FLOAT, :TYPE_DOUBLE
                                  float_double_default_value
                                else
                                  verbatim_default_value
@@ -54,7 +60,7 @@ module Protobuf
 
       def compile
         run_once(:compile) do
-          field_definition = [ "#{label} #{type_name}", name, number, applicable_options ]
+          field_definition = ["#{label} #{type_name}", name, number, applicable_options]
           puts field_definition.flatten.compact.join(', ')
         end
       end
@@ -64,7 +70,7 @@ module Protobuf
       end
 
       def name
-        @name ||= ":#{descriptor.name}"
+        @name ||= descriptor.name.to_sym.inspect
       end
 
       def number
@@ -78,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
@@ -91,10 +104,10 @@ module Protobuf
         @type_name ||= begin
                          case descriptor.type.name
                          when :TYPE_MESSAGE, :TYPE_ENUM, :TYPE_GROUP then
-                           type_name = modulize(descriptor.type_name)
+                           modulize(descriptor.type_name)
                          else
                            type_name = descriptor.type.name.to_s.downcase.sub(/type_/, '')
-                           type_name = ":#{type_name}"
+                           ":#{type_name}"
                          end
                        end
       end
@@ -119,7 +132,7 @@ module Protobuf
       end
 
       def string_default_value
-        %Q{"#{verbatim_default_value.gsub(/'/, '\\\\\'')}"}
+        %("#{verbatim_default_value.gsub(/'/, '\\\\\'')}")
       end
 
       def verbatim_default_value
@@ -129,4 +142,3 @@ module Protobuf
     end
   end
 end
-

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
 
@@ -22,23 +23,25 @@ module Protobuf
 
       def compile
         run_once(:compile) do
-          map_extensions(descriptor, [ descriptor.package ])
-          extract_dangling_extensions
+          map_extensions(descriptor, [descriptor.package])
 
           print_file_comment
           print_generic_requires
           print_import_requires
 
           print_package do
+            inject_optionable
             group = GroupGenerator.new(current_indent)
-            group.add_enums(descriptor.enum_type, :namespace => [ descriptor.package ])
+            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 ])
-            group.add_extended_messages(@unknown_extensions)
+            group.add_messages(descriptor.message_type, :extension_fields => @extension_fields, :namespace => [descriptor.package])
+            group.add_extended_messages(unknown_extensions)
             group.add_services(descriptor.service)
 
             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')
@@ -48,9 +51,17 @@ module Protobuf
         end
       end
 
-      def extract_dangling_extensions
-        @unknown_extensions = @extension_fields.select do |k, v|
-          ! @known_messages.include?(k)
+      def unknown_extensions
+        @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
 
@@ -65,63 +76,101 @@ module Protobuf
       # the value is an array of field descriptors.
       #
       def map_extensions(descriptor, namespaces)
+        if fully_qualified_token?(descriptor.name)
+          fully_qualified_namespace = descriptor.name
+        elsif !(namespace = namespaces.reject(&:empty?).join(".")).empty?
+          fully_qualified_namespace = ".#{namespace}"
+        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|
+          unless fully_qualified_token?(field_descriptor.name) && fully_qualified_namespace
+            field_descriptor.name = "#{fully_qualified_namespace}.#{field_descriptor.name}"
+          end
           @extension_fields[field_descriptor.extendee] << field_descriptor
         end
 
-        if descriptor.respond_to_has_and_present?(:message_type)
-          descriptor.message_type.each do |message_descriptor|
-            map_extensions(message_descriptor, (namespaces + [ message_descriptor.name ]))
-          end
-        end
+        [:message_type, :nested_type, :enum_type].each do |type|
+          next unless descriptor.respond_to_has_and_present?(type)
 
-        if descriptor.respond_to_has_and_present?(:nested_type)
-          descriptor.nested_type.each do |nested_descriptor|
-            map_extensions(nested_descriptor, (namespaces + [ nested_descriptor.name ]))
+          descriptor.public_send(type).each do |type_descriptor|
+            map_extensions(type_descriptor, (namespaces + [type_descriptor.name]))
           end
         end
       end
 
       def print_file_comment
+        puts "# encoding: utf-8"
+        puts
         puts "##"
         puts "# This file is auto-generated. DO NOT EDIT!"
         puts "#"
       end
 
       def print_generic_requires
-        print_require("protobuf/message")
+        print_require("protobuf")
         print_require("protobuf/rpc/service") if descriptor.service.count > 0
         puts
       end
 
       def print_import_requires
-        if descriptor.dependency.count > 0
-          header "Imports"
+        return if descriptor.dependency.empty?
 
-          descriptor.dependency.each do |dependency|
-            print_require(convert_filename(dependency))
-          end
+        header "Imports"
 
-          puts
+        descriptor.dependency.each do |dependency|
+          print_require(convert_filename(dependency))
         end
+
+        puts
       end
 
       def print_package(&block)
-        final = lambda { block.call }
         namespaces = descriptor.package.split('.')
-        namespaces.reverse.inject(final) { |previous, namespace|
-          lambda { print_module(namespace, &previous) }
-        }.call
+        if namespaces.empty? && ENV.key?('PB_ALLOW_DEFAULT_PACKAGE_NAME')
+          namespaces = [File.basename(descriptor.name).sub('.proto', '')]
+        end
+        namespaces.reverse.reduce(block) do |previous, namespace|
+          -> { print_module(namespace, &previous) }
+        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
@@ -134,7 +183,80 @@ 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 }"
+      end
     end
   end
 end
-