protobuf-cucumber 3.10.4

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,78 @@
+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
+          if value.encoding == Encoding::ASCII_8BIT
+            # This is a "binary" string
+            value
+          else
+            # Assume the value is Base64 encoded (from JSON)
+            # Ideally we'd do the Base64 decoding while processing the JSON,
+            # but this is tricky to do since we don't know the protobuf field
+            # types when we do that.
+            Base64.decode64(value)
+          end
+        when 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,61 @@
+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 Google'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
+
+      def json_encode(value)
+        enum = type_class.enums.find { |e| e.to_i == value }
+        enum.to_s(: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

data/lib/protobuf/field/field_array.rb

@@ -0,0 +1,104 @@
+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(options = {})
+        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(options) : 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::BytesField)
+          field.coerce!(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(options = {})
+        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(options) : 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