protobuf-core 3.5.0

data/lib/protobuf/exceptions.rb

@@ -0,0 +1,9 @@
+module Protobuf
+  class Error < StandardError; end
+  class InvalidWireType < Error; end
+  class NotInitializedError < Error; end
+  class TagCollisionError < Error; end
+  class SerializationError < StandardError; end
+  class FieldNotDefinedError < StandardError; end
+  class DuplicateFieldNameError < StandardError; end
+end

data/lib/protobuf/field.rb

@@ -0,0 +1,74 @@
+require 'protobuf/field/base_field'
+require 'protobuf/field/bytes_field'
+require 'protobuf/field/float_field'
+require 'protobuf/field/message_field'
+require 'protobuf/field/varint_field'
+require 'protobuf/field/string_field'
+require 'protobuf/field/double_field'
+require 'protobuf/field/enum_field'
+require 'protobuf/field/integer_field'
+require 'protobuf/field/signed_integer_field'
+require 'protobuf/field/uint32_field'
+require 'protobuf/field/uint64_field'
+require 'protobuf/field/int32_field'
+require 'protobuf/field/int64_field'
+require 'protobuf/field/sint32_field'
+require 'protobuf/field/sint64_field'
+require 'protobuf/field/bool_field'
+require 'protobuf/field/sfixed32_field'
+require 'protobuf/field/sfixed64_field'
+require 'protobuf/field/fixed32_field'
+require 'protobuf/field/fixed64_field'
+
+module Protobuf
+  module Field
+
+    PRIMITIVE_FIELD_MAP = {
+      :double   => ::Protobuf::Field::DoubleField,
+      :float    => ::Protobuf::Field::FloatField,
+      :int32    => ::Protobuf::Field::Int32Field,
+      :int64    => ::Protobuf::Field::Int64Field,
+      :uint32   => ::Protobuf::Field::Uint32Field,
+      :uint64   => ::Protobuf::Field::Uint64Field,
+      :sint32   => ::Protobuf::Field::Sint32Field,
+      :sint64   => ::Protobuf::Field::Sint64Field,
+      :fixed32  => ::Protobuf::Field::Fixed32Field,
+      :fixed64  => ::Protobuf::Field::Fixed64Field,
+      :sfixed32 => ::Protobuf::Field::Sfixed32Field,
+      :sfixed64 => ::Protobuf::Field::Sfixed64Field,
+      :string   => ::Protobuf::Field::StringField,
+      :bytes    => ::Protobuf::Field::BytesField,
+      :bool     => ::Protobuf::Field::BoolField,
+    }.freeze
+
+    def self.build(message_class, rule, type, name, tag, options = {})
+      field_class(type).new(message_class, rule, field_type(type), name, tag, options)
+    end
+
+    # Returns the field class for primitives,
+    # EnumField for types that inherit from Protobuf::Enum,
+    # and MessageField for types that inherit from Protobuf::Message.
+    #
+    def self.field_class(type)
+      if PRIMITIVE_FIELD_MAP.key?(type)
+        PRIMITIVE_FIELD_MAP[type]
+      elsif type < ::Protobuf::Enum
+        EnumField
+      elsif type < ::Protobuf::Message
+        MessageField
+      elsif type < ::Protobuf::Field::BaseField
+        type
+      else
+        fail ArgumentError, "Invalid field type #{type}"
+      end
+    end
+
+    # Returns the mapped type for primitives,
+    # otherwise the given type is returned.
+    #
+    def self.field_type(type)
+      PRIMITIVE_FIELD_MAP.fetch(type) { type }
+    end
+
+  end
+end

data/lib/protobuf/field/base_field.rb

@@ -0,0 +1,267 @@
+require 'protobuf/field/field_array'
+require 'protobuf/logging'
+require 'protobuf/wire_type'
+
+module Protobuf
+  module Field
+    class BaseField
+      include ::Protobuf::Logging
+
+      ##
+      # Constants
+      #
+
+      PACKED_TYPES = [
+        ::Protobuf::WireType::VARINT,
+        ::Protobuf::WireType::FIXED32,
+        ::Protobuf::WireType::FIXED64,
+      ].freeze
+
+      ##
+      # Attributes
+      #
+
+      attr_reader :message_class, :name, :options, :rule, :tag, :type_class
+
+      ##
+      # Class Methods
+      #
+
+      def self.default
+        nil
+      end
+
+      ##
+      # Constructor
+      #
+
+      def initialize(message_class, rule, type_class, name, tag, options)
+        @message_class = message_class
+        @name          = name
+        @rule          = rule
+        @tag           = tag
+        @type_class    = type_class
+        @options       = options
+
+        validate_packed_field if packed?
+        define_accessor
+      end
+
+      ##
+      # Public Instance Methods
+      #
+
+      def acceptable?(_value)
+        true
+      end
+
+      def coerce!(value)
+        value
+      end
+
+      def decode(_bytes)
+        fail NotImplementedError, "#{self.class.name}##{__method__}"
+      end
+
+      def default
+        options[:default]
+      end
+
+      def default_value
+        @default_value ||= case
+                           when repeated? then ::Protobuf::Field::FieldArray.new(self).freeze
+                           when required? then nil
+                           when optional? then typed_default_value
+                           end
+      end
+
+      def deprecated?
+        options.key?(:deprecated)
+      end
+
+      def encode(_value)
+        fail NotImplementedError, "#{self.class.name}##{__method__}"
+      end
+
+      def extension?
+        options.key?(:extension)
+      end
+
+      def enum?
+        false
+      end
+
+      def getter
+        name
+      end
+
+      def message?
+        false
+      end
+
+      def optional?
+        rule == :optional
+      end
+
+      def packed?
+        repeated? && options.key?(:packed)
+      end
+
+      def repeated?
+        rule == :repeated
+      end
+
+      def repeated_message?
+        repeated? && message?
+      end
+
+      def required?
+        rule == :required
+      end
+
+      # FIXME: need to cleanup (rename) this warthog of a method.
+      def set(message_instance, bytes)
+        if packed?
+          array = message_instance.__send__(getter)
+          method = \
+            case wire_type
+            when ::Protobuf::WireType::FIXED32 then :read_fixed32
+            when ::Protobuf::WireType::FIXED64 then :read_fixed64
+            when ::Protobuf::WireType::VARINT  then :read_varint
+            end
+          stream = StringIO.new(bytes)
+
+          until stream.eof?
+            array << decode(::Protobuf::Decoder.__send__(method, stream))
+          end
+        else
+          value = decode(bytes)
+          if repeated?
+            message_instance.__send__(getter) << value
+          else
+            message_instance.__send__(setter, value)
+          end
+        end
+      end
+
+      def setter
+        @setter ||= "#{name}="
+      end
+
+      # FIXME: add packed, deprecated, extension options to to_s output
+      def to_s
+        "#{rule} #{type_class} #{name} = #{tag} #{default ? "[default=#{default.inspect}]" : ''}"
+      end
+
+      ::Protobuf.deprecator.define_deprecated_methods(self, :type => :type_class)
+
+      def wire_type
+        ::Protobuf::WireType::VARINT
+      end
+
+      private
+
+      ##
+      # Private Instance Methods
+      #
+
+      def define_accessor
+        if repeated?
+          define_array_getter
+          define_array_setter
+        else
+          define_getter
+          define_setter
+        end
+      end
+
+      def define_array_getter
+        field = self
+        method_name = field.getter
+
+        message_class.class_eval do
+          define_method(method_name) do
+            @values[field.name] ||= ::Protobuf::Field::FieldArray.new(field)
+          end
+        end
+
+        ::Protobuf.field_deprecator.deprecate_method(message_class, method_name) if field.deprecated?
+      end
+
+      def define_array_setter
+        field = self
+        method_name = field.setter
+
+        message_class.class_eval do
+          define_method(method_name) do |val|
+            if val.is_a?(Array)
+              val = val.dup
+              val.compact!
+            else
+              fail TypeError, <<-TYPE_ERROR
+                Expected repeated value of type '#{field.type_class}'
+                Got '#{val.class}' for repeated protobuf field #{field.name}
+              TYPE_ERROR
+            end
+
+            if val.nil? || (val.respond_to?(:empty?) && val.empty?)
+              @values.delete(field.name)
+            else
+              @values[field.name] ||= ::Protobuf::Field::FieldArray.new(field)
+              @values[field.name].replace(val)
+            end
+          end
+        end
+
+        ::Protobuf.field_deprecator.deprecate_method(message_class, method_name) if field.deprecated?
+      end
+
+      def define_getter
+        field = self
+        method_name = field.getter
+
+        message_class.class_eval do
+          define_method(method_name) do
+            @values.fetch(field.name, field.default_value)
+          end
+        end
+
+        ::Protobuf.field_deprecator.deprecate_method(message_class, method_name) if field.deprecated?
+      end
+
+      def define_setter
+        field = self
+        method_name = field.setter
+
+        message_class.class_eval do
+          define_method(method_name) do |val|
+            if val.nil? || (val.respond_to?(:empty?) && val.empty?)
+              @values.delete(field.name)
+            elsif field.acceptable?(val)
+              @values[field.name] = field.coerce!(val)
+            else
+              fail TypeError, "Unacceptable value #{val} for field #{field.name} of type #{field.type_class}"
+            end
+          end
+        end
+
+        ::Protobuf.field_deprecator.deprecate_method(message_class, method_name) if field.deprecated?
+      end
+
+      def typed_default_value
+        if default.nil?
+          self.class.default
+        else
+          default
+        end
+      end
+
+      def validate_packed_field
+        if packed? && ! ::Protobuf::Field::BaseField::PACKED_TYPES.include?(wire_type)
+          fail "Can't use packed encoding for '#{type_class}' type"
+        end
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/bool_field.rb

@@ -0,0 +1,59 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class BoolField < VarintField
+
+      ##
+      # Class Methods
+      #
+
+      def self.default
+        false
+      end
+
+      ##
+      # Public Instance Methods
+      # #
+
+      def acceptable?(val)
+        [true, false].include?(val) || %w(true false).include?(val)
+      end
+
+      def coerce!(val)
+        if val == 'true'
+          true
+        elsif val == 'false'
+          false
+        else
+          val
+        end
+      end
+
+      def decode(value)
+        value == 1
+      end
+
+      def encode(value)
+        [value ? 1 : 0].pack('C')
+      end
+
+      private
+
+      ##
+      # Private Instance Methods
+      #
+
+      def define_getter
+        super
+
+        field = self
+
+        message_class.class_eval do
+          alias_method "#{field.getter}?", field.getter
+        end
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/bytes_field.rb

@@ -0,0 +1,82 @@
+require 'protobuf/wire_type'
+
+module Protobuf
+  module Field
+    class BytesField < BaseField
+
+      ##
+      # Constants
+      #
+
+      BYTES_ENCODING = Encoding::BINARY
+
+      ##
+      # Class Methods
+      #
+
+      def self.default
+        ''
+      end
+
+      ##
+      # Public Instance Methods
+      #
+
+      def acceptable?(val)
+        val.nil? || val.is_a?(String) || val.is_a?(Symbol) || val.is_a?(::Protobuf::Message)
+      end
+
+      def decode(bytes)
+        bytes_to_decode = bytes.dup
+        bytes_to_decode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        bytes_to_decode
+      end
+
+      def encode(value)
+        value_to_encode = value.dup
+        value_to_encode = value.encode if value.is_a?(::Protobuf::Message)
+        value_to_encode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+
+        string_size = ::Protobuf::Field::VarintField.encode(value_to_encode.size)
+        string_size << value_to_encode
+      end
+
+      def wire_type
+        ::Protobuf::WireType::LENGTH_DELIMITED
+      end
+
+      private
+
+      ##
+      # Private Instance Methods
+      #
+
+      def define_setter
+        field = self
+        method_name = field.setter
+
+        message_class.class_eval do
+          define_method(method_name) do |val|
+            begin
+              val = "#{val}" if val.is_a?(Symbol)
+
+              if val.nil?
+                @values.delete(field.name)
+              elsif field.acceptable?(val)
+                @values[field.name] = val.dup
+              else
+                fail TypeError, "Unacceptable value #{val} for field #{field.name} of type #{field.type_class}"
+              end
+            rescue NoMethodError => ex
+              logger.error { ex.message }
+              logger.error { ex.backtrace.join("\n") }
+              raise TypeError, "Got NoMethodError attempting to set #{val} for field #{field.name} of type #{field.type_class}: #{ex.message}"
+            end
+          end
+        end
+
+        ::Protobuf.field_deprecator.deprecate_method(message_class, method_name) if field.deprecated?
+      end
+    end
+  end
+end