Supports text formatting and parsing as the C++/Python/Java/Go

implementations do.

Author: yugui

.gitignore

@@ -12,3 +12,4 @@ prof
 rdoc
 tests
 tmp
+/lib/protocol_buffers/runtime/text_parser.rb

README.md

@@ -142,6 +142,7 @@ end
 * passing on unknown fields when re-serializing a message
 * groups
 * RPC stubbing
+* formatting to and parsing from text format
 
 ### Unsupported Features
 

Rakefile

@@ -3,3 +3,11 @@ require "bundler/gem_tasks"
 Dir['tasks/**/*.rake'].each { |t| load t }
 
 task :default => [:spec]
+
+file 'lib/protocol_buffers/runtime/text_parser.rb' => 'lib/protocol_buffers/runtime/text_parser.ry' do |t|
+  sh 'racc', '-o', t.name, *t.prerequisites
+end
+
+task :text_parser => 'lib/protocol_buffers/runtime/text_parser.rb'
+task :spec => :text_parser
+task :build => :text_parser

lib/protocol_buffers.rb

@@ -8,6 +8,14 @@ def self.bin_sio(*args)
       sio.external_encoding != Encoding::BINARY
     sio
   end
+
+  def self.utf8_sio(*args)
+    sio = StringIO.new(*args)
+    sio.set_encoding('utf-8') if
+      sio.respond_to?(:set_encoding) and
+      sio.external_encoding != Encoding::UTF_8
+    sio
+  end
 end
 
 require 'protocol_buffers/version'

lib/protocol_buffers/runtime/field.rb

@@ -242,6 +242,10 @@ def deserialize(value)
       value
     end
 
+    def text_format(io, value, options = nil)
+      io.write value.to_s
+    end
+
     module WireFormats
       module LENGTH_DELIMITED
         def wire_type
@@ -304,6 +308,11 @@ def default_value
       def deserialize(value)
         value.read
       end
+
+      def text_format(io, value, options = nil)
+        value = value.unpack("C*").map { |b| "\\x%02x" % b }.join(nil)
+        io.write "\"#{value}\""
+      end
     end
 
     class StringField < BytesField
@@ -332,6 +341,14 @@ def deserialize(value)
           read_value
         end
       end
+
+      def text_format(io, value, options = nil)
+        if HAS_ENCODING
+          io.write value.dup.force_encoding(Encoding::ASCII_8BIT).dump
+        else
+          io.write value.dump
+        end
+      end
     end
 
     class NumericField < Field
@@ -583,9 +600,18 @@ def default_value
         @opts[:default] || @valid_values.first
       end
 
+      def value_from_name(name)
+        @proxy_enum.name_to_value_map[name.to_sym]
+      end
+
       def inspect_value(value)
         "#{@value_to_name[value]}(#{value})"
       end
+
+      def text_format(io, value, options = nil)
+        formatted = @value_to_name[value] || value.to_s
+        io.write formatted 
+      end
     end
 
     class AggregateField < Field
@@ -614,6 +640,24 @@ def serialize(value)
       def deserialize(io)
         @proxy_class.parse(io)
       end
+
+      def text_format(io, value, options = nil)
+        options = options.dup
+        options[:nest] ||= 0
+        if options[:short]
+          indent = ""
+          newline = " "
+        else
+          indent = "  " * options[:nest]
+          newline = "\n"
+        end
+        options[:nest] += 1
+
+        io.write "{#{newline}"
+        value.text_format(io, options)
+        io.write " " if options[:short]
+        io.write "#{indent}}"
+      end
     end
 
     class MessageField < AggregateField

lib/protocol_buffers/runtime/message.rb

@@ -2,6 +2,8 @@
 require 'protocol_buffers/runtime/field'
 require 'protocol_buffers/runtime/encoder'
 require 'protocol_buffers/runtime/decoder'
+require 'protocol_buffers/runtime/text_formatter'
+require 'protocol_buffers/runtime/text_parser'
 
 module ProtocolBuffers
 
@@ -257,6 +259,19 @@ def serialize_to_string
     end
     alias_method :to_s, :serialize_to_string
 
+    # Format this message into the given IO stream using the text format of Protocol Buffers.
+    def text_format(io, options = nil)
+      formatter = TextFormatter.new(options)
+      formatter.format(io, self)
+    end
+
+    # Format this message into a text and return it.
+    def text_format_to_string(options = nil)
+      sio = ProtocolBuffers.utf8_sio
+      text_format(sio, options)
+      return sio.string
+    end
+
     def to_hash
       self.class.to_hash(self)
     end
@@ -296,6 +311,19 @@ def self.parse(io)
       self.new.parse(io)
     end
 
+    # Parse the text as a text representation of this class, and merge the parsed fields
+    # into the current message.
+    def parse_from_text(text)
+      parser = TextParser.new
+      parser.parse_text(text, self)
+      return self
+    end
+
+    # Shortcut, simply calls self.new.parse_from_text(text)
+    def self.parse_from_text(text)
+      self.new.parse_from_text(text)
+    end
+
     # Merge the attribute values from +obj+ into this Message, which must be of
     # the same class.
     #

lib/protocol_buffers/runtime/text_formatter.rb

@@ -0,0 +1,116 @@
+module ProtocolBuffers
+  class TextFormatter
+    def initialize(options = nil)
+      @options = options || {}
+    end
+
+    def format(io, message, options = nil)
+      message.validate!
+      options ||= {}
+      options = options.merge(@options)
+      options[:nest] ||= 0
+
+      if options[:short]
+        indent = ""
+        newline = " "
+      else
+        indent = "  " * options[:nest]
+        newline = "\n"
+      end
+
+      sep = ""
+      message.fields.each do |tag, field|
+        next unless message.value_for_tag?(tag)
+        value = message.value_for_tag(tag)
+        if field.repeated?
+          next if value.size == 0
+          value.each do |v|
+            io.write sep; sep = newline
+
+            format_field(io, field, v, indent, newline, options)
+          end
+        else
+          io.write sep; sep = newline
+
+          format_field(io, field, value, indent, newline, options)
+        end
+      end
+
+      message.each_unknown_field do |tag_int, value|
+        io.write sep; sep = newline
+
+        wire_type = tag_int & 0x7
+        id = tag_int >> 3
+        format_unknown_field(io, wire_type, id, value, options)
+      end
+
+      io.write sep if !options[:short]
+
+      io
+    end
+
+    def format_field(io, field, value, indent, newline, options)
+      if field.kind_of? Field::GroupField
+        name = value.class.name.sub(/\A.*::/, '')
+      else
+        name = field.name
+      end
+
+      io.write "#{indent}#{name}"
+      if field.kind_of? Field::AggregateField
+        io.write " "
+      else
+        io.write ": "
+      end
+      field.text_format(io, value, options)
+    end
+
+    def format_unknown_field(io, wire_type, id, value, options)
+      options = options.dup
+      options[:nest] ||= 0
+
+      if options[:short]
+        indent = ""
+        newline = " "
+      else
+        indent = "  " * options[:nest]
+        newline = "\n"
+      end
+
+      if wire_type == 3
+        options[:nest] += 1
+
+        io.write "#{indent}#{id} {#{newline}"
+      else
+        io.write "#{indent}#{id}: "
+      end
+
+      case wire_type
+      when 0 # VARINT
+        io.write "#{value}"
+
+      when 1 # FIXED64
+        lo, hi = value.unpack("V2")
+        io.write "0x%016x" % (hi << 32 | lo)
+
+      when 5 # FIXED32
+        io.write "0x%08x" % value.unpack("V")
+
+      when 2 # LENGTH_DELIMITED
+        value = value.unpack("C*").map { |b| "\\x%02x" % b }.join(nil)
+        io.write "\"#{value}\""
+
+      when 3 # START_GROUP
+        format(io, value, options)
+
+      when 4 # END_GROUP: never appear
+        raise(EncodeError, "Unexpected wire type END_GROUP")
+      else
+        raise(EncodeError, "unknown wire type: #{wire_type}")
+      end
+      if wire_type == 3
+        io.write "#{indent}}"
+      end
+    end
+  end
+end