contrast-agent 6.1.2 → 6.4.0

data/lib/protobuf/field/field_array.rb

@@ -0,0 +1,102 @@
+module Protobuf
+  module Field
+    class FieldArray < Array
+
+      ##
+      # Attributes
+      #
+
+      attr_reader :field
+
+      ##
+      # Constructor
+      #
+
+      def initialize(field)
+        @field = field
+      end
+
+      ##
+      # Public Instance Methods
+      #
+
+      def []=(nth, val)
+        super(nth, normalize(val)) unless val.nil?
+      end
+
+      def <<(val)
+        super(normalize(val)) unless val.nil?
+      end
+
+      def push(val)
+        super(normalize(val)) unless val.nil?
+      end
+
+      def replace(val)
+        raise_type_error(val) unless val.is_a?(Array)
+        val.map! { |v| normalize(v) }
+        super(val)
+      end
+
+      # Return a hash-representation of the given values for this field type.
+      # The value in this case would be an array.
+      def to_hash_value
+        map do |value|
+          value.respond_to?(:to_hash_value) ? value.to_hash_value : value
+        end
+      end
+
+      # Return a hash-representation of the given values for this field type
+      # that is safe to convert to JSON.
+      # The value in this case would be an array.
+      def to_json_hash_value
+        if field.respond_to?(:json_encode)
+          map do |value|
+            field.json_encode(value)
+          end
+        else
+          map do |value|
+            value.respond_to?(:to_json_hash_value) ? value.to_json_hash_value : value
+          end
+        end
+      end
+
+      def to_s
+        "[#{field.name}]"
+      end
+
+      def unshift(val)
+        super(normalize(val)) unless val.nil?
+      end
+
+      private
+
+      ##
+      # Private Instance Methods
+      #
+
+      def normalize(value)
+        value = value.to_proto if value.respond_to?(:to_proto)
+        fail TypeError, "Unacceptable value #{value} for field #{field.name} of type #{field.type_class}" unless field.acceptable?(value)
+
+        if field.is_a?(::Protobuf::Field::EnumField)
+          field.type_class.fetch(value)
+        elsif field.is_a?(::Protobuf::Field::MessageField) && value.is_a?(field.type_class)
+          value
+        elsif field.is_a?(::Protobuf::Field::MessageField) && value.respond_to?(:to_hash)
+          field.type_class.new(value.to_hash)
+        else
+          value
+        end
+      end
+
+      def raise_type_error(val)
+        fail TypeError, <<-TYPE_ERROR
+          Expected repeated value of type '#{field.type_class}'
+          Got '#{val.class}' for repeated protobuf field #{field.name}
+        TYPE_ERROR
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/field_hash.rb

@@ -0,0 +1,122 @@
+module Protobuf
+  module Field
+    class FieldHash < Hash
+
+      ##
+      # Attributes
+      #
+
+      attr_reader :field, :key_field, :value_field
+
+      ##
+      # Constructor
+      #
+
+      def initialize(field)
+        @field = field
+        @key_field = field.type_class.get_field(:key)
+        @value_field = field.type_class.get_field(:value)
+      end
+
+      ##
+      # Public Instance Methods
+      #
+
+      def []=(key, val)
+        super(normalize_key(key), normalize_val(val))
+      end
+
+      alias store []=
+
+      def replace(val)
+        raise_type_error(val) unless val.is_a?(Hash)
+        clear
+        update(val)
+      end
+
+      def merge!(other)
+        raise_type_error(other) unless other.is_a?(Hash)
+        # keys and values will be normalized by []= above
+        other.each { |k, v| self[k] = v }
+      end
+
+      alias update merge!
+
+      # Return a hash-representation of the given values for this field type.
+      # The value in this case would be the hash itself, right? Unfortunately
+      # not because the values of the map could be messages themselves that we
+      # need to transform.
+      def to_hash_value
+        each_with_object({}) do |(key, value), hash|
+          hash[key] = value.respond_to?(:to_hash_value) ? value.to_hash_value : value
+        end
+      end
+
+      # Return a hash-representation of the given values for this field type
+      # that is safe to convert to JSON.
+      #
+      # The value in this case would be the hash itself, right? Unfortunately
+      # not because the values of the map could be messages themselves that we
+      # need to transform.
+      def to_json_hash_value
+        if field.respond_to?(:json_encode)
+          each_with_object({}) do |(key, value), hash|
+            hash[key] = field.json_encode(value)
+          end
+        else
+          each_with_object({}) do |(key, value), hash|
+            hash[key] = value.respond_to?(:to_json_hash_value) ? value.to_json_hash_value : value
+          end
+        end
+      end
+
+      def to_s
+        "{#{field.name}}"
+      end
+
+      private
+
+      ##
+      # Private Instance Methods
+      #
+
+      def normalize_key(key)
+        normalize(:key, key, key_field)
+      end
+
+      def normalize_val(value)
+        normalize(:value, value, value_field)
+      end
+
+      def normalize(what, value, normalize_field)
+        raise_type_error(value) if value.nil?
+        value = value.to_proto if value.respond_to?(:to_proto)
+        fail TypeError, "Unacceptable #{what} #{value} for field #{field.name} of type #{normalize_field.type_class}" unless normalize_field.acceptable?(value)
+
+        if normalize_field.is_a?(::Protobuf::Field::EnumField)
+          fetch_enum(normalize_field.type_class, value)
+        elsif normalize_field.is_a?(::Protobuf::Field::MessageField) && value.is_a?(normalize_field.type_class)
+          value
+        elsif normalize_field.is_a?(::Protobuf::Field::MessageField) && value.respond_to?(:to_hash)
+          normalize_field.type_class.new(value.to_hash)
+        else
+          value
+        end
+      end
+
+      def fetch_enum(type, val)
+        en = type.fetch(val)
+        raise_type_error(val) if en.nil?
+        en
+      end
+
+      def raise_type_error(val)
+        fail TypeError, <<-TYPE_ERROR
+          Expected map value of type '#{key_field.type_class} -> #{value_field.type_class}'
+          Got '#{val.class}' for map protobuf field #{field.name}
+        TYPE_ERROR
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/fixed32_field.rb

@@ -0,0 +1,25 @@
+require 'protobuf/field/uint32_field'
+
+module Protobuf
+  module Field
+    class Fixed32Field < Uint32Field
+
+      ##
+      # Public Instance Methods
+      #
+
+      def decode(bytes)
+        bytes.unpack('V').first
+      end
+
+      def encode(value)
+        [value].pack('V')
+      end
+
+      def wire_type
+        ::Protobuf::WireType::FIXED32
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/fixed64_field.rb

@@ -0,0 +1,28 @@
+require 'protobuf/field/uint64_field'
+
+module Protobuf
+  module Field
+    class Fixed64Field < Uint64Field
+
+      ##
+      # Public Instance Methods
+      #
+
+      def decode(bytes)
+        # we don't use 'Q' for pack/unpack. 'Q' is machine-dependent.
+        values = bytes.unpack('VV')
+        values[0] + (values[1] << 32)
+      end
+
+      def encode(value)
+        # we don't use 'Q' for pack/unpack. 'Q' is machine-dependent.
+        [value & 0xffff_ffff, value >> 32].pack('VV')
+      end
+
+      def wire_type
+        ::Protobuf::WireType::FIXED64
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/float_field.rb

@@ -0,0 +1,43 @@
+require 'protobuf/field/base_field'
+
+module Protobuf
+  module Field
+    class FloatField < BaseField
+
+      ##
+      # Class Methods
+      #
+
+      def self.default
+        0.0
+      end
+
+      ##
+      # Public Instance Methods
+      #
+
+      def acceptable?(val)
+        val.respond_to?(:to_f)
+      end
+
+      def coerce!(val)
+        Float(val)
+      rescue ArgumentError
+        fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{val.class}'"
+      end
+
+      def decode(bytes)
+        bytes.unpack('e').first
+      end
+
+      def encode(value)
+        [value].pack('e')
+      end
+
+      def wire_type
+        WireType::FIXED32
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/int32_field.rb

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

data/lib/protobuf/field/int64_field.rb

@@ -0,0 +1,34 @@
+require 'protobuf/field/integer_field'
+
+module Protobuf
+  module Field
+    class Int64Field < IntegerField
+
+      ##
+      # Class Methods
+      #
+
+      def self.max
+        INT64_MAX
+      end
+
+      def self.min
+        INT64_MIN
+      end
+
+      ##
+      # Instance Methods
+      #
+      def acceptable?(val)
+        if val.is_a?(Integer) || val.is_a?(Numeric)
+          val >= INT64_MIN && val <= INT64_MAX
+        else
+          Integer(val, 10) >= INT64_MIN && Integer(val, 10) <= INT64_MAX
+        end
+      rescue
+        return false
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/integer_field.rb

@@ -0,0 +1,23 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class IntegerField < VarintField
+
+      ##
+      # Public Instance Methods
+      #
+
+      def decode(value)
+        value -= 0x1_0000_0000_0000_0000 if (value & 0x8000_0000_0000_0000).nonzero?
+        value
+      end
+
+      def encode(value)
+        # original CSGoogle's library uses 64bits integer for negative value
+        ::Protobuf::Field::VarintField.encode(value & 0xffff_ffff_ffff_ffff)
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/message_field.rb

@@ -0,0 +1,51 @@
+require 'protobuf/field/base_field'
+
+module Protobuf
+  module Field
+    class MessageField < BaseField
+
+      ##
+      # Public Instance Methods
+      #
+
+      def acceptable?(val)
+        val.is_a?(type_class) || val.respond_to?(:to_hash) || val.respond_to?(:to_proto)
+      end
+
+      def decode(bytes)
+        type_class.decode(bytes)
+      end
+
+      def encode(value)
+        bytes = value.encode
+        result = ::Protobuf::Field::VarintField.encode(bytes.bytesize)
+        result << bytes
+      end
+
+      def message?
+        true
+      end
+
+      def wire_type
+        ::Protobuf::WireType::LENGTH_DELIMITED
+      end
+
+      def coerce!(value)
+        return nil if value.nil?
+
+        coerced_value = if value.respond_to?(:to_proto)
+                          value.to_proto
+                        elsif value.respond_to?(:to_hash)
+                          type_class.new(value.to_hash)
+                        else
+                          value
+                        end
+
+        return coerced_value if coerced_value.is_a?(type_class)
+
+        fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{value.class}'"
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/sfixed32_field.rb

@@ -0,0 +1,27 @@
+require 'protobuf/field/int32_field'
+
+module Protobuf
+  module Field
+    class Sfixed32Field < Int32Field
+
+      ##
+      # Public Instance Methods
+      #
+
+      def decode(bytes)
+        value  = bytes.unpack('V').first
+        value -= 0x1_0000_0000 if (value & 0x8000_0000).nonzero?
+        value
+      end
+
+      def encode(value)
+        [value].pack('V')
+      end
+
+      def wire_type
+        ::Protobuf::WireType::FIXED32
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/sfixed64_field.rb

@@ -0,0 +1,28 @@
+require 'protobuf/field/int64_field'
+
+module Protobuf
+  module Field
+    class Sfixed64Field < Int64Field
+
+      ##
+      # Public Instance Methods
+      #
+
+      def decode(bytes)
+        values = bytes.unpack('VV') # 'Q' is machine-dependent, don't use
+        value  = values[0] + (values[1] << 32)
+        value -= 0x1_0000_0000_0000_0000 if (value & 0x8000_0000_0000_0000).nonzero?
+        value
+      end
+
+      def encode(value)
+        [value & 0xffff_ffff, value >> 32].pack('VV') # 'Q' is machine-dependent, don't use
+      end
+
+      def wire_type
+        ::Protobuf::WireType::FIXED64
+      end
+
+    end
+  end
+end

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,51 @@
+require 'protobuf/field/bytes_field'
+
+module Protobuf
+  module Field
+    class StringField < BytesField
+
+      ##
+      # Constants
+      #
+
+      ENCODING = Encoding::UTF_8
+
+      ##
+      # Public Instance Methods
+      #
+
+      def acceptable?(val)
+        val.is_a?(String) || val.nil? || val.is_a?(Symbol)
+      end
+
+      def coerce!(value)
+        if value.nil?
+          nil
+        elsif acceptable?(value)
+          value.to_s
+        else
+          fail TypeError, "Unacceptable value #{value} for field #{name} of type #{type_class}"
+        end
+      end
+
+      def decode(bytes)
+        bytes.force_encoding(::Protobuf::Field::StringField::ENCODING)
+        bytes
+      end
+
+      def encode(value)
+        value_to_encode = "" + value # dup is slower
+        unless value_to_encode.encoding == ENCODING
+          value_to_encode.encode!(::Protobuf::Field::StringField::ENCODING, :invalid => :replace, :undef => :replace, :replace => "")
+        end
+        value_to_encode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+
+        "#{::Protobuf::Field::VarintField.encode(value_to_encode.bytesize)}#{value_to_encode}"
+      end
+
+      def json_encode(value)
+        value
+      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