protobuffy 3.6.0 → 4.0.0

data/lib/protobuf/message/fields.rb

@@ -1,122 +1,204 @@
-require 'protobuf/deprecator'
+require "set"
 
 module Protobuf
   class Message
     module Fields
 
-      def self.extended(other)
-        other.extend(::Protobuf::Deprecator)
-        other.deprecate_class_method(:get_ext_field_by_name, :get_extension_field)
-        other.deprecate_class_method(:get_ext_field_by_tag, :get_extension_field)
-        other.deprecate_class_method(:get_field_by_name, :get_field)
-        other.deprecate_class_method(:get_field_by_tag, :get_field)
-      end
+      ACCESSOR_SUFFIXES = ["", "=", "!", "?"].freeze
 
-      ##
-      # Field Definition Methods
-      #
+      def self.extended(other)
+        other.extend(ClassMethods)
+        ::Protobuf.deprecator.define_deprecated_methods(
+          other.singleton_class,
+          :get_ext_field_by_name => :get_extension_field,
+          :get_ext_field_by_tag => :get_extension_field,
+          :get_field_by_name => :get_field,
+          :get_field_by_tag => :get_field
+        )
+      end
+
+      module ClassMethods
+        def inherited(subclass)
+          inherit_fields!(subclass)
+        end
 
-      # Define an optional field.
-      #
-      def optional(type_class, name, tag, options = {})
-        define_field(:optional, type_class, name, tag, options)
-      end
+        ##
+        # Field Definition Methods
+        #
 
-      # Define a repeated field.
-      #
-      def repeated(type_class, name, tag, options = {})
-        define_field(:repeated, type_class, name, tag, options)
-      end
+        # Define an optional field.
+        #
+        def optional(type_class, name, tag, options = {})
+          define_field(:optional, type_class, name, tag, options)
+        end
 
-      # Define a required field.
-      #
-      def required(type_class, name, tag, options = {})
-        define_field(:required, type_class, name, tag, options)
-      end
+        # Define a repeated field.
+        #
+        def repeated(type_class, name, tag, options = {})
+          define_field(:repeated, type_class, name, tag, options)
+        end
 
-      # Define an extension range.
-      #
-      def extensions(range)
-        extension_ranges << range
-      end
+        # Define a required field.
+        #
+        def required(type_class, name, tag, options = {})
+          define_field(:required, type_class, name, tag, options)
+        end
 
-      ##
-      # Field Access Methods
-      #
+        # Define an extension range.
+        #
+        def extensions(range)
+          extension_ranges << range
+        end
 
-      def all_fields
-        @all_fields ||= field_store.values.uniq
-      end
+        ##
+        # Field Access Methods
+        #
+        def all_fields
+          @all_fields ||= field_store.values.uniq.sort_by(&:tag)
+        end
 
-      def extension_fields
-        @extension_fields ||= all_fields.select(&:extension?)
-      end
+        def extension_fields
+          @extension_fields ||= all_fields.select(&:extension?)
+        end
 
-      def extension_ranges
-        @extension_ranges ||= []
-      end
+        def extension_ranges
+          @extension_ranges ||= []
+        end
 
-      def extension_tag?(tag)
-        tag.respond_to?(:to_i) && get_extension_field(tag).present?
-      end
+        def extension_tag?(tag)
+          tag.respond_to?(:to_i) && get_extension_field(tag).present?
+        end
 
-      def field_store
-        @field_store ||= {}
-      end
+        def field_store
+          @field_store ||= {}
+        end
 
-      def fields
-        @fields ||= all_fields.reject(&:extension?)
-      end
+        def fields
+          @fields ||= all_fields.reject(&:extension?)
+        end
 
-      def field_tag?(tag, allow_extension = false)
-        tag.respond_to?(:to_i) && get_field(tag, allow_extension).present?
-      end
+        def field_tag?(tag, allow_extension = false)
+          tag.respond_to?(:to_i) && get_field(tag, allow_extension).present?
+        end
 
-      def get_extension_field(name_or_tag)
-        name_or_tag = name_or_tag.to_sym if name_or_tag.respond_to?(:to_sym)
-        field = field_store[name_or_tag]
-        field if field.try(:extension?) { false }
-      end
+        def get_extension_field(name_or_tag)
+          field = field_store[name_or_tag]
+          field if field.try(:extension?) { false }
+        end
 
-      def get_field(name_or_tag, allow_extension = false)
-        name_or_tag = name_or_tag.to_sym if name_or_tag.respond_to?(:to_sym)
-        field = field_store[name_or_tag]
+        def get_field(name_or_tag, allow_extension = false)
+          field = field_store[name_or_tag]
 
-        if field && (allow_extension || ! field.extension?)
-          field
-        else
-          nil
+          if field && (allow_extension || !field.extension?)
+            field
+          else
+            nil
+          end
         end
-      end
 
-      def define_field(rule, type_class, field_name, tag, options)
-        raise_if_tag_collision(tag, field_name)
-        raise_if_name_collision(field_name)
+        def define_field(rule, type_class, fully_qualified_field_name, tag, options)
+          raise_if_tag_collision(tag, fully_qualified_field_name)
+          raise_if_name_collision(fully_qualified_field_name)
+
+          # Determine appropirate accessor for fields depending on name collisions via extensions:
+
+          # Case 1: Base field = "string_field" and no extensions of the same name
+          # Result:
+          #   message.string_field #=> @values["string_field"]
+          #   message[:string_field] #=> @values["string_field"]
+          #   message['string_field'] #=> @values["string_field"]
+
+          # Case 2: Base field = "string_field" and extension 1 = ".my_package.string_field", extension N = ".package_N.string_field"...
+          # Result:
+          #   message.string_field #=> @values["string_field"]
+          #   message[:string_field] #=> @values["string_field"]
+          #   message['string_field'] #=> @values["string_field"]
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+          #   message['.my_package.string_field']  #=> @values[".my_package.string_field"]
+
+          # Case 3: No base field, extension 1 = ".my_package.string_field", extension 2 = ".other_package.string_field", extension N...
+          # Result:
+          #   message.string_field #=> raise NoMethodError (no simple accessor allowed)
+          #   message[:string_field] #=> raise NoMethodError (no simple accessor allowed)
+          #   message['string_field'] #=> raise NoMethodError (no simple accessor allowed)
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+          #   message['.my_package.string_field']  #=> @values[".my_package.string_field"]
+          #   message[:'.other_package.string_field'] #=> @values[".other_package.string_field"]
+          #   message['.other_package.string_field']  #=> @values[".other_package.string_field"]
+
+          # Case 4: No base field, extension = ".my_package.string_field", no other extensions
+          # Result:
+          #   message.string_field #=> @values[".my_package.string_field"]
+          #   message[:string_field] #=> @values[".my_package.string_field"]
+          #   message['string_field'] #=> @values[".my_package.string_field"]
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+
+          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
+                base_name
+              end
+            else
+              # Case 1
+              fully_qualified_field_name
+            end
+
+          field = ::Protobuf::Field.build(self, rule, type_class, fully_qualified_field_name,
+                                          tag, simple_name, options)
+          field_store[tag] = field
+          field_store[fully_qualified_field_name.to_sym] = field
+          field_store[fully_qualified_field_name.to_s] = field
+          if simple_name && simple_name != fully_qualified_field_name
+            field_store[simple_name.to_sym] = field
+            field_store[simple_name.to_s] = field
+          end
+          # defining a new field for the message will cause cached @all_fields, @extension_fields,
+          # and @fields to be incorrect; reset them
+          @all_fields = @extension_fields = @fields = nil
+        end
 
-        field = ::Protobuf::Field.build(self, rule, type_class, field_name, tag, options)
-        field_store[field_name] = field
-        field_store[tag] = field
+        def remove_existing_accessors(accessor)
+          field_store.delete(accessor.to_sym).try(:fully_qualified_name_only!)
+          field_store.delete(accessor.to_s)
+          ACCESSOR_SUFFIXES.each do |modifier|
+            begin
+              remove_method("#{accessor}#{modifier}")
+            # rubocop: disable Lint/HandleExceptions
+            rescue NameError
+              # Do not remove the method
+            end
+          end
+        end
 
-        class_eval(<<-RAW_GETTER, __FILE__, __LINE__ + 1)
-          define_method("#{field_name}!") do
-            @values[:#{field_name}]
+        def raise_if_tag_collision(tag, field_name)
+          if get_field(tag, true)
+            fail TagCollisionError, %(Field number #{tag} has already been used in "#{name}" by field "#{field_name}".)
           end
-        RAW_GETTER
-      end
+        end
 
-      def raise_if_tag_collision(tag, field_name)
-        if get_field(tag, true)
-          raise TagCollisionError, %!Field number #{tag} has already been used in "#{name}" by field "#{field_name}".!
+        def raise_if_name_collision(field_name)
+          if get_field(field_name, true)
+            fail DuplicateFieldNameError, %(Field name #{field_name} has already been used in "#{name}".)
+          end
         end
-      end
 
-      def raise_if_name_collision(field_name)
-        if get_field(field_name, true)
-          raise DuplicateFieldNameError, %!Field name #{field_name} has already been used in "#{name}".!
+        def inherit_fields!(subclass)
+          instance_variables.each do |iv|
+            subclass.instance_variable_set(iv, instance_variable_get(iv))
+          end
         end
-      end
+        private :inherit_fields!
 
+      end
     end
   end
 end
-

data/lib/protobuf/message/serialization.rb

@@ -8,12 +8,16 @@ module Protobuf
 
       module ClassMethods
         def decode(bytes)
-          self.new.decode(bytes)
+          new.decode(bytes)
+        end
+
+        def decode_from(stream)
+          new.decode_from(stream)
         end
 
         # Create a new object with the given values and return the encoded bytes.
         def encode(fields = {})
-          self.new(fields).encode
+          new(fields).encode
         end
       end
 
@@ -44,8 +48,10 @@ module Protobuf
       # Encode this message
       #
       def encode
-        stream = ::StringIO.new.set_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
-        encode_to(stream).string
+        stream = ::StringIO.new
+        stream.set_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        encode_to(stream)
+        stream.string
       end
 
       # Encode this message to the given stream.
@@ -57,22 +63,18 @@ 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
 
-      def field_must_be_serialized?(field)
-        field.required? || ! @values[field.name].nil?
-      end
-
       def set_field_bytes(tag, bytes)
         field = self.class.get_field(tag, true)
         field.set(self, bytes) if field
@@ -81,4 +83,3 @@ module Protobuf
     end
   end
 end
-

data/lib/protobuf/optionable.rb

@@ -1,17 +1,37 @@
-require 'active_support/concern'
-
 module Protobuf
   module Optionable
-    extend ::ActiveSupport::Concern
-
     module ClassMethods
       def get_option(name)
-        @_optionable_options.try(:[], name)
+        name = name.to_s
+        option = optionable_descriptor_class.get_field(name, true)
+        fail ArgumentError, "invalid option=#{name}" unless option
+        unless option.fully_qualified_name.to_s == name
+          # Eventually we'll deprecate the use of simple names of fields completely, but for now make sure people
+          # are accessing options correctly. We allow simple names in other places for backwards compatibility.
+          fail ArgumentError, "must access option using its fully qualified name: #{option.fully_qualified_name.inspect}"
+        end
+        value =
+          if @_optionable_options.try(:key?, name)
+            @_optionable_options[name]
+          else
+            option.default_value
+          end
+        if option.type_class < ::Protobuf::Message
+          option.type_class.new(value)
+        else
+          value
+        end
+      end
+
+      def get_option!(name)
+        get_option(name) if @_optionable_options.try(:key?, name.to_s)
       end
 
+      private
+
       def set_option(name, value = true)
         @_optionable_options ||= {}
-        @_optionable_options[name] = value
+        @_optionable_options[name.to_s] = value
       end
     end
 
@@ -19,5 +39,32 @@ module Protobuf
       self.class.get_option(name)
     end
 
+    def get_option!(name)
+      self.class.get_option!(name)
+    end
+
+    def self.inject(base_class, extend_class = true, &block)
+      unless block_given?
+        fail ArgumentError, 'missing option class block (e.g: ::Google::Protobuf::MessageOptions)'
+      end
+      if extend_class
+        # Check if optionable_descriptor_class is already defined and short circuit if so.
+        # File options are injected per module, and since a module can be defined more than once,
+        # we will get a warning if we try to define optionable_descriptor_class twice.
+        if base_class.respond_to?(:optionable_descriptor_class)
+          # Don't define optionable_descriptor_class twice
+          return  if base_class.optionable_descriptor_class == block.call
+
+          fail 'A class is being defined with two different descriptor classes, something is very wrong'
+        end
+
+        base_class.extend(ClassMethods)
+        base_class.__send__(:include, self)
+        base_class.define_singleton_method(:optionable_descriptor_class, block)
+      else
+        base_class.__send__(:include, ClassMethods)
+        base_class.module_eval { define_method(:optionable_descriptor_class, block) }
+      end
+    end
   end
 end

data/lib/protobuf/rpc/buffer.rb

@@ -4,12 +4,12 @@ module Protobuf
 
       attr_accessor :mode, :data, :size
 
-      MODES = [:read, :write]
+      MODES = [:read, :write].freeze
 
       # constantize this so we don't re-initialize the regex every time we need it
       SIZE_REGEX = /^\d+-/
 
-      def initialize(mode=:read)
+      def initialize(mode = :read)
         @flush = false
         @data = ""
         @size = 0
@@ -17,18 +17,19 @@ module Protobuf
       end
 
       def mode=(mode)
-        if MODES.include?(mode)
-          @mode = mode
-        else
-          @mode = :read
-        end
+        @mode =
+          if MODES.include?(mode)
+            mode
+          else
+            :read
+          end
       end
 
-      def write(force_mode=true)
-        if force_mode and reading?
-          mode = :write
-        elsif not force_mode and reading?
-          raise = 'You chose to write the buffer when in read mode'
+      def write(force_mode = true)
+        if force_mode && reading?
+          self.mode = :write
+        elsif !force_mode && reading?
+          fail 'You chose to write the buffer when in read mode'
         end
 
         @size = @data.length
@@ -43,7 +44,7 @@ module Protobuf
         end
       end
 
-      def set_data(data)
+      def set_data(data) # rubocop:disable Style/AccessorMethodName
         @data = data.to_s
         @size = @data.size
       end
@@ -60,19 +61,17 @@ module Protobuf
         @flush
       end
 
-      def get_data_size
+      def get_data_size # rubocop:disable Style/AccessorMethodName
         if @size == 0 || @data.match(SIZE_REGEX)
           sliced_size = @data.slice!(SIZE_REGEX)
-          @size = sliced_size.gsub('-', '').to_i unless sliced_size.nil?
+          @size = sliced_size.delete('-').to_i unless sliced_size.nil?
         end
       end
 
-    private
+      private
 
       def check_for_flush
-        if !@size.nil? && @data.length == @size
-          @flush = true
-        end
+        @flush = true if !@size.nil? && @data.length == @size
       end
     end
   end