ruby-protocol-buffers 1.5.1 → 1.6.0

data/lib/protocol_buffers/runtime/message.rb

@@ -2,6 +2,8 @@ require 'stringio'
 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 @@ module ProtocolBuffers
     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 @@ module ProtocolBuffers
       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.
     #
@@ -426,6 +454,41 @@ module ProtocolBuffers
       @set_fields[tag] || false
     end
 
+    # Gets the field, returning nil if not set
+    # If a block is given, this block is called and it's
+    # return value returned if the value is not set
+    def get(*nested_field_names, &b)
+      if nested_field_names.size == 1
+        field_name = nested_field_names.first
+        field = self.class.field_for_name(field_name)
+        raise ArgumentError.new unless field
+        unless self.value_for_tag?(field.tag)
+          return b ? b.call : nil
+        end
+        return self.value_for_tag(field.tag)
+      end
+      last_proto = nested_field_names[0..-2].inject(self) do |sub_proto, ifield_name|
+        sub_field = sub_proto.class.field_for_name(ifield_name)
+        raise ArgumentError.new unless sub_field
+        raise ArgumentError.new unless sub_field.is_a?(ProtocolBuffers::Field::MessageField)
+        unless sub_proto.value_for_tag?(sub_field.tag)
+          return b ? b.call : nil
+        end
+        sub_proto.value_for_tag(sub_field.tag)
+      end
+      last_field_name = nested_field_names.last
+      last_field = last_proto.class.field_for_name(last_field_name)
+      unless last_proto.value_for_tag?(last_field.tag)
+        return b ? b.call : nil
+      end
+      last_proto.value_for_tag(last_field.tag)
+    end
+
+    # Gets the field, throwing ArgumentError if not set
+    def get!(*nested_field_names)
+      get(*nested_field_names) { raise ArgumentError.new("#{nested_field_names} is not set") }
+    end
+
     def inspect
       ret = ProtocolBuffers.bin_sio
       ret << "#<#{self.class.name}"

data/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

data/lib/protocol_buffers/runtime/text_parser.ry

@@ -0,0 +1,136 @@
+# vim: set ft=racc fenc=us-ascii : -*- mode: racc coding: US-ASCII -*-
+class ProtocolBuffers::TextParser
+token identifier string integer bool float
+rule
+  message    : /* none */
+               {
+                 result = current_message
+               }
+             | message field
+
+  field      : field_name ':' primitive_value
+               {
+                 set_field(val[0], val[2])
+               }
+             | field_name ':' identifier
+               {
+                 field, enum_symbol = val[0], val[2]
+                 unless field.kind_of?(ProtocolBuffers::Field::EnumField)
+                   raise Racc::ParseError, "not a enum field: %s" % field.name
+                 end
+                 value = field.value_from_name(enum_symbol)
+                 unless value
+                   raise Racc::ParseError, "enum type %s has no value named %s" % [field.name, enum_symbol]
+                 end
+                 set_field(field, value)
+               }
+             | message_field_head '<'
+               {
+                 field = _values[-2]
+                 push_message(field.proxy_class.new)
+               }
+               message '>'
+               {
+                 pop_message
+                 set_field(val[0], val[3])
+               }
+             | message_field_head '{'
+               {
+                 field = _values[-2]
+                 push_message(field.proxy_class.new)
+               }
+               message '}'
+               {
+                 pop_message
+                 set_field(val[0], val[3])
+               }
+
+  message_field_head : field_name
+                     | field_name ':'
+
+  field_name : identifier
+               {
+                 field = current_message.class.field_for_name(val[0])
+                 if field
+                   return field
+                 end
+
+                 # fallback for case mismatch in group fields.
+                 field = current_message.fields.find { |tag,field| field.name.to_s.downcase == val[0].downcase }
+                 field &&= field.last
+                 if field && field.kind_of?(ProtocolBuffers::Field::GroupField)
+                   return field
+                 end
+
+                 raise Racc::ParseError, "no such field %s in %s" % [val[0], current_message.class]
+               }
+             | '[' qualified_name ']'
+               {
+                 raise NotImplementedError, "extension is not yet supported"
+               }
+
+  qualified_name   : identifier
+                     {
+                       result = [val[0]]
+                     }
+                   | qualified_name '.' identifier
+                     {
+                       result = (val[0] << val[2])
+                     }
+
+  primitive_value : concat_string
+                  | integer
+                  | float
+                  | bool
+  concat_string   : string
+                  | concat_string string
+                    {
+                      result = val[0] + val[1]
+                    }
+end
+
+---- header
+require 'protocol_buffers/runtime/text_scanner'
+
+---- inner
+def initialize
+  @msgstack = []
+end
+
+attr_accessor :yydebug
+
+def parse_text(text, message)
+  scanner = ProtocolBuffers::TextScanner.new(text)
+  parse_from_scanner(scanner.enum_for(:scan), message)
+end
+
+def parse_from_scanner(scanner, message)
+  @msgstack.clear
+  push_message(message)
+  yyparse(scanner, :each)
+  pop_message
+end
+
+private :yyparse, :do_parse
+private
+def current_message
+  @msgstack.last
+end
+
+def push_message(message)
+  @msgstack.push(message)
+end
+
+def pop_message
+  @msgstack.pop
+end
+
+def set_field(field, value)
+  msg = current_message
+  if field.repeated?
+    msg.value_for_tag(field.tag) << value
+  else
+    msg.set_value_for_tag(field.tag, value)
+  end
+  msg
+end

data/lib/protocol_buffers/runtime/text_scanner.rb

@@ -0,0 +1,94 @@
+# -*- coding: UTF-8 -*-
+
+require 'strscan'
+require 'racc/parser'
+
+module ProtocolBuffers; end
+
+class ProtocolBuffers::TextScanner
+  def initialize(text)
+    @text = text.encode(Encoding::UTF_8)
+    @scanner = StringScanner.new(@text)
+    @lineno = 1
+  end
+
+  attr_reader :lineno
+
+  def scan
+    while @scanner.rest?
+      case
+      when @scanner.skip(/[ \t\v]+/)
+        next
+      when @scanner.skip(/#.*?$/)
+        next
+      when @scanner.skip(/\r?\n|\r/)
+        @lineno += 1
+        next
+      when @scanner.scan(/[.:<>{}\[\]]/)
+        c = @scanner[0]
+        yield [c, c]
+      when @scanner.scan(/true/)
+        yield [:bool, true]
+      when @scanner.scan(/false/)
+        yield [:bool, false]
+      when @scanner.scan(/["']/)
+        quote = @scanner[0]
+        line = lineno
+        if @scanner.scan(/(.*?)(?<!\\)#{quote}/)
+          str = @scanner[1]
+          yield [:string, unescape(str)]
+        else
+          raise Racc::ParseError, "unterminated string from line #{line}"
+        end
+      when @scanner.scan(/([+-])?[0-9]+\.[0-9]+([Ee][+-]?[0-9]+)?/)
+        yield [:float, Float(@scanner[0])]
+      when @scanner.scan(/([+-])?0[Bb]([01]+)/)
+        yield [:integer, Integer(@scanner[0], 2)]
+      when @scanner.scan(/([+-])?0[Xx]([[:xdigit:]]+)/)
+        yield [:integer, Integer(@scanner[0], 16)]
+      when @scanner.scan(/([+-])?0[Oo]?([0-7]+)/)
+        yield [:integer, Integer(@scanner[0], 8)]
+      when @scanner.scan(/([+-])?(?:0[Dd])?([0-9]+)/)
+        yield [:integer, Integer(@scanner[0], 10)]
+      when @scanner.scan(/[[:alpha:]_][[:alnum:]_]*/)
+        yield [:identifier, @scanner[0]]
+      else
+        line = lineno
+        raise Racc::ParseError, "unexpected character at: line #{line}: #{@scanner.rest.inspect}"
+      end
+    end
+    yield [false, nil]
+  end
+
+  private
+  ESCAPE_SEQUENCE = {
+    'a' => "\a",
+    'b' => "\b",
+    'f' => "\f",
+    'n' => "\n",
+    'r' => "\r",
+    't' => "\t",
+    'v' => "\v",
+    '\\' => "\\",
+    '"' => '"',
+    "'" => "'",
+  }.freeze
+
+  def unescape(str)
+    str.gsub(%r!
+      \\ (?:
+        [Xx]([[:xdigit:]]{1,2}) |
+        ([0-7]{1,3})            |
+        ([abfnrtv\\'"])
+    )!x) do
+      case
+      when $1
+        Integer($1, 16).chr
+      when $2
+        Integer($2, 8).chr
+      when $3
+        ESCAPE_SEQUENCE[$3]
+      end
+    end
+  end
+end

data/lib/protocol_buffers/version.rb

@@ -1,3 +1,3 @@
 module ProtocolBuffers
-  VERSION = "1.5.1"
+  VERSION = "1.6.0"
 end

data/ruby-protocol-buffers.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "rake"
   gem.add_development_dependency "rake-compiler"
   gem.add_development_dependency "simplecov"
-  gem.add_development_dependency "rspec", "~> 2.5"
+  gem.add_development_dependency "rspec", "~> 2.14"
   gem.add_development_dependency "yard"
+  gem.add_development_dependency "racc", "~> 1.4.12"
 end