contrast-agent 6.1.2 → 6.4.0

data/lib/protobuf/field/base_field_object_definitions.rb

@@ -0,0 +1,504 @@
+module Protobuf
+  module Field
+    module BaseFieldObjectDefinitions
+
+      class ToHashValueToMessageHashWithStringKey
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name.to_s
+        end
+
+        def call(values, result)
+          result[@name] = @selph.value_from_values(values).to_hash_value
+        end
+      end
+
+      class BaseToMessageHashWithStringKey
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name.to_s
+        end
+
+        def call(values, result)
+          result[@name] = @selph.value_from_values(values)
+        end
+      end
+
+      class ToHashValueToMessageHash
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name.to_sym
+        end
+
+        def call(values, result)
+          result[@name] = @selph.value_from_values(values).to_hash_value
+        end
+      end
+
+      class BaseToMessageHash
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name.to_sym
+        end
+
+        def call(values, result)
+          result[@name] = @selph.value_from_values(values)
+        end
+      end
+
+      class RepeatedPackedEncodeToStream
+        def initialize(selph)
+          @selph = selph
+          @tag_encoded = selph.tag_encoded
+        end
+
+        def call(value, stream)
+          packed_value = value.map { |val| @selph.encode(val) }.join
+          stream << @tag_encoded << "#{::Protobuf::Field::VarintField.encode(packed_value.size)}#{packed_value}"
+        end
+      end
+
+      class BytesEncodeToStream
+        def initialize(selph)
+          @selph = selph
+          @tag_encoded = selph.tag_encoded
+        end
+
+        def call(value, stream)
+          value = value.encode if value.is_a?(::Protobuf::Message)
+          byte_size = ::Protobuf::Field::VarintField.encode(value.bytesize)
+
+          stream << @tag_encoded << byte_size << value
+        end
+      end
+
+      class StringEncodeToStream
+        def initialize(selph)
+          @selph = selph
+          @tag_encoded = selph.tag_encoded
+        end
+
+        def call(value, stream)
+          new_value = "" + value
+          if new_value.encoding != ::Protobuf::Field::StringField::ENCODING
+            new_value.encode!(::Protobuf::Field::StringField::ENCODING, :invalid => :replace, :undef => :replace, :replace => "")
+          end
+
+          stream << @tag_encoded << ::Protobuf::Field::VarintField.encode(new_value.bytesize) << new_value
+        end
+      end
+
+      class BaseEncodeToStream
+        def initialize(selph)
+          @selph = selph
+          @tag_encoded = selph.tag_encoded
+        end
+
+        def call(value, stream)
+          stream << @tag_encoded << @selph.encode(value)
+        end
+      end
+
+      class RepeatedNotPackedEncodeToStream
+        def initialize(selph)
+          @selph = selph
+          @tag_encoded = selph.tag_encoded
+        end
+
+        def call(value, stream)
+          value.each do |val|
+            stream << @tag_encoded << @selph.encode(val)
+          end
+        end
+      end
+
+      class BaseSetMethod
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name
+        end
+
+        def call(message_instance, bytes)
+          message_instance.set_field(@name, @selph.decode(bytes), true, @selph)
+        end
+      end
+
+      class MapSetMethod
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name
+        end
+
+        def call(message_instance, bytes)
+          hash = message_instance[@name]
+          entry = @selph.decode(bytes)
+          # decoded value could be nil for an
+          # enum value that is not recognized
+          hash[entry.key] = entry.value unless entry.value.nil?
+          hash[entry.key]
+        end
+      end
+
+      class RepeatedNotPackedSetMethod
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name
+        end
+
+        def call(message_instance, bytes)
+          message_instance[@name] << @selph.decode(bytes)
+        end
+      end
+
+      class RepeatedPackedSetMethod
+        def initialize(selph)
+          @selph = selph
+          @name = selph.name
+          @wire_type = selph.wire_type
+        end
+
+        def call(message_instance, bytes)
+          array = message_instance[@name]
+          stream = ::StringIO.new(bytes)
+
+          if @wire_type == ::Protobuf::WireType::VARINT
+            array << @selph.decode(Varint.decode(stream)) until stream.eof?
+          elsif @wire_type == ::Protobuf::WireType::FIXED64
+            array << @selph.decode(stream.read(8)) until stream.eof?
+          elsif @wire_type == ::Protobuf::WireType::FIXED32
+            array << @selph.decode(stream.read(4)) until stream.eof?
+          end
+        end
+      end
+
+      class RequiredMapSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, message_instance)
+          unless value.is_a?(Hash)
+            fail TypeError, <<-TYPE_ERROR
+                    Expected map value
+                    Got '#{value.class}' for map protobuf field #{@selph.name}
+            TYPE_ERROR
+          end
+
+          if value.empty?
+            values.delete(@fully_qualified_name)
+            message_instance._protobuf_message_unset_required_field_tags << @tag
+          else
+            message_instance._protobuf_message_unset_required_field_tags.delete(@tag)
+            values[@fully_qualified_name] ||= ::Protobuf::Field::FieldHash.new(@selph)
+            values[@fully_qualified_name].replace(value)
+          end
+        end
+      end
+
+      class MapSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, _message_instance)
+          unless value.is_a?(Hash)
+            fail TypeError, <<-TYPE_ERROR
+                    Expected map value
+                    Got '#{value.class}' for map protobuf field #{@selph.name}
+            TYPE_ERROR
+          end
+
+          if value.empty?
+            values.delete(@fully_qualified_name)
+          else
+            values[@fully_qualified_name] ||= ::Protobuf::Field::FieldHash.new(@selph)
+            values[@fully_qualified_name].replace(value)
+          end
+        end
+      end
+
+      class RequiredRepeatedSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, ignore_nil_for_repeated, message_instance)
+          if value.nil? && ignore_nil_for_repeated
+            ::Protobuf.deprecator.deprecation_warning("['#{@fully_qualified_name}']=nil", "use an empty array instead of nil")
+            return
+          end
+
+          unless value.is_a?(Array)
+            fail TypeError, <<-TYPE_ERROR
+                  Expected repeated value of type '#{@selph.type_class}'
+                  Got '#{value.class}' for repeated protobuf field #{@selph.name}
+            TYPE_ERROR
+          end
+
+          value = value.compact
+
+          if value.empty?
+            values.delete(@fully_qualified_name)
+            message_instance._protobuf_message_unset_required_field_tags << @tag
+          else
+            message_instance._protobuf_message_unset_required_field_tags.delete(@tag)
+            values[@fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(@selph)
+            values[@fully_qualified_name].replace(value)
+          end
+        end
+      end
+
+      class RepeatedSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, ignore_nil_for_repeated, _message_instance)
+          if value.nil? && ignore_nil_for_repeated
+            ::Protobuf.deprecator.deprecation_warning("['#{@fully_qualified_name}']=nil", "use an empty array instead of nil")
+            return
+          end
+
+          unless value.is_a?(Array)
+            fail TypeError, <<-TYPE_ERROR
+                  Expected repeated value of type '#{@selph.type_class}'
+                  Got '#{value.class}' for repeated protobuf field #{@selph.name}
+            TYPE_ERROR
+          end
+
+          value = value.compact
+
+          if value.empty?
+            values.delete(@fully_qualified_name)
+          else
+            values[@fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(@selph)
+            values[@fully_qualified_name].replace(value)
+          end
+        end
+      end
+
+      class RequiredStringSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, message_instance)
+          if value
+            message_instance._protobuf_message_unset_required_field_tags.delete(@tag)
+            values[@fully_qualified_name] = if value.is_a?(String)
+                                              value
+                                            else
+                                              @selph.coerce!(value)
+                                            end
+          else
+            values.delete(@fully_qualified_name)
+            message_instance._protobuf_message_unset_required_field_tags << @tag
+          end
+        end
+      end
+
+      class StringSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, _message_instance)
+          if value
+            values[@fully_qualified_name] = if value.is_a?(String)
+                                              value
+                                            else
+                                              @selph.coerce!(value)
+                                            end
+          else
+            values.delete(@fully_qualified_name)
+          end
+        end
+      end
+
+      class RequiredBaseSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, message_instance)
+          if value.nil?
+            values.delete(@fully_qualified_name)
+            message_instance._protobuf_message_unset_required_field_tags << @tag
+          else
+            message_instance._protobuf_message_unset_required_field_tags.delete(@tag)
+            values[@fully_qualified_name] = @selph.coerce!(value)
+          end
+        end
+      end
+
+      class BaseSetField
+        def initialize(selph)
+          @selph = selph
+          @tag = selph.tag
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values, value, _ignore_nil_for_repeated, _message_instance)
+          if value.nil?
+            values.delete(@fully_qualified_name)
+          else
+            values[@fully_qualified_name] = @selph.coerce!(value)
+          end
+        end
+      end
+
+      class BaseFieldAndPresentPredicate
+        def initialize(selph)
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name].present?
+        end
+      end
+
+      class BoolFieldAndPresentPredicate
+        BOOL_VALUES = [true, false].freeze
+
+        def initialize(selph)
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          BOOL_VALUES.include?(values[@fully_qualified_name])
+        end
+      end
+
+      class BaseFieldPredicate
+        def initialize(selph)
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values.key?(@fully_qualified_name)
+        end
+      end
+
+      class RepeatedFieldPredicate
+        def initialize(selph)
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values.key?(@fully_qualified_name) &&
+            values[@fully_qualified_name].present?
+        end
+      end
+
+      class BoolFieldValueFromValues
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values.fetch(@fully_qualified_name) { @selph.default_value }
+        end
+      end
+
+      class BoolFieldValueFromValuesForSerialization
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values.fetch(@fully_qualified_name) { @selph.default_value }
+        end
+      end
+
+      class BaseFieldValueFromValues
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name] || @selph.default_value
+        end
+      end
+
+      class BaseFieldValueFromValuesForSerialization
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name] || @selph.default_value
+        end
+      end
+
+      class MapValueFromValues
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name] ||= ::Protobuf::Field::FieldHash.new(@selph)
+        end
+      end
+
+      class MapValueFromValuesForSerialization
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+          @type_class = selph.type_class
+        end
+
+        def call(values)
+          value = values[@fully_qualified_name] ||= ::Protobuf::Field::FieldHash.new(@selph)
+
+          array = []
+          value.each do |k, v|
+            array << @type_class.new(:key => k, :value => v)
+          end
+
+          array
+        end
+      end
+
+      class RepeatedFieldValueFromValues
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(@selph)
+        end
+      end
+
+      class RepeatedFieldValueFromValuesForSerialization
+        def initialize(selph)
+          @selph = selph
+          @fully_qualified_name = selph.fully_qualified_name
+        end
+
+        def call(values)
+          values[@fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(@selph)
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/field/bool_field.rb

@@ -0,0 +1,64 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class BoolField < VarintField
+      ONE = 1
+      FALSE_ENCODE = [0].pack('C')
+      FALSE_STRING = "false".freeze
+      FALSE_VALUES = [false, FALSE_STRING].freeze
+      TRUE_ENCODE = [1].pack('C')
+      TRUE_STRING = "true".freeze
+      TRUE_VALUES = [true, TRUE_STRING].freeze
+      ACCEPTABLES = [true, false, TRUE_STRING, FALSE_STRING].freeze
+
+      ##
+      # Class Methods
+      #
+
+      def self.default
+        false
+      end
+
+      ##
+      # Public Instance Methods
+      # #
+
+      def acceptable?(val)
+        ACCEPTABLES.include?(val)
+      end
+
+      def coerce!(val)
+        if TRUE_VALUES.include?(val)
+          true
+        elsif FALSE_VALUES.include?(val)
+          false
+        else
+          fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{val.class}'"
+        end
+      end
+
+      def decode(value)
+        value == ONE
+      end
+
+      def encode(value)
+        value ? TRUE_ENCODE : FALSE_ENCODE
+      end
+
+      private
+
+      ##
+      # Private Instance Methods
+      #
+
+      def define_accessor(simple_field_name, _fully_qualified_field_name)
+        super
+        message_class.class_eval do
+          alias_method "#{simple_field_name}?", simple_field_name
+        end
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/bytes_field.rb

@@ -0,0 +1,67 @@
+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.is_a?(String) || val.nil? || val.is_a?(Symbol) || val.is_a?(::Protobuf::Message)
+      end
+
+      def decode(bytes)
+        bytes.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        bytes
+      end
+
+      def encode(value)
+        value_to_encode = if value.is_a?(::Protobuf::Message)
+                            value.encode
+                          else
+                            "" + value
+                          end
+
+        value_to_encode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        "#{::Protobuf::Field::VarintField.encode(value_to_encode.bytesize)}#{value_to_encode}"
+      end
+
+      def wire_type
+        ::Protobuf::WireType::LENGTH_DELIMITED
+      end
+
+      def coerce!(value)
+        case value
+        when String, Symbol
+          value.to_s
+        when NilClass
+          nil
+        when ::Protobuf::Message
+          value.dup
+        else
+          fail TypeError, "Unacceptable value #{value} for field #{name} of type #{type_class}"
+        end
+      end
+
+      def json_encode(value)
+        Base64.strict_encode64(value)
+      end
+    end
+  end
+end

data/lib/protobuf/field/double_field.rb

@@ -0,0 +1,25 @@
+require 'protobuf/field/float_field'
+
+module Protobuf
+  module Field
+    class DoubleField < FloatField
+
+      ##
+      # Public Instance Methods
+      #
+
+      def decode(bytes)
+        bytes.unpack('E').first
+      end
+
+      def encode(value)
+        [value].pack('E')
+      end
+
+      def wire_type
+        WireType::FIXED64
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/enum_field.rb

@@ -0,0 +1,56 @@
+require 'protobuf/field/integer_field'
+
+module Protobuf
+  module Field
+    class EnumField < IntegerField
+
+      ##
+      # Class Methods
+      #
+
+      def self.default
+        fail NoMethodError, "#{self}.#{__method__} must be called on an instance"
+      end
+
+      ##
+      # Public Instance Methods
+      #
+      def encode(value)
+        # original CSGoogle's library uses 64bits integer for negative value
+        ::Protobuf::Field::VarintField.encode(value.to_i & 0xffff_ffff_ffff_ffff)
+      end
+
+      def decode(value)
+        value -= 0x1_0000_0000_0000_0000 if (value & 0x8000_0000_0000_0000).nonzero?
+        value if acceptable?(value)
+      end
+
+      def acceptable?(val)
+        !type_class.fetch(val).nil?
+      end
+
+      def enum?
+        true
+      end
+
+      def coerce!(value)
+        type_class.fetch(value) || fail(TypeError, "Invalid Enum value: #{value.inspect} for #{name}")
+      end
+
+      private
+
+      ##
+      # Private Instance Methods
+      #
+
+      def typed_default_value
+        if default.is_a?(Symbol)
+          type_class.const_get(default)
+        else
+          type_class.fetch(default) || type_class.enums.first
+        end
+      end
+
+    end
+  end
+end