protobuf-core 3.5.0

data/lib/protobuf/field/signed_integer_field.rb

@@ -0,0 +1,29 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class SignedIntegerField < VarintField
+
+      ##
+      # Public Instance Methods
+      #
+
+      def decode(value)
+        if (value & 1).zero?
+          value >> 1   # positive value
+        else
+          ~value >> 1  # negative value
+        end
+      end
+
+      def encode(value)
+        if value >= 0
+          VarintField.encode(value << 1)
+        else
+          VarintField.encode(~(value << 1))
+        end
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/sint32_field.rb

@@ -0,0 +1,21 @@
+require 'protobuf/field/signed_integer_field'
+
+module Protobuf
+  module Field
+    class Sint32Field < SignedIntegerField
+
+      ##
+      # Class Methods
+      #
+
+      def self.max
+        INT32_MAX
+      end
+
+      def self.min
+        INT32_MIN
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/sint64_field.rb

@@ -0,0 +1,21 @@
+require 'protobuf/field/signed_integer_field'
+
+module Protobuf
+  module Field
+    class Sint64Field < SignedIntegerField
+
+      ##
+      # Class Methods
+      #
+
+      def self.max
+        INT64_MAX
+      end
+
+      def self.min
+        INT64_MIN
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/string_field.rb

@@ -0,0 +1,34 @@
+require 'protobuf/field/bytes_field'
+
+module Protobuf
+  module Field
+    class StringField < BytesField
+
+      ##
+      # Constants
+      #
+
+      ENCODING = Encoding::UTF_8
+
+      ##
+      # Public Instance Methods
+      #
+
+      def decode(bytes)
+        bytes_to_decode = bytes.dup
+        bytes_to_decode.force_encoding(::Protobuf::Field::StringField::ENCODING)
+        bytes_to_decode
+      end
+
+      def encode(value)
+        value_to_encode = value.dup
+        value_to_encode.encode!(::Protobuf::Field::StringField::ENCODING, :invalid => :replace, :undef => :replace, :replace => "")
+        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
+
+    end
+  end
+end

data/lib/protobuf/field/uint32_field.rb

@@ -0,0 +1,21 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class Uint32Field < VarintField
+
+      ##
+      # Class Methods
+      #
+
+      def self.max
+        UINT32_MAX
+      end
+
+      def self.min
+        0
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/uint64_field.rb

@@ -0,0 +1,21 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class Uint64Field < VarintField
+
+      ##
+      # Class Methods
+      #
+
+      def self.max
+        UINT64_MAX
+      end
+
+      def self.min
+        0
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/varint_field.rb

@@ -0,0 +1,73 @@
+require 'protobuf/field/base_field'
+
+module Protobuf
+  module Field
+    class VarintField < BaseField
+
+      ##
+      # Constants
+      #
+
+      INT32_MAX  =  2**31 - 1
+      INT32_MIN  = -2**31
+      INT64_MAX  =  2**63 - 1
+      INT64_MIN  = -2**63
+      UINT32_MAX =  2**32 - 1
+      UINT64_MAX =  2**64 - 1
+
+      ##
+      # Class Methods
+      #
+
+      def self.default
+        0
+      end
+
+      def self.encode(value)
+        bytes = []
+        until value < 128
+          bytes << (0x80 | (value & 0x7f))
+          value >>= 7
+        end
+        (bytes << value).pack('C*')
+      end
+
+      ##
+      # Public Instance Methods
+      #
+
+      def acceptable?(val)
+        int_val = coerce!(val)
+        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*')
+      end
+
+      def wire_type
+        ::Protobuf::WireType::VARINT
+      end
+
+    end
+  end
+end

data/lib/protobuf/generators/base.rb

@@ -0,0 +1,70 @@
+require 'protobuf/generators/printable'
+
+module Protobuf
+  module Generators
+    class Base
+      include ::Protobuf::Generators::Printable
+
+      def self.validate_tags(type_name, tags)
+        return if tags.empty?
+
+        unique_tags = tags.uniq
+
+        if unique_tags.size < tags.size
+          ::Protobuf::CodeGenerator.fatal("#{type_name} object has duplicate tags. Expected #{unique_tags.size} tags, but got #{tags.size}. Suppress with PB_NO_TAG_WARNINGS=1.")
+        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
+
+          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.")
+          end
+        end
+      end
+
+      attr_reader :descriptor, :namespace, :options
+
+      def initialize(descriptor, indent_level = 0, options = {})
+        @descriptor = descriptor
+        @options = options
+        @namespace = @options.fetch(:namespace) { [] }
+        init_printer(indent_level)
+      end
+
+      def fully_qualified_type_namespace
+        ".#{type_namespace.join('.')}"
+      end
+
+      def run_once(label, &block)
+        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
+      end
+
+      def to_s
+        compile
+        print_contents # see Printable
+      end
+
+      def type_namespace
+        @type_namespace ||= @namespace + [descriptor.name]
+      end
+
+    end
+  end
+end

data/lib/protobuf/generators/enum_generator.rb

@@ -0,0 +1,41 @@
+require 'protobuf/generators/base'
+
+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"
+              puts
+            end
+
+            descriptor.value.each do |enum_value_descriptor|
+              tags << enum_value_descriptor.number
+              puts build_value(enum_value_descriptor)
+            end
+          end
+
+          unless allow_alias?
+            self.class.validate_tags(fully_qualified_type_namespace, tags)
+          end
+        end
+      end
+
+      def build_value(enum_value_descriptor)
+        name = enum_value_descriptor.name
+        number = enum_value_descriptor.number
+        "define :#{name}, #{number}"
+      end
+
+    end
+  end
+end

data/lib/protobuf/generators/extension_generator.rb

@@ -0,0 +1,27 @@
+require 'protobuf/generators/base'
+require 'protobuf/generators/group_generator'
+
+module Protobuf
+  module Generators
+    class ExtensionGenerator < Base
+
+      def initialize(message_type, field_descriptors, indent_level)
+        super(nil, indent_level)
+        @message_type = modulize(message_type)
+        @field_descriptors = field_descriptors
+      end
+
+      def compile
+        run_once(:compile) do
+          print_class(@message_type, :message) do
+            group = GroupGenerator.new(current_indent)
+            group.add_extension_fields(@field_descriptors)
+            group.order = [:extension_field]
+            print group.to_s
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/protobuf/generators/field_generator.rb

@@ -0,0 +1,131 @@
+require 'protobuf/generators/base'
+
+module Protobuf
+  module Generators
+    class FieldGenerator < Base
+
+      ##
+      # Constants
+      #
+      PROTO_INFINITY_DEFAULT          = /^inf$/i.freeze
+      PROTO_NEGATIVE_INFINITY_DEFAULT = /^-inf$/i.freeze
+      PROTO_NAN_DEFAULT               = /^nan$/i.freeze
+      RUBY_INFINITY_DEFAULT           = '::Float::INFINITY'.freeze
+      RUBY_NEGATIVE_INFINITY_DEFAULT  = '-::Float::INFINITY'.freeze
+      RUBY_NAN_DEFAULT                = '::Float::NAN'.freeze
+
+      ##
+      # Attributes
+      #
+      attr_reader :field_options
+
+      def applicable_options
+        @applicable_options ||= field_options.map { |k, v| ":#{k} => #{v}" }
+      end
+
+      def default_value
+        @default_value ||= begin
+                             if defaulted?
+                               case descriptor.type.name
+                               when :TYPE_ENUM then
+                                 enum_default_value
+                               when :TYPE_STRING, :TYPE_BYTES then
+                                 string_default_value
+                               when :TYPE_FLOAT, :TYPE_DOUBLE then
+                                 float_double_default_value
+                               else
+                                 verbatim_default_value
+                               end
+                             end
+                           end
+      end
+
+      def defaulted?
+        descriptor.respond_to_has_and_present?(:default_value)
+      end
+
+      def deprecated?
+        descriptor.options.try(:deprecated?) { false }
+      end
+
+      def extension?
+        descriptor.respond_to_has_and_present?(:extendee)
+      end
+
+      def compile
+        run_once(:compile) do
+          field_definition = ["#{label} #{type_name}", name, number, applicable_options]
+          puts field_definition.flatten.compact.join(', ')
+        end
+      end
+
+      def label
+        @label ||= descriptor.label.name.to_s.downcase.sub(/label_/, '') # required, optional, repeated
+      end
+
+      def name
+        @name ||= ":#{descriptor.name}"
+      end
+
+      def number
+        @number ||= descriptor.number
+      end
+
+      def field_options
+        @field_options ||= begin
+                             opts = {}
+                             opts[:default] = default_value if defaulted?
+                             opts[:packed] = 'true' if packed?
+                             opts[:deprecated] = 'true' if deprecated?
+                             opts[:extension] = 'true' if extension?
+                             opts
+                           end
+      end
+
+      def packed?
+        descriptor.options.try(:packed?) { false }
+      end
+
+      # Determine the field type
+      def type_name
+        @type_name ||= begin
+                         case descriptor.type.name
+                         when :TYPE_MESSAGE, :TYPE_ENUM, :TYPE_GROUP then
+                           modulize(descriptor.type_name)
+                         else
+                           type_name = descriptor.type.name.to_s.downcase.sub(/type_/, '')
+                           ":#{type_name}"
+                         end
+                       end
+      end
+
+      private
+
+      def enum_default_value
+        "#{type_name}::#{verbatim_default_value}"
+      end
+
+      def float_double_default_value
+        case verbatim_default_value
+        when PROTO_INFINITY_DEFAULT then
+          RUBY_INFINITY_DEFAULT
+        when PROTO_NEGATIVE_INFINITY_DEFAULT then
+          RUBY_NEGATIVE_INFINITY_DEFAULT
+        when PROTO_NAN_DEFAULT then
+          RUBY_NAN_DEFAULT
+        else
+          verbatim_default_value
+        end
+      end
+
+      def string_default_value
+        %("#{verbatim_default_value.gsub(/'/, '\\\\\'')}")
+      end
+
+      def verbatim_default_value
+        descriptor.default_value
+      end
+
+    end
+  end
+end