ruby_protobuf 0.3.2 → 0.3.3

data/lib/protobuf/compiler/visitors.rb

@@ -48,7 +48,11 @@ module Protobuf
       end
 
       def commented_proto_contents
-        File.read(proto_file).gsub(/^/, '# ') if proto_file
+        if proto_file
+          proto_filepath = File.exist?(proto_file) ? 
+            proto_file : "#{@proto_dir}/#{proto_file}"
+          File.read(proto_filepath).gsub(/^/, '# ')
+        end
       end
 
       def write(str)

data/lib/protobuf/descriptor/enum_descriptor.rb

@@ -22,7 +22,7 @@ module Protobuf
         enum_proto.name = @enum_class.name.split('::').last
         @enum_class.constants.each do |const|
           enum_value_proto = Google::Protobuf::EnumValueDescriptorProto.new
-          enum_value_proto.name = const
+          enum_value_proto.name = const.to_s
           enum_value_proto.number = @enum_class.const_get const
           enum_proto.value << enum_value_proto
         end

data/lib/protobuf/message/decoder.rb

@@ -42,39 +42,36 @@ module Protobuf
     protected
 
     def read_key(stream)
-      # TODO is there more clear way to do this?
-      bits = 0
       bytes = read_varint stream
-      bytes.each_with_index do |byte, index|
-        byte &= 0b01111111
-        bits |= byte << (7 * index)
-      end
-      wire_type = bits & 0b00000111
+      bits = Protobuf::Field::VarintField.decode bytes
+      wire_type = bits & 0x07
       tag = bits >> 3
       [tag, wire_type]
     end
 
     def read_varint(stream)
+      read_method = stream.respond_to?(:readbyte) ? :readbyte : :readchar
       bytes = []
       begin
-        byte = stream.readchar
-        bytes << (byte & 0b01111111)
-      end while byte >> 7 == 1
+        byte = stream.send(read_method)
+        bytes << (byte & 0x7f)
+      end while (byte & 0x80).nonzero?
       bytes
     end
 
+    def read_fixed32(stream)
+      stream.read(4)
+    end
+
     def read_fixed64(stream)
       stream.read(8)
     end
 
     def read_length_delimited(stream)
       bytes = read_varint stream
-      value_length = 0
-      bytes.each_with_index do |byte, index|
-        value_length |= byte << (7 * index)
-      end
+      value_length = Protobuf::Field::VarintField.decode bytes
       value = stream.read value_length
-      value.unpack('c*')
+      value.unpack('C*')
     end
 
     def read_start_group(stream)
@@ -84,9 +81,5 @@ module Protobuf
     def read_end_group(stream)
       raise NotImplementedError.new('Group is duplecated.')
     end
-
-    def read_fixed32(stream)
-      stream.read(4)
-    end
   end
 end

data/lib/protobuf/message/encoder.rb

@@ -1,6 +1,8 @@
 require 'protobuf/common/wire_type'
 
 module Protobuf
+  class NotInitializedError < StandardError; end
+
   class Encoder
     class <<self
       def encode(stream, message)
@@ -13,8 +15,9 @@ module Protobuf
     end
 
     def encode(stream=@stream, message=@message)
+      raise NotInitializedError unless message.initialized?
       message.each_field do |field, value|
-        next unless value # TODO
+        next unless message.has_field?(field.name)
 
         if field.repeated?
           value.each do |val|
@@ -28,7 +31,7 @@ module Protobuf
 
     def write_pair(field, value, stream)
       key = (field.tag << 3) | field.wire_type
-      key_bytes = Protobuf::Field::VarintField.get_bytes key
+      key_bytes = Protobuf::Field::VarintField.encode key
       stream.write key_bytes
       bytes = field.get value
       stream.write bytes

data/lib/protobuf/message/enum.rb

@@ -8,7 +8,7 @@ module Protobuf
 
       def get_name_by_tag(tag)
         constants.find do |name|
-          class_eval(name) == tag
+          const_get(name) == tag
         end
       end
 

data/lib/protobuf/message/field.rb

@@ -4,9 +4,9 @@ require 'protobuf/descriptor/field_descriptor'
 module Protobuf
   module Field
     def self.build(message_class, rule, type, name, tag, opts={})
-      field_class = 
-        if [:double, :float, :int32, :int64, :uint32, :uint64, 
-          :sint32, :sint64, :fixed32, :fixed64, :sfixed32, :sfixed64, 
+      field_class =
+        if [:double, :float, :int32, :int64, :uint32, :uint64,
+          :sint32, :sint64, :fixed32, :fixed64, :sfixed32, :sfixed64,
           :bool, :string, :bytes].include? type
           eval "Protobuf::Field::#{type.to_s.capitalize}Field"
         else
@@ -22,6 +22,8 @@ module Protobuf
         def descriptor
           @descriptor ||= Protobuf::Descriptor::FieldDescriptor.new
         end
+
+        def default; nil end
       end
 
       attr_accessor :message_class, :rule, :type, :name, :tag, :default
@@ -31,9 +33,10 @@ module Protobuf
       end
 
       def initialize(message_class, rule, type, name, tag, opts={})
-        @message_class, @rule, @type, @name, @tag, @default, @extension = 
+        @message_class, @rule, @type, @name, @tag, @default, @extension =
           message_class, rule, type, name, tag, opts[:default], opts[:extension]
         @error_message = 'Type invalid'
+        define_accessor
       end
 
       def ready?; true end
@@ -44,9 +47,11 @@ module Protobuf
           return false if message[name].nil?
           return false if is_a?(Protobuf::Field::MessageField) and not message[name].initialized?
         when :repeated
-          return message[name].inject(true) do |result, msg|
-            result and msg.initialized?
-          end
+          return message[name].all? {|msg|
+            (not is_a?(Protobuf::Field::MessageField)) or msg.initialized?
+          }
+        when :optional
+          return false if message[name] and is_a?(Protobuf::Field::MessageField) and not message[name].initialized?
         end
         true
       end
@@ -55,7 +60,7 @@ module Protobuf
         if repeated?
           message[name].clear
         else
-          message[name] = default_value
+          message.instance_variable_get(:@values).delete(name)
         end
       end
 
@@ -73,60 +78,81 @@ module Protobuf
       end
 
       def typed_default_value(default=nil)
-        default
+        default or self.class.default
       end
 
-      def define_accessor(message_instance)
-        message_instance.instance_variable_set "@#{name}", default_value
-        define_getter message_instance
-        define_setter message_instance unless rule == :repeated
+      private
+
+      def define_accessor
+        define_getter
+        if rule == :repeated
+          define_array_setter
+        else
+          define_setter
+        end
       end
 
-      def define_getter(message_instance)
-        message_instance.instance_eval %Q{
-          def #{name}
-            @#{name}
+      def define_getter
+        field = self
+        @message_class.class_eval do
+          define_method(field.name) do
+            if @values.has_key?(field.name)
+              @values[field.name]
+            else
+              field.default_value
+            end
           end
-        }
+        end
       end
 
-      def define_setter(message_instance)
-        extension = @extension
-        message_instance.instance_eval %Q{
-          def #{name}=(val)
-            field = get_#{extension ? 'ext_' : ''}field_by_name #{name.inspect}
+      def define_setter
+        field = self
+        @message_class.class_eval do
+          define_method("#{field.name}=") do |val|
             if val.nil?
-              @#{name} = field.default_value
+              @values.delete(field.name)
             elsif field.acceptable? val
-              @#{name} = val
+              @values[field.name] = val
             end
           end
-        }
+        end
+      end
+
+      def define_array_setter
+        field = self
+        @message_class.class_eval do
+          define_method("#{field.name}=") do |val|
+            @values[field.name].replace(val)
+          end
+        end
       end
 
+      public
+
+      # encoder/decoder related methods
+
       def set(message_instance, bytes)
+        value = decode(bytes)
         if repeated?
-          set_array message_instance, bytes
+          message_instance.send(name) << value
         else
-          set_bytes message_instance, bytes
+          message_instance.send("#{name}=", value)
         end
       end
 
-      def set_array(message_instance, bytes)
-        raise NotImplementedError
+      def get(value)
+        encode(value)
       end
 
-      def set_bytes(message_instance, bytes)
-        raise NotImplementedError
+      def decode(bytes)
+        raise NotImplementedError.new("#{self.class.name}\#decode")
       end
+      private :decode
 
-      def get(value)
-        get_bytes value
-      end
-
-      def get_bytes(value)
-        raise NotImplementedError
+      def encode(value)
+        raise NotImplementedError.new("#{self.class.name}\#encode")
       end
+      private :encode
 
       def merge(message_instance, value)
         if repeated?
@@ -137,13 +163,15 @@ module Protobuf
       end
 
       def merge_array(message_instance, value)
-        message_instance[tag].concat value 
+        message_instance[tag].concat value
       end
 
       def merge_value(message_instance, value)
         message_instance[tag] = value
       end
 
+      # utility methods
+
       def repeated?; rule == :repeated end
       def required?; rule == :required end
       def optional?; rule == :optional end
@@ -180,22 +208,26 @@ module Protobuf
           elsif type.superclass == Protobuf::Message
             Protobuf::Field::MessageField
           else
-            raise $!
+            raise TypeError.new(type.inspect)
           end
         field_class.new @message_class, @rule, type, @name, @tag, @opts
       end
 
       def typename_to_class(message_class, type)
+        suffix = type.to_s.split('::')
         modules = message_class.to_s.split('::')
+        args = (Object.method(:const_defined?).arity == 1) ? [] : [nil, false]
         while
-          begin
-            type = eval((modules | [type.to_s]).join('::'))
-            break
-          rescue NameError
-            modules.empty? ? raise($!) : modules.pop
-          end
+          mod = modules.empty? ? Object : eval(modules.join('::'))
+          mod = suffix.inject(mod) {|m, s|
+            args[0] = s
+            m and m.const_defined?(*args) and m.const_get(s)
+          }
+          break if mod
+          raise NameError.new("type not found: #{type}", type) if modules.empty?
+          modules.pop
         end
-        type
+        mod
       end
     end
 
@@ -205,136 +237,119 @@ module Protobuf
       end
 
       def []=(nth, val)
-        if @field.acceptable? val
-          super
-        end
+        super(normalize(val))
       end
 
       def <<(val)
-        if @field.acceptable? val
-          super
-        end
+        super(normalize(val))
       end
 
       def push(val)
-        if @field.acceptable? val
-          super
-        end
+        super(normalize(val))
       end
 
       def unshift(val)
-        if @field.acceptable? val
-          super
-        end
+        super(normalize(val))
       end
 
-      def to_s
-        "[#{@field.name}]"
+      def replace(val)
+        raise TypeError unless val.is_a?(Array)
+        val = val.map {|v| normalize(v)}
+        super(val)
       end
-    end
 
-    class StringField < BaseField
-      def wire_type
-        Protobuf::WireType::LENGTH_DELIMITED
+      def to_s
+        "[#{@field.name}]"
       end
 
-      def typed_default_value(default=nil)
-        default or ''
-      end
+      private
 
-      def acceptable?(val)
-        raise TypeError unless val.instance_of? String
-        true
+      def normalize(val)
+        raise TypeError unless @field.acceptable?(val)
+        if @field.is_a?(MessageField) && val.is_a?(Hash)
+          @field.type.new(val)
+        else
+          val
+        end
       end
+    end
 
-      def set_bytes(message_instance, bytes)
-        message_instance.send("#{name}=", bytes.pack('U*'))
-      end
- 
-      def set_array(message_instance, bytes)
-        message = bytes.pack('U*')
-        arr = message_instance.send name
-        arr << message
+    class BytesField < BaseField
+      class <<self
+        def default; '' end
       end
 
-      def get_bytes(value)
-        bytes = value.unpack('U*')
-        string_size = VarintField.get_bytes bytes.size
-        #(string_size + bytes).pack('C*')
-        string_size + bytes.pack('C*')
-      end
-    end
-    
-    class BytesField < BaseField
       def wire_type
         Protobuf::WireType::LENGTH_DELIMITED
       end
 
-      def typed_default_value(default=nil)
-        default or ''
-      end
-
       def acceptable?(val)
         raise TypeError unless val.instance_of? String
         true
       end
 
-      def set_bytes(message_instance, bytes)
-        message_instance.send("#{name}=", bytes.pack('C*'))
+      def decode(bytes)
+        bytes.pack('C*')
       end
- 
-      def set_array(message_instance, bytes)
-        message = bytes.pack('C*')
-        arr = message_instance.send name
-        arr << message
+
+      def encode(value)
+        value = value.dup
+        value.force_encoding('ASCII-8BIT') if value.respond_to?(:force_encoding)
+        string_size = VarintField.encode(value.size)
+        string_size << value
       end
+    end
 
-      def get_bytes(value)
-        string_size = VarintField.get_bytes value.unpack('C*').size
-        string_size + value
+    class StringField < BytesField
+      def decode(bytes)
+        message = bytes.pack('C*')
+        message.force_encoding('UTF-8') if message.respond_to?(:force_encoding)
+        message
       end
     end
 
     class VarintField < BaseField
-      def wire_type
-        Protobuf::WireType::VARINT
-      end
+      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
 
-      def typed_default_value(default=nil)
-        default or 0
-      end
- 
-      def set_bytes(message_instance, bytes)
-        # TODO should refactor using pack('w*')
-        value = 0
-        bytes.each_with_index do |byte, index|
-          value |= byte << (7 * index)
+      class <<self
+        def default; 0 end
+
+        def decode(bytes)
+          value = 0
+          bytes.each_with_index do |byte, index|
+            value |= byte << (7 * index)
+          end
+          value
         end
-        message_instance.send("#{name}=", value)
-      end
-
-      def self.get_bytes(value)
-        # TODO should refactor using unpack('w*')
-        #return [value].pack('w*').unpack('C*')
-        return [0].pack('C') if value == 0
-        bytes = []
-        until value == 0
-          byte = 0
-          7.times do |i|
-            byte |= (value & 1) << i
-            value >>= 1
+
+        def encode(value)
+          raise RangeError.new(value) if value < 0
+          return [value].pack('C') if value < 128
+          bytes = []
+          until value == 0
+            bytes << (0x80 | (value & 0x7f))
+            value >>= 7
           end
-          byte |= 0b10000000
-          bytes << byte
+          bytes[-1] &= 0x7f
+          bytes.pack('C*')
         end
-        #bytes[0] &= 0b01111111
-        #bytes
-        bytes[bytes.size - 1] &= 0b01111111
-        bytes.pack('C*')
       end
 
-      def get_bytes(value)
-        self.class.get_bytes value
+      def wire_type
+        Protobuf::WireType::VARINT
+      end
+
+      def decode(bytes)
+        self.class.decode(bytes)
+      end
+
+      def encode(value)
+        self.class.encode(value)
       end
 
       def acceptable?(val)
@@ -343,92 +358,86 @@ module Protobuf
         true
       end
     end
-    
-    class Int32Field < VarintField
-      def self.max; 1.0/0.0 end
-      def self.min; -1.0/0.0 end
+
+    # Base class for int32 and int64
+    class IntegerField < VarintField
+      def encode(value)
+        # original Google's library uses 64bits integer for negative value
+        VarintField.encode(value & 0xffff_ffff_ffff_ffff)
+      end
+
+      def decode(bytes)
+        value  = VarintField.decode(bytes)
+        value -= 0x1_0000_0000_0000_0000 if (value & 0x8000_0000_0000_0000).nonzero?
+        value
+      end
     end
-    
-    class Int64Field < VarintField
-      def self.max; 1.0/0.0 end
-      def self.min; -1.0/0.0 end
+
+    class Int32Field < IntegerField
+      def self.max; INT32_MAX; end
+      def self.min; INT32_MIN; end
     end
-    
+
+    class Int64Field < IntegerField
+      def self.max; INT64_MAX; end
+      def self.min; INT64_MIN; end
+    end
+
     class Uint32Field < VarintField
-      def self.max; 1.0/0.0 end
-      def self.min; 0 end
+      def self.max; UINT32_MAX; end
+      def self.min; 0; end
     end
-    
+
     class Uint64Field < VarintField
-      def self.max; 1.0/0.0 end
-      def self.min; 0 end
+      def self.max; UINT64_MAX; end
+      def self.min; 0; end
     end
-    
-    class Sint32Field < VarintField
-      def self.max; 1.0/0.0 end
-      def self.min; -1.0/0.0 end
- 
-      def set_bytes(message_instance, bytes)
-        # TODO use only bit-operations
-        byte = bytes.first
-        value = 
-          if byte % 2 == 0
-            byte / 2
-          else
-            -(byte + 1) / 2
-          end
-        message_instance.send("#{name}=", value)
+
+    # Base class for sint32 and sint64
+    class SignedIntegerField < VarintField
+      def decode(bytes)
+        value = VarintField.decode(bytes)
+        if (value & 1).zero?
+          value >> 1   # positive value
+        else
+          ~value >> 1  # negative value
+        end
       end
 
-      def get_bytes(value)
-        #(value << 1) ^ (value >> 31)
-        [(value << 1) ^ (value >> 31)].pack('C*')
+      def encode(value)
+        if value >= 0
+          VarintField.encode(value << 1)
+        else
+          VarintField.encode(~(value << 1))
+        end
       end
     end
-    
-    class Sint64Field < VarintField
-      def self.max; 1.0/0.0 end
-      def self.min; -1.0/0.0 end
- 
-      def set_bytes(message_instance, bytes)
-        # TODO use only bit-operations
-        byte = bytes.first
-        value = 
-          if byte % 2 == 0
-            byte / 2
-          else
-            -(byte + 1) / 2
-          end
-        message_instance.send("#{name}=", value)
-      end
 
-      def get_bytes(value)
-        #(value << 1) ^ (value >> 63)
-        [(value << 1) ^ (value >> 63)].pack('C*')
-      end
+    class Sint32Field < SignedIntegerField
+      def self.max; INT32_MAX; end
+      def self.min; INT32_MIN; end
     end
-    
-    class DoubleField < VarintField
+
+    class Sint64Field < SignedIntegerField
+      def self.max; INT64_MAX; end
+      def self.min; INT64_MIN; end
+    end
+
+    class FloatField < BaseField
+      def self.default; 0.0; end
+      def self.max;  1.0/0; end
+      def self.min; -1.0/0; end
+
       def wire_type
-        Protobuf::WireType::FIXED64
-      end
- 
-      #TODO
-      def self.max
-        '0x7fefffffffffffff'.unpack('d').first
+        Protobuf::WireType::FIXED32
       end
 
-      #TODO
-      def self.min
-        -(2**(64/2) - 1)
-      end
- 
-      def set_bytes(message_instance, bytes)
-        message_instance.send("#{name}=", bytes.unpack('E').first)
+      def decode(bytes)
+        bytes.unpack('e').first
       end
 
-      def get_bytes(value)
-        [value].pack('E')
+      def encode(value)
+        [value].pack('e')
       end
 
       def acceptable?(val)
@@ -437,129 +446,129 @@ module Protobuf
         true
       end
     end
-    
-    class FloatField < VarintField
+
+    class DoubleField < FloatField
       def wire_type
-        Protobuf::WireType::FIXED32
-      end
- 
-      #TODO
-      def self.max
-        '0x7fefffffffffffff'.unpack('e').first
+        Protobuf::WireType::FIXED64
       end
 
-      #TODO
-      def self.min
-        -(2**(32/2) - 1)
-      end
- 
-      def set_bytes(message_instance, bytes)
-        message_instance.send("#{name}=", bytes.unpack('e').first)
+      def decode(bytes)
+        bytes.unpack('E').first
       end
 
-      def get_bytes(value)
-        [value].pack('e')
-      end
- 
-      def acceptable?(val)
-        raise TypeError unless val.is_a? Numeric
-        raise RangeError if val < min or max < val
-        true
+      def encode(value)
+        [value].pack('E')
       end
-   end
-    
-    class Fixed32Field < VarintField
+    end
+
+    class Fixed32Field < Uint32Field
       def wire_type
         Protobuf::WireType::FIXED32
       end
 
-      def self.max
-        2**32
+      def decode(bytes)
+        bytes.unpack('V').first
       end
 
-      def self.min
-        0
-      end
- 
-      def set_bytes(message_instance, bytes)
-        message_instance.send("#{name}=", bytes.unpack('L').first)
-      end
-
-      def get_bytes(value)
-        [value].pack('L')
+      def encode(value)
+        [value].pack('V')
       end
     end
-    
-    class Fixed64Field < VarintField
+
+    class Fixed64Field < Uint64Field
       def wire_type
         Protobuf::WireType::FIXED64
       end
 
-      def self.max
-        2**64
-      end
-
-      def self.min
-        0
-      end
- 
-      def set_bytes(message_instance, bytes)
-        message_instance.send("#{name}=", bytes.unpack('l').first)
+      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 get_bytes(value)
-        [value].pack('Q')
+      def encode(value)
+        # we don't use 'Q' for pack/unpack. 'Q' is machine-dependent.
+        [value & 0xffff_ffff, value >> 32].pack('VV')
       end
     end
-    
-    class Sfinxed32Field < VarintField
+
+    class Sfixed32Field < Int32Field
       def wire_type
         Protobuf::WireType::FIXED32
       end
 
-      def self.max
-        2**(32/2)
+      def decode(bytes)
+        value  = bytes.unpack('V').first
+        value -= 0x1_0000_0000 if (value & 0x8000_0000).nonzero?
+        value
       end
 
-      def self.min
-        -(2**(32/2) - 1)
+      def encode(value)
+        [value].pack('V')
       end
     end
-    
-    class Sfixed64Field < VarintField
+
+    class Sfixed64Field < Int64Field
       def wire_type
         Protobuf::WireType::FIXED64
       end
 
-      def self.max
-        2**(64/2)
+      def decode(bytes)
+        # we don't use 'Q' for pack/unpack. 'Q' is machine-dependent.
+        values = bytes.unpack('VV')
+        value  = values[0] + (values[1] << 32)
+        value -= 0x1_0000_0000_0000_0000 if (value & 0x8000_0000_0000_0000).nonzero?
+        value
       end
 
-      def self.min
-        -(2**(64/2) - 1)
+      def encode(value)
+        # we don't use 'Q' for pack/unpack. 'Q' is machine-dependent.
+        [value & 0xffff_ffff, value >> 32].pack('VV')
       end
     end
-    
+
     class BoolField < VarintField
-      def typed_default_value(default=nil)
-        default or false
+      class <<self
+        def default; false end
       end
 
       def acceptable?(val)
         raise TypeError unless [TrueClass, FalseClass].include? val.class
         true
       end
- 
-      def set_bytes(message_instance, bytes)
-        message_instance.send("#{name}=", bytes.first == 1)
+
+      def decode(bytes)
+        bytes.first == 1
       end
 
-      def get_bytes(value)
+      def encode(value)
         [value ? 1 : 0].pack('C')
       end
     end
-    
+
     class MessageField < BaseField
+      class <<self
+        def default; nil end
+      end
+
+      def define_setter
+        field = self
+        @message_class.class_eval do
+          define_method("#{field.name}=") do |val|
+            case val
+            when nil
+              @values.delete(field.name)
+            when Hash
+              @values[field.name] = field.type.new(val)
+            when field.type
+              @values[field.name] = val
+            else
+              raise TypeError
+            end
+          end
+        end
+      end
+
       def wire_type
         Protobuf::WireType::LENGTH_DELIMITED
       end
@@ -573,33 +582,20 @@ module Protobuf
       end
 
       def acceptable?(val)
-        raise TypeError unless val.instance_of? type
+        raise TypeError unless val.instance_of?(type) or val.instance_of?(Hash)
         true
       end
- 
-      def set_bytes(message_instance, bytes)
-        message = type.new
-        #message.parse_from bytes
-        message.parse_from_string bytes.pack('U*') # TODO
-        message_instance.send("#{name}=", message)
-      end
- 
-      def set_array(message_instance, bytes)
+
+      def decode(bytes)
         message = type.new
-        #message.parse_from bytes
-        message.parse_from_string bytes.pack('U*')
-        arr = message_instance.send name
-        arr << message
+        message.parse_from_string bytes.pack('C*') # TODO
+        message
       end
 
-      def get_bytes(value)
-        stringio = StringIO.new ''
-        value.serialize_to stringio
-        bytes = stringio.string.unpack 'C*'
-        string_size = VarintField.get_bytes bytes.size
-        #(string_size + bytes).pack('C*')
-        #bytes + string_size
-        string_size + bytes.pack('C*')
+      def encode(value)
+        bytes = value.serialize_to_string
+        string_size = VarintField.encode bytes.size
+        string_size << bytes
       end
 
       def merge_value(message_instance, value)
@@ -608,6 +604,14 @@ module Protobuf
     end
 
     class EnumField < VarintField
+      def default
+        if @default.is_a?(Symbol)
+          type.const_get @default
+        else
+          @default
+        end
+      end
+
       def acceptable?(val)
         raise TypeError unless type.valid_tag? val
         true