chrisk-protopuffs 0.2.0 → 0.2.1

data/README.rdoc

@@ -1,3 +1,74 @@
 = Protopuffs!
 
-A new implementation of Protocol Buffers in Ruby.
+A new implementation of Protocol Buffers in Ruby. 
+
+If you're not familiar with Protocol Buffers, start with Google's homepage:
+http://code.google.com/apis/protocolbuffers
+
+  Protocol buffers are Google's language-neutral, platform-neutral, extensible
+  mechanism for serializing structured data -- think XML, but smaller, faster,
+  and simpler.
+
+== Installation
+
+Rubyforge is cuckoo for protopuffs.
+
+  sudo gem install protopuffs
+
+== Usage
+
+Start with a +proto+ file, say, <tt>proto/animals.proto</tt>:
+
+  message Bird {
+    required string name = 1;
+    optional string species = 2;
+  }
+
+First, require Protopuffs and tell it where your +proto+ files are:
+
+  require 'protopuffs'
+  Protopuffs.proto_load_path << "proto"
+  Protopuffs.load_message_classes
+
+That makes the Bird message dynamically available in Ruby. Everything's
+namespaced under <tt>Protopuffs::Message</tt>, which should help with your OCD.
+
+  bird = Protopuffs::Message::Bird.new
+  bird.name = "Sonny"
+  bird.species = "Cuculus canorus"
+
+  # encode this message to the super-efficient binary wire format
+  binary_bird = bird.to_wire_format
+
+  # or encode to the human-friendly text format, for debugging
+  puts bird.inspect
+
+You can also decode incoming binary wire-format messages:
+
+  decoded_bird = Protopuffs::Message::Bird.new
+  decoded_bird.from_wire_format(binary_bird)
+  decoded_bird.name  # => "Sonny"
+
+=== Mass-assignment
+
+TODO: explain <tt>Message::Base.new</tt> with strings containing the wire format
+or hashes, as well as <tt>#attributes=</tt>
+
+== Missing functionality
+
+Protopuffs currently only supports a base set of the <tt>.proto</tt> file
+syntax. Here's what's missing:
+
+* sfixed32 and sfixed64 types
+* sint32 and sint64 types (due to lack of support for ZigZag encoding)
+* packed repeated fields (the <tt>[packed=true]</tt> option)
+* enumerations
+* importing definitions
+* nested message types
+* extensions
+* nested extensions
+* packages
+* services
+* built-in options
+* custom options
+* groups (deprecated)

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 2
-:patch: 0
+:patch: 1

data/lib/protopuffs/message/base.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 module Protopuffs
   module Message
 
@@ -7,7 +9,7 @@ module Protopuffs
         attr_reader :fields
 
         def define_message_class(name, fields)
-          name = name.capitalize
+          name = name.delete("_")
           self.check_fields_for_errors(name, fields)
           Message.send(:remove_const, name) if Message.const_defined?(name)
           klass = Message.const_set(name, Class.new(self))
@@ -36,27 +38,52 @@ module Protopuffs
 
       attr_reader :buffer
 
-      def initialize
+      def initialize(field_values = nil)
         if self.class == Base
           raise "#{self.class} should not be instantiated directly. Use the factory #{self.class}.define_message_class instead."
         end
-        @buffer = StringIO.new
+
+        if field_values.nil?
+          @buffer = StringIO.new
+          @buffer.set_encoding("BINARY") if @buffer.respond_to?(:set_encoding)
+        elsif field_values.respond_to?(:each_pair)
+          @buffer = StringIO.new
+          @buffer.set_encoding("BINARY") if @buffer.respond_to?(:set_encoding)
+          self.attributes = field_values
+        else
+          from_wire_format(field_values)
+        end
       end
 
       def to_wire_format
-        self.class.fields.each do |field|
+        self.class.fields.sort_by { |f| f.tag }.each do |field|
           value = send(field.identifier)
           @buffer.write field.to_wire_format_with_value(value) unless value.nil?
         end
         @buffer.string
       end
 
+      # Returns the protocol buffer text format, which is useful for debugging
+      def inspect
+        type = self.class.name.split("::").last.downcase
+        field_strings = self.class.fields.map { |f| "  #{f.identifier}: #{send(f.identifier).inspect}\n" }
+        "#{type} {\n#{field_strings.join}}"
+      end
+
       def from_wire_format(buffer)
-        @buffer = buffer
+        if !buffer.respond_to?(:read)
+          buffer.force_encoding("BINARY") if buffer.respond_to?(:force_encoding)
+          @buffer = StringIO.new(buffer)
+        else
+          @buffer = buffer
+        end
+        @buffer.set_encoding("BINARY") if @buffer.respond_to?(:set_encoding)
+
         until @buffer.eof?
-          tag, value_bytes = MessageField.shift_tag_and_value_bytes(@buffer)
+          tag = MessageField.shift_tag(@buffer)
           field = self.class.fields.find { |field| field.tag == tag }
           next if field.nil?
+          value_bytes = field.class.shift(@buffer)
 
           value = field.decode(value_bytes)
           if field.repeated? && send(field.identifier).nil?
@@ -68,6 +95,7 @@ module Protopuffs
           end
         end
         set_values_for_missing_optional_fields
+        self
       end
 
       def set_values_for_missing_optional_fields
@@ -76,6 +104,12 @@ module Protopuffs
         end
       end
 
+      def attributes=(attrs = {})
+        attrs.each_pair do |name, value|
+          self.send("#{name}=", value) if respond_to?("#{name}=")
+        end
+      end
+
       def ==(other)
         return false if self.class != other.class
         self.class.fields.each do |field|

data/lib/protopuffs/message/field.rb

@@ -1,40 +1,40 @@
+# encoding: UTF-8
+
 module Protopuffs
 
   class MessageField
-    attr_reader :modifier, :type, :identifier, :tag, :default
+    attr_reader :identifier, :tag, :default
+
+    def self.factory(type, *args)
+      case type
+      when "int32"    then Int32.new(*args)
+      when "int64"    then Int64.new(*args)
+      when "uint32"   then UInt32.new(*args)
+      when "uint64"   then UInt64.new(*args)
+      when "bool"     then Bool.new(*args)
+      when "double"   then Double.new(*args)
+      when "fixed64"  then Fixed64.new(*args)
+      when "string"   then String.new(*args)
+      when "bytes"    then Bytes.new(*args)
+      when "float"    then Float.new(*args)
+      when "fixed32"  then Fixed32.new(*args)
+      else Embedded.new(type, *args)
+      end
+    end
 
-    def initialize(modifier, type, identifier, tag, default = nil)
+    def initialize(modifier, identifier, tag, default)
+      raise "MessageField is an abstract base class" if self.class == MessageField
+      raise ArgumentError.new("Invalid modifier '#{modifier}'") unless
+        ["optional", "required", "repeated"].include?(modifier)
       @modifier = modifier
-      @type = type
       @identifier = identifier
       @tag = tag
       @default = default
-
-      set_default_for_type if optional? && @default.nil?
-    end
-
-    def set_default_for_type
-      if numeric?
-        @default = 0
-      elsif @type == "string"
-        @default = ""
-      elsif @type == "bool"
-        @default = false
-      end
-    end
-
-    def wire_type
-      case @type
-      when "int32", "int64", "uint32", "uint64", "bool" then WireType::VARINT
-      when "double", "fixed64"                          then WireType::FIXED64
-      when "string", "bytes"                            then WireType::LENGTH_DELIMITED
-      when "float", "fixed32"                           then WireType::FIXED32
-      else WireType::LENGTH_DELIMITED # embedded messages
-      end
     end
+    private :initialize
 
     def key
-      (@tag << 3) | wire_type
+      (@tag << 3) | self.class.wire_type
     end
 
     def repeated?
@@ -45,18 +45,8 @@ module Protopuffs
       @modifier == "optional"
     end
 
-    def numeric?
-      %w(double float int32 int64 uint32 unit64 sint32 sint64 fixed32 fixed64
-         sfixed32 sfixed64).include?(@type)
-    end
-
-    def embedded_message?
-      wire_type == WireType::LENGTH_DELIMITED && @type != "string" && @type != "bytes"
-    end
-
     def to_wire_format_with_value(value)
-      field_encoder = lambda { |val| self.class.varint_encode(key) + encode(val) }
-
+      field_encoder = lambda { |val| VarInt.encode(key) + self.class.encode(val) }
       if repeated?
         value.map(&field_encoder).join
       else
@@ -64,32 +54,60 @@ module Protopuffs
       end
     end
 
-    def encode(value)
-      case wire_type
-      when WireType::VARINT
-        value = (value ? 1 : 0) if @type == "bool"
-        value_bytes = self.class.varint_encode(value)
-      when WireType::LENGTH_DELIMITED
-        if value.respond_to?(:to_wire_format)
-          embedded_bytes = value.to_wire_format
-          value_bytes = self.class.varint_encode(embedded_bytes.size) + embedded_bytes
-        else
-          value_bytes = self.class.varint_encode(value.size)
-          value_bytes += self.class.string_encode(value) if @type == "string"
-          value_bytes += value if @type == "bytes"
-        end
-      when WireType::FIXED32
-        value_bytes = self.class.float_encode(value) if @type == "float"
-        value_bytes = self.class.fixed32_encode(value) if @type == "fixed32"
-      when WireType::FIXED64
-        value_bytes = self.class.double_encode(value) if @type == "double"
-        value_bytes = self.class.fixed64_encode(value) if @type == "fixed64"
+    def self.shift_tag(buffer)
+      bits = 0
+      bytes = VarInt.shift(buffer)
+      bytes.each_with_index do |byte, index|
+        byte &= 0b01111111
+        bits |= byte << (7 * index)
       end
-      value_bytes
+      bits >> 3
     end
+  end
 
+  class Bool < MessageField
+    def initialize(modifier, identifier, tag, default = nil)
+      super(modifier, identifier, tag, default || false)
+    end
+    def self.wire_type;     WireType::VARINT end
+    def self.shift(buffer); VarInt.shift(buffer) end
+    def decode(value_bytes)
+      value = VarInt.decode(value_bytes)
+      value = true  if value == 1
+      value = false if value == 0
+      value
+    end
+    def self.encode(value); VarInt.encode(value ? 1 : 0) end
+  end
 
-    def self.varint_encode(value)
+  class Numeric < MessageField
+    def initialize(modifier, identifier, tag, default = nil)
+      super(modifier, identifier, tag, default || 0)
+    end
+  end
+
+  class VarInt < Numeric
+    def self.wire_type; WireType::VARINT end
+    def self.shift(buffer)
+      bytes = []
+      begin
+        # Use #readbyte in Ruby 1.9, and #readchar in Ruby 1.8
+        byte = buffer.send(buffer.respond_to?(:readbyte) ? :readbyte : :readchar)
+        bytes << (byte & 0b01111111)
+      end while byte >> 7 == 1
+      bytes
+    end
+    def self.decode(bytes)
+      value = 0
+      bytes.each_with_index do |byte, index|
+        value |= byte << (7 * index)
+      end
+      value
+    end
+    def decode(bytes)
+      VarInt.decode(bytes)
+    end
+    def self.encode(value)
       return [0].pack('C') if value.zero?
       bytes = []
       until value.zero?
@@ -104,123 +122,96 @@ module Protopuffs
       bytes[-1] &= 0b01111111
       bytes.pack('C*')
     end
+  end
 
-    def self.string_encode(value)
-      value.unpack('U*').pack('C*')
-    end
-
-    def self.float_encode(value)
-      [value].pack('e')
-    end
+  class Int32 < VarInt; end
+  class Int64 < VarInt; end
+  class UInt32 < VarInt; end
+  class UInt64 < VarInt; end
 
-    def self.double_encode(value)
-      [value].pack('E')
-    end
+  class Fixed32Base < Numeric
+    def self.wire_type;     WireType::FIXED32 end
+    def self.shift(buffer); buffer.read(4) end
+  end
 
-    def self.fixed64_encode(value)
-      [value].pack('Q')
-    end
+  class Fixed32 < Fixed32Base
+    def decode(bytes);      bytes.unpack('V').first end
+    def self.encode(value); [value].pack('V') end
+  end
 
-    def self.fixed32_encode(value)
-      [value].pack('V')
-    end
+  class Float < Fixed32Base
+    def decode(bytes);      bytes.unpack('e').first end
+    def self.encode(value); [value].pack('e') end
+  end
 
-    # note: returns two values
-    def self.shift_tag_and_value_bytes(buffer)
-      bits = 0
-      bytes = shift_varint(buffer)
-      bytes.each_with_index do |byte, index|
-        byte &= 0b01111111
-        bits |= byte << (7 * index)
-      end
-      wire_type = bits & 0b00000111
-      tag = bits >> 3
-
-      case wire_type
-      when WireType::VARINT
-        value_bytes = shift_varint(buffer)
-      when WireType::LENGTH_DELIMITED
-        value_bytes = shift_length_delimited(buffer)
-      when WireType::FIXED32
-        value_bytes = shift_fixed32(buffer)
-      when WireType::FIXED64
-        value_bytes = shift_fixed64(buffer)
-      end
+  class Fixed64Base < Numeric
+    def self.wire_type;     WireType::FIXED64 end
+    def self.shift(buffer); buffer.read(8) end
+  end
 
-      [tag, value_bytes]
-    end
+  class Fixed64 < Fixed64Base
+    def decode(bytes);      bytes.unpack('Q').first end
+    def self.encode(value); [value].pack('Q') end
+  end
 
-    def self.shift_varint(buffer)
-      bytes = []
-      begin
-        byte = buffer.readchar
-        bytes << (byte & 0b01111111)
-      end while byte >> 7 == 1
-      bytes
-    end
+  class Double < Fixed64Base
+    def decode(bytes);      bytes.unpack('E').first end
+    def self.encode(value); [value].pack('E') end
+  end
 
-    def self.shift_length_delimited(buffer)
-      bytes = shift_varint(buffer)
-      value_length = self.varint_decode(bytes)
+  class LengthDelimited < MessageField
+    def self.wire_type; WireType::LENGTH_DELIMITED end
+    def self.shift(buffer)
+      bytes = VarInt.shift(buffer)
+      value_length = VarInt.decode(bytes)
       buffer.read(value_length)
     end
+    def decode(bytes); bytes end
+  end
 
-    def self.shift_fixed32(buffer)
-      buffer.read(4)
+  class String < LengthDelimited
+    def initialize(modifier, identifier, tag, default = nil)
+      super(modifier, identifier, tag, default || "")
     end
-
-    def self.shift_fixed64(buffer)
-      buffer.read(8)
+    def self.encode(value)
+      value = value.to_s
+      value.force_encoding("UTF-8") if value.respond_to?(:force_encoding)
+      # Use #bytesize in Ruby 1.9, and #size in Ruby 1.8
+      size = value.respond_to?(:bytesize) ? value.bytesize : value.size
+      VarInt.encode(size) + value
     end
-
-    def decode(value_bytes)
-      case wire_type
-      when WireType::VARINT
-        value = self.class.varint_decode(value_bytes)
-        if @type == "bool"
-          value = true  if value == 1
-          value = false if value == 0
-        end
-      when WireType::LENGTH_DELIMITED
-        if embedded_message?
-          value = Message.const_get(@type).new
-          value.from_wire_format(StringIO.new(value_bytes))
-        else
-          value = value_bytes
-        end
-      when WireType::FIXED32
-        value = self.class.float_decode(value_bytes) if @type == "float"
-        value = self.class.fixed32_decode(value_bytes) if @type == "fixed32"
-      when WireType::FIXED64
-        value = self.class.double_decode(value_bytes) if @type == "double"
-        value = self.class.fixed64_decode(value_bytes) if @type == "fixed64"
-      end
-      value
+    def decode(bytes)
+      bytes.respond_to?(:force_encoding) ? bytes.force_encoding("UTF-8") : bytes
     end
+  end
 
-    def self.varint_decode(bytes)
-      value = 0
-      bytes.each_with_index do |byte, index|
-        value |= byte << (7 * index)
-      end
-      value
+  class Bytes < LengthDelimited
+    def initialize(modifier, identifier, tag, default = nil)
+      super
     end
-
-    def self.float_decode(bytes)
-      bytes.unpack('e').first
+    def self.encode(value)
+      VarInt.encode(value.size) + value
     end
-
-    def self.double_decode(bytes)
-      bytes.unpack('E').first
+    def decode(bytes)
+      bytes.respond_to?(:force_encoding) ? bytes.force_encoding("BINARY") : bytes
     end
+  end
 
-    def self.fixed64_decode(bytes)
-      bytes.unpack('Q').first
+  class Embedded < LengthDelimited
+    def initialize(type, modifier, identifier, tag, default = nil)
+      @type = type
+      super(modifier, identifier, tag, default)
     end
-
-    def self.fixed32_decode(bytes)
-      bytes.unpack('V').first
+    def decode(bytes)
+      bytes.force_encoding("BINARY") if bytes.respond_to?(:force_encoding)
+      value = Message.const_get(@type.delete("_")).new
+      value.from_wire_format(StringIO.new(bytes))
+    end
+    def self.encode(value)
+      embedded_bytes = value.to_wire_format
+      VarInt.encode(embedded_bytes.size) + embedded_bytes
     end
   end
 
 end
+

data/lib/protopuffs/message/wire_type.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 module Protopuffs
   class WireType
     VARINT = 0
@@ -7,4 +9,4 @@ module Protopuffs
     END_GROUP = 4
     FIXED32 = 5
   end
-end
+end

data/lib/protopuffs/parser/parser.rb

@@ -7,7 +7,7 @@ module Protopuffs
 
     class ProtocolBufferDescriptor
       def initialize
-        Treetop.load "lib/protopuffs/parser/protocol_buffer"
+        Treetop.load File.join(File.dirname(__FILE__), "protocol_buffer")
         @parser = Protopuffs::ProtocolBufferParser.new
       end
 
@@ -21,4 +21,4 @@ module Protopuffs
     end
 
   end
-end
+end

data/lib/protopuffs/parser/protocol_buffer.treetop

@@ -60,8 +60,8 @@ module Protopuffs
         end
 
         def build
-          MessageField.new(modifier.text_value, type.text_value, identifier.text_value,
-                           integer.text_value.to_i, default)
+          MessageField.factory(type.text_value, modifier.text_value, identifier.text_value,
+                               integer.text_value.to_i, default)
         end
       }
     end

data/lib/protopuffs.rb

@@ -1,3 +1,7 @@
+# encoding: UTF-8
+
+require "rubygems"
+require "treetop"
 require "protopuffs/message/base"
 require "protopuffs/message/field"
 require "protopuffs/message/wire_type"

data/test/abstract_syntax_tree_test.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require File.dirname(__FILE__) + '/test_helper'
 
 class AbstractSyntaxTreeTest < Test::Unit::TestCase
@@ -12,13 +14,13 @@ class AbstractSyntaxTreeTest < Test::Unit::TestCase
         @descriptor = "message Person {}"
       end
 
-      should "create one MessageDescriptor" do
+      should "create one message class" do
         Protopuffs::Message::Base.expects(:define_message_class).once.with("Person", [])
         @parser.parse(@descriptor)
       end
 
       should "not create any MessageFields" do
-        Protopuffs::MessageField.expects(:new).never
+        Protopuffs::MessageField.expects(:factory).never
         @parser.parse(@descriptor)
       end
     end
@@ -32,14 +34,14 @@ class AbstractSyntaxTreeTest < Test::Unit::TestCase
         proto
       end
 
-      should "create two MessageDescriptors" do
+      should "create two message classes" do
         Protopuffs::Message::Base.expects(:define_message_class).once.with("Apple", []).in_sequence
         Protopuffs::Message::Base.expects(:define_message_class).once.with("Orange", []).in_sequence
         @parser.parse(@descriptor)
       end
 
       should "not create any MessageFields" do
-        Protopuffs::MessageField.expects(:new).never
+        Protopuffs::MessageField.expects(:factory).never
         @parser.parse(@descriptor)
       end
     end
@@ -54,13 +56,14 @@ class AbstractSyntaxTreeTest < Test::Unit::TestCase
         proto
       end
 
-      should "create one 'Person' MessageDescriptor with one field" do
+      should "create one 'Person' message class with one field" do
         Protopuffs::Message::Base.expects(:define_message_class).once.with("Person", responds_with(:size, 1))
         @parser.parse(@descriptor)
       end
 
       should "create one MessageField with correct options" do
-        Protopuffs::MessageField.expects(:new).once.with("required", "string", "name", 1, nil).returns(stub(:tag => 1, :identifier => "name"))
+        Protopuffs::MessageField.expects(:factory).once.with("string", "required", "name", 1, nil).
+          returns(stub(:tag => 1, :identifier => "name"))
         @parser.parse(@descriptor)
       end
     end
@@ -77,15 +80,18 @@ class AbstractSyntaxTreeTest < Test::Unit::TestCase
         proto
       end
 
-      should "create one 'Person' MessageDescriptor with three fields" do
+      should "create one 'Person' message class with three fields" do
         Protopuffs::Message::Base.expects(:define_message_class).once.with("Person", responds_with(:size, 3))
         @parser.parse(@descriptor)
       end
 
       should "create three MessageFields with correct options" do
-        Protopuffs::MessageField.expects(:new).once.with("required", "string", "name", 1, nil).in_sequence.returns(stub(:tag => 1, :identifier => "name"))
-        Protopuffs::MessageField.expects(:new).once.with("required", "int32", "id", 2, nil).in_sequence.returns(stub(:tag => 2, :identifier => "id"))
-        Protopuffs::MessageField.expects(:new).once.with("optional", "string", "email", 3, nil).in_sequence.returns(stub(:tag => 3, :identifier => "email"))
+        Protopuffs::MessageField.expects(:factory).once.with("string", "required", "name", 1, nil).in_sequence.
+          returns(stub(:tag => 1, :identifier => "name"))
+        Protopuffs::MessageField.expects(:factory).once.with("int32", "required", "id", 2, nil).in_sequence.
+          returns(stub(:tag => 2, :identifier => "id"))
+        Protopuffs::MessageField.expects(:factory).once.with("string", "optional", "email", 3, nil).in_sequence.
+          returns(stub(:tag => 3, :identifier => "email"))
         @parser.parse(@descriptor)
       end
     end
@@ -102,15 +108,18 @@ class AbstractSyntaxTreeTest < Test::Unit::TestCase
         proto
       end
 
-      should "create one 'Person' MessageDescriptor with three fields" do
+      should "create one 'Person' message class with three fields" do
         Protopuffs::Message::Base.expects(:define_message_class).once.with("Person", responds_with(:size, 3))
         @parser.parse(@descriptor)
       end
 
       should "create three MessageFields with correct options" do
-        Protopuffs::MessageField.expects(:new).once.with("required", "string", "name", 1, nil).in_sequence.returns(stub(:tag => 1, :identifier => "name"))
-        Protopuffs::MessageField.expects(:new).once.with("optional", "string", "language", 2, "en").in_sequence.returns(stub(:tag => 2, :identifier => "language"))
-        Protopuffs::MessageField.expects(:new).once.with("optional", "int32", "account_code", 3, 0).in_sequence.returns(stub(:tag => 3, :identifier => "account_code"))
+        Protopuffs::MessageField.expects(:factory).once.with("string", "required", "name", 1, nil).in_sequence.
+          returns(stub(:tag => 1, :identifier => "name"))
+        Protopuffs::MessageField.expects(:factory).once.with("string", "optional", "language", 2, "en").in_sequence.
+          returns(stub(:tag => 2, :identifier => "language"))
+        Protopuffs::MessageField.expects(:factory).once.with("int32", "optional", "account_code", 3, 0).in_sequence.
+          returns(stub(:tag => 3, :identifier => "account_code"))
         @parser.parse(@descriptor)
       end
     end
@@ -126,17 +135,19 @@ class AbstractSyntaxTreeTest < Test::Unit::TestCase
         proto
       end
 
-      should "create one 'Person' MessageDescriptor with two fields" do
+      should "create one 'Person' message class with two fields" do
         Protopuffs::Message::Base.expects(:define_message_class).once.with("Person", responds_with(:size, 2))
         @parser.parse(@descriptor)
       end
 
       should "create two MessageFields with correct options" do
-        Protopuffs::MessageField.expects(:new).once.with("required", "string", "name", 1, nil).in_sequence.returns(stub(:tag => 1, :identifier => "name"))
-        Protopuffs::MessageField.expects(:new).once.with("repeated", "Address", "addresses", 2, nil).in_sequence.returns(stub(:tag => 2, :identifier => "addresses"))
+        Protopuffs::MessageField.expects(:factory).once.with("string", "required", "name", 1, nil).in_sequence.
+          returns(stub(:tag => 1, :identifier => "name"))
+        Protopuffs::MessageField.expects(:factory).once.with("Address", "repeated", "addresses", 2, nil).in_sequence.
+          returns(stub(:tag => 2, :identifier => "addresses"))
         @parser.parse(@descriptor)
       end
     end
   end
 
-end
+end

data/test/message_base_test.rb

@@ -1,18 +1,20 @@
+# encoding: UTF-8
+
 require File.dirname(__FILE__) + '/test_helper'
 
 class MessageBaseTest < Test::Unit::TestCase
 
   context ".define_message_class using 'Person' and two fields" do
     should "create a Message::Person class" do
-      fields = [Protopuffs::MessageField.new("optional", "string", "name", 1),
-                Protopuffs::MessageField.new("optional", "string", "address", 2)]
+      fields = [Protopuffs::String.new("optional", "name", 1),
+                Protopuffs::String.new("optional", "address", 2)]
       Protopuffs::Message::Base.define_message_class("Person", fields)
       Protopuffs::Message::Person
     end
 
     should "create a class with accessors for each field" do
-      fields = [Protopuffs::MessageField.new("optional", "string", "name", 1),
-                Protopuffs::MessageField.new("optional", "string", "address", 2)]
+      fields = [Protopuffs::String.new("optional", "name", 1),
+                Protopuffs::String.new("optional", "address", 2)]
       Protopuffs::Message::Base.define_message_class("Person", fields)
       person = Protopuffs::Message::Person.new
       person.name = "Chris"
@@ -25,8 +27,8 @@ class MessageBaseTest < Test::Unit::TestCase
 
   context ".define_message_class with fields that have duplicate tags" do
     should "raise a Protopuffs::ParseError" do
-      fields = [Protopuffs::MessageField.new("optional", "int32", "name", 1),
-                Protopuffs::MessageField.new("optional", "string", "address", 1)]
+      fields = [Protopuffs::Int32.new("optional", "name", 1),
+                Protopuffs::String.new("optional", "address", 1)]
       assert_raises Protopuffs::ParseError do
         Protopuffs::Message::Base.define_message_class("Person", fields)
       end
@@ -36,23 +38,23 @@ class MessageBaseTest < Test::Unit::TestCase
 
   context ".define_message_class with fields that have invalid tags" do
     should "raise a Protopuffs::ParseError when a tag is too large" do
-      fields = [Protopuffs::MessageField.new("optional", "int32", "name", 1),
-                Protopuffs::MessageField.new("optional", "string", "address", 536_870_912)]
+      fields = [Protopuffs::Int32.new("optional", "name", 1),
+                Protopuffs::String.new("optional", "address", 536_870_912)]
       assert_raises Protopuffs::ParseError do
         Protopuffs::Message::Base.define_message_class("Person", fields)
       end
     end
 
     should "raise a Protopuffs::ParseError when a tag is too small" do
-      fields = [Protopuffs::MessageField.new("optional", "int32", "name", 0),
-                Protopuffs::MessageField.new("optional", "string", "address", 1)]
+      fields = [Protopuffs::Int32.new("optional", "name", 0),
+                Protopuffs::String.new("optional", "address", 1)]
       assert_raises Protopuffs::ParseError do
         Protopuffs::Message::Base.define_message_class("Person", fields)
       end
     end
 
     should "raise a Protopuffs::ParseError when a tag is reserved" do
-      fields = [Protopuffs::MessageField.new("optional", "string", "name", 19050)]
+      fields = [Protopuffs::String.new("optional", "name", 19050)]
       assert_raises Protopuffs::ParseError do
         Protopuffs::Message::Base.define_message_class("Person", fields)
       end
@@ -60,6 +62,30 @@ class MessageBaseTest < Test::Unit::TestCase
   end
 
 
+  context ".define_message_class with a message name that's Camel_Scored" do
+    # violates the Google style guide, but the other implementations handle this
+    should "strip the underscore when creating the class" do
+      Protopuffs::Message::Base.define_message_class("User_Image", [])
+      assert !Protopuffs::Message.const_defined?("User_Image")
+      assert Protopuffs::Message.const_defined?("UserImage")
+    end
+
+    context "and an embedded-message field that's Camel_Scored" do
+      should "strip the underscore when instantiating the class of the field" do
+        child_fields = [Protopuffs::String.new("optional", "street", 1)]
+        Protopuffs::Message::Base.define_message_class("User_Address", child_fields)
+        parent_fields = [Protopuffs::Embedded.new("User_Address", "required", "user_address", 1)]
+        Protopuffs::Message::Base.define_message_class("User_Info", parent_fields)
+
+        child = Protopuffs::Message::UserAddress.new(:street => "400 2nd Street")
+        parent = Protopuffs::Message::UserInfo.new(child.to_wire_format)
+
+        assert_equal Protopuffs::Message::UserAddress, parent.user_address.class
+      end
+    end
+  end
+
+
   should "not allow you to instantiate Message::Base directly" do
     assert_raises RuntimeError do
       Protopuffs::Message::Base.new
@@ -75,7 +101,7 @@ class MessageBaseTest < Test::Unit::TestCase
     end
 
     should "return false when the messages' fields have different values" do
-      fields = [Protopuffs::MessageField.new("optional", "string", "name", 1)]
+      fields = [Protopuffs::String.new("optional", "name", 1)]
       Protopuffs::Message::Base.define_message_class("Person", fields)
       alice = Protopuffs::Message::Person.new
       alice.name = "Alice"
@@ -85,7 +111,7 @@ class MessageBaseTest < Test::Unit::TestCase
     end
 
     should "return true when messages of the same type have the same field values" do
-      fields = [Protopuffs::MessageField.new("optional", "string", "name", 1)]
+      fields = [Protopuffs::String.new("optional", "name", 1)]
       Protopuffs::Message::Base.define_message_class("Sheep", fields)
       sheep = Protopuffs::Message::Sheep.new
       sheep.name = "Dolly"
@@ -95,4 +121,82 @@ class MessageBaseTest < Test::Unit::TestCase
     end
   end
 
-end
+
+  context "instantiating a message class" do
+    setup do
+      fields = [Protopuffs::String.new("required", "title", 2)]
+      Protopuffs::Message::Base.define_message_class("Book", fields)
+    end
+
+    should "optionally accept a wire-format encoded IO-style object and populate the fields" do
+      input = StringIO.new([0x12, 0x07, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6E, 0x67].pack("C*"))
+      message = Protopuffs::Message::Book.new(input)
+      assert_equal "testing", message.title
+    end
+
+    should "optionally accept a wire-format encoded string and populate the fields" do
+      input = [0x12, 0x07, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6E, 0x67].pack("C*")
+      message = Protopuffs::Message::Book.new(input)
+      assert_equal "testing", message.title
+    end
+
+    should "not populate the fields if no argument is present" do
+      message = Protopuffs::Message::Book.new
+      assert_nil message.title
+    end
+
+    should "optionally accept a hash of field values and mass-assign them" do
+      message = Protopuffs::Message::Book.new(:title => "testing")
+      assert_equal "testing", message.title
+    end
+  end
+
+
+  context "mass-assignment of field values via #attributes=" do
+    setup do
+      fields = [Protopuffs::String.new("required", "title", 1),
+                Protopuffs::String.new("required", "author", 2),
+                Protopuffs::Int32.new("optional", "edition", 3)]
+      Protopuffs::Message::Base.define_message_class("Book", fields)
+    end
+
+    should "set each field value to the corresponding entry in the argument hash" do
+      message = Protopuffs::Message::Book.new
+      message.attributes = {:title   => "You Shall Know Our Velocity",
+                            :author  => "Dave Eggers",
+                            :edition => 2}
+      assert_equal "You Shall Know Our Velocity", message.title
+      assert_equal "Dave Eggers", message.author
+      assert_equal 2, message.edition
+    end
+
+    should "ignore unknown fields in the argument hash" do
+      message = Protopuffs::Message::Book.new
+      message.attributes = {:title   => "You Shall Know Our Velocity",
+                            :author  => "Dave Eggers",
+                            :edition => 2,
+                            :isbn    => "0970335555"}
+      assert_equal "You Shall Know Our Velocity", message.title
+      assert_equal "Dave Eggers", message.author
+      assert_equal 2, message.edition
+    end
+
+    should "only assign fields present in the argument hash" do
+      message = Protopuffs::Message::Book.new
+      message.title = "You Shall Know Our Velocity"
+      message.attributes = {:author => "Dave Eggers"}
+      assert_equal "Dave Eggers", message.author
+      assert_equal "You Shall Know Our Velocity", message.title
+      assert_nil message.edition
+    end
+
+    should "not assign defaults for optional fields missing from the argument hash" do
+      message = Protopuffs::Message::Book.new
+      message.attributes = {:author => "Dave Eggers"}
+      assert_equal "Dave Eggers", message.author
+      assert_nil message.title
+      assert_nil message.edition
+    end
+  end
+
+end

data/test/message_field_test.rb

@@ -1,34 +1,76 @@
+# encoding: UTF-8
+
 require File.dirname(__FILE__) + '/test_helper'
 
 class MessageFieldTest < Test::Unit::TestCase
 
   context "creating a MessageField" do
+    should "not allow you to instantiate MessageField directly" do
+      assert_raises RuntimeError do
+        Protopuffs::MessageField.new "_", "_", "_", "_"
+      end
+    end
+
+    should "complain if an invalid modifier is specified" do
+      ["optional", "required", "repeated"].each do |modifier|
+        assert_nothing_raised {Protopuffs::Int32.new(modifier, 'identitifer', 1)}
+      end
+      assert_raises(ArgumentError) {Protopuffs::Int32.new("invalid_modifier", "identifier", 1)}
+    end
+
+    should "instantiate the right class, given a type string" do
+      [[ "int32",    Protopuffs::Int32],
+       [ "int64",    Protopuffs::Int64],
+       [ "uint32",   Protopuffs::UInt32],
+       [ "uint64",   Protopuffs::UInt64],
+       [ "bool",     Protopuffs::Bool],
+       [ "double",   Protopuffs::Double],
+       [ "fixed64",  Protopuffs::Fixed64],
+       [ "string",   Protopuffs::String],
+       [ "bytes",    Protopuffs::Bytes],
+       [ "float",    Protopuffs::Float],
+       [ "fixed32",  Protopuffs::Fixed32],
+       [ "embedded", Protopuffs::Embedded],
+      ].each do |type, klass|
+        assert_kind_of klass, Protopuffs::MessageField.factory(type, "optional", "a_string", 1, 2)
+      end
+    end
+
     should "set a string's default to '' when a default isn't specified" do
-      field = Protopuffs::MessageField.new("optional", "string", "name", 1)
+      field = Protopuffs::String.new("optional", "name", 1)
+      assert_equal "", field.default
+    end
+
+    should "set a string's default to '' when a default is specified as nil" do
+      field = Protopuffs::String.new("optional", "name", 1, nil)
       assert_equal "", field.default
     end
 
-    should "set a numeric's default to 0 when a default isn't specified" do
-      numeric_types = %w(double float int32 int64 uint32 unit64 sint32 sint64
-                         fixed32 fixed64 sfixed32 sfixed64)
+    should "set a numeric's default to 0 when a default isn't specified or is specified as nil" do
+      numeric_types = [Protopuffs::Double, Protopuffs::Float,
+                       Protopuffs::Int32, Protopuffs::Int64,
+                       Protopuffs::UInt32, Protopuffs::UInt64,
+                       Protopuffs::Fixed32, Protopuffs::Fixed64]
       numeric_types.each do |type|
-        assert_equal 0, Protopuffs::MessageField.new("optional", type, "number", 1).default
+        assert_equal 0, type.new("optional", "number", 1).default
+        assert_equal 0, type.new("optional", "number", 1, nil).default
       end
     end
 
     should "set a bool's default to false when a default isn't specified" do
-      field = Protopuffs::MessageField.new("optional", "bool", "opt_in", 1)
+      field = Protopuffs::Bool.new("optional", "opt_in", 1)
+      assert_same false, field.default
+    end
+
+    should "set a bool's default to false when a default is specified as nil" do
+      field = Protopuffs::Bool.new("optional", "opt_in", 1, nil)
       assert_same false, field.default
     end
 
     should "set the default to 'Matz' when that default is specified" do
-      field = Protopuffs::MessageField.new("optional", "string", "name", 1, "Matz")
+      field = Protopuffs::String.new("optional", "name", 1, "Matz")
       assert_equal "Matz", field.default
     end
   end
 
-  should_return_wire_type_for_fields_typed 0 => %w(int32 int64 uint32 uint64 bool),
-                                           1 => %w(double fixed64),
-                                           2 => %w(bytes string TestMessage),
-                                           5 => %w(float fixed32)
-end
+end

data/test/parse_tree_test.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require File.dirname(__FILE__) + '/test_helper'
 
 class ParseTreeTest < Test::Unit::TestCase
@@ -203,4 +205,4 @@ class ParseTreeTest < Test::Unit::TestCase
 
   end
 
-end
+end

data/test/protopuffs_test.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require File.dirname(__FILE__) + '/test_helper'
 
 class ProtopuffsTest < Test::Unit::TestCase
@@ -33,4 +35,4 @@ class ProtopuffsTest < Test::Unit::TestCase
       assert_equal ["Chris", 42, "chris@kampers.net"], [p.name, p.id, p.email]
     end
   end
-end
+end

data/test/test_helper.rb

@@ -1,8 +1,9 @@
+# encoding: UTF-8
+
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
 require 'mocha'
-require 'treetop'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'protopuffs'
@@ -37,6 +38,7 @@ class Test::Unit::TestCase
   def self.should_decode_wire_format_to_fields(actual_bytes, expected_fields)
     should "decode the byte string #{inspect_bytes(actual_bytes)} to the fields #{expected_fields.inspect}" do
       buffer = StringIO.new(actual_bytes.pack('C*'))
+      buffer.set_encoding("BINARY") if buffer.respond_to?(:set_encoding)
       @message.from_wire_format(buffer)
       actual_fields = @message.class.fields.inject({}) { |hash, field|
         hash[field.identifier.to_sym] = @message.send(field.identifier)
@@ -56,16 +58,5 @@ class Test::Unit::TestCase
     end
   end
 
-
-  def self.should_return_wire_type_for_fields_typed(wire_types)
-    wire_types.each_pair do |wire_type, names|
-      names.each do |name|
-        should "return wire type #{wire_type} for a field with type #{name}" do
-          assert_equal wire_type, Protopuffs::MessageField.new("required", name, "a", 1).wire_type
-        end
-      end
-    end
-  end
-
 end
 

data/test/text_format_test.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/test_helper'
+
+class TextFormatTest < Test::Unit::TestCase
+
+  context "a message called Test1 with one int32 field" do
+    # from http://code.google.com/apis/protocolbuffers/docs/overview.html#whynotxml
+    setup do
+      fields = [Protopuffs::String.new("required", "name", 1),
+                Protopuffs::String.new("required", "email", 2)]
+      Protopuffs::Message::Base.define_message_class("Person", fields)
+      @message = Protopuffs::Message::Person.new
+      @message.name = "John Doe"
+      @message.email = "jdoe@example.com"
+    end
+
+    should "return the correct text format from #inspect" do
+      assert_equal %Q(person {\n  name: "John Doe"\n  email: "jdoe@example.com"\n}), @message.inspect
+    end
+  end
+
+end

data/test/wire_format_test.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require File.dirname(__FILE__) + '/test_helper'
 
 class WireFormatTest < Test::Unit::TestCase
@@ -5,7 +7,7 @@ class WireFormatTest < Test::Unit::TestCase
   context "a message with one int32 field tagged #1" do
     # from http://code.google.com/apis/protocolbuffers/docs/encoding.html#simple
     setup do
-      fields = [Protopuffs::MessageField.new("required", "int32", "a", 1)]
+      fields = [Protopuffs::Int32.new("required", "a", 1)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -15,13 +17,24 @@ class WireFormatTest < Test::Unit::TestCase
 
     # should ignore unknown fields: this message also has an int32 tagged #2 with value 157,372
     should_decode_wire_format_to_fields [0x08, 0x96, 0x01, 0x10, 0xBC, 0xCD, 0x09], :a => 150
+
+    should "return itself from #from_wire_format" do
+      wire_message = StringIO.new([0x08, 0x96, 0x01].pack('C*'))
+      assert_same @message, @message.from_wire_format(wire_message)
+    end
+
+    should "accept a string as an argument to #from_wire_format" do
+      wire_message = [0x08, 0x96, 0x01].pack('C*')
+      @message.from_wire_format(wire_message)
+      assert_equal 150, @message.a
+    end
   end
 
 
   context "a message with two int32 fields tagged #1 and #2" do
     setup do
-      fields = [Protopuffs::MessageField.new("required", "int32", "a", 1),
-                Protopuffs::MessageField.new("required", "int32", "b", 2)]
+      fields = [Protopuffs::Int32.new("required", "a", 1),
+                Protopuffs::Int32.new("required", "b", 2)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -35,7 +48,7 @@ class WireFormatTest < Test::Unit::TestCase
 
   context "a message with one int64 field tagged #1" do
     setup do
-      fields = [Protopuffs::MessageField.new("required", "int64", "a", 1)]
+      fields = [Protopuffs::Int64.new("required", "a", 1)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -49,8 +62,8 @@ class WireFormatTest < Test::Unit::TestCase
 
   context "a message with one uint32 field tagged #1 and one uint64 field tagged #2" do
     setup do
-      fields = [Protopuffs::MessageField.new("required", "uint32", "a", 1),
-                Protopuffs::MessageField.new("required", "uint64", "b", 2)]
+      fields = [Protopuffs::UInt32.new("required", "a", 1),
+                Protopuffs::UInt64.new("required", "b", 2)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -64,8 +77,8 @@ class WireFormatTest < Test::Unit::TestCase
 
   context "a message with two bool fields tagged #1 and #2" do
     setup do
-      fields = [Protopuffs::MessageField.new("required", "bool", "a", 1),
-                Protopuffs::MessageField.new("required", "bool", "b", 2)]
+      fields = [Protopuffs::Bool.new("required", "a", 1),
+                Protopuffs::Bool.new("required", "b", 2)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -80,7 +93,7 @@ class WireFormatTest < Test::Unit::TestCase
   context "a message with one string field tagged #2" do
     setup do
       # from http://code.google.com/apis/protocolbuffers/docs/encoding.html#types
-      fields = [Protopuffs::MessageField.new("required", "string", "b", 2)]
+      fields = [Protopuffs::String.new("required", "b", 2)]
       Protopuffs::Message::Base.define_message_class("Test2", fields)
       @message = Protopuffs::Message::Test2.new
     end
@@ -89,12 +102,25 @@ class WireFormatTest < Test::Unit::TestCase
                                           :b => "testing"
     should_decode_wire_format_to_fields   [0x12, 0x07, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6E, 0x67],
                                           :b => "testing"
+
+    should_encode_wire_format_from_fields [0x12, 0x01, 0x32], :b => 2
+    should_decode_wire_format_to_fields   [0x12, 0x01, 0x32], :b => "2"
+
+    should_encode_wire_format_from_fields [0x12, 0x0C, 0xE3, 0x81, 0x93, 0xE3, 0x81, 0xAB, 0xE3, 0x81, 0xA1, 0xE3, 0x82, 0x8F],
+                                          :b => "こにちわ"
+    should_decode_wire_format_to_fields   [0x12, 0x0C, 0xE3, 0x81, 0x93, 0xE3, 0x81, 0xAB, 0xE3, 0x81, 0xA1, 0xE3, 0x82, 0x8F],
+                                          :b => "こにちわ"
+
+    should_encode_wire_format_from_fields [0x12, 0x05, 0xD2, 0x90, 0x41, 0xC3, 0x9C],
+                                          :b => "ҐAÜ"
+    should_decode_wire_format_to_fields   [0x12, 0x05, 0xD2, 0x90, 0x41, 0xC3, 0x9C],
+                                          :b => "ҐAÜ"
   end
 
 
   context "a message with a bytes field tagged #1" do
     setup do
-      fields = [Protopuffs::MessageField.new("required", "bytes", "a", 1)]
+      fields = [Protopuffs::Bytes.new("required", "a", 1)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -108,7 +134,7 @@ class WireFormatTest < Test::Unit::TestCase
 
   context "a message with one float field tagged #1" do
     setup do
-      fields = [Protopuffs::MessageField.new("required", "float", "a", 1)]
+      fields = [Protopuffs::Float.new("required", "a", 1)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -124,7 +150,7 @@ class WireFormatTest < Test::Unit::TestCase
 
   context "a message with one double field tagged #1" do
     setup do
-      fields = [Protopuffs::MessageField.new("required", "double", "a", 1)]
+      fields = [Protopuffs::Double.new("required", "a", 1)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -140,7 +166,7 @@ class WireFormatTest < Test::Unit::TestCase
 
   context "a message with one fixed64 field tagged #1" do
     setup do
-      fields = [Protopuffs::MessageField.new("required", "fixed64", "a", 1)]
+      fields = [Protopuffs::Fixed64.new("required", "a", 1)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -155,7 +181,7 @@ class WireFormatTest < Test::Unit::TestCase
 
   context "a message with one fixed32 field tagged #1" do
     setup do
-      fields = [Protopuffs::MessageField.new("required", "fixed32", "a", 1)]
+      fields = [Protopuffs::Fixed32.new("required", "a", 1)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -169,7 +195,7 @@ class WireFormatTest < Test::Unit::TestCase
 
   context "a message with one repeating int32 field tagged #1" do
     setup do
-      fields = [Protopuffs::MessageField.new("repeated", "int32", "a", 1)]
+      fields = [Protopuffs::Int32.new("repeated", "a", 1)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -184,10 +210,10 @@ class WireFormatTest < Test::Unit::TestCase
   context "a message with one embedded-message field Test1 tagged #3 (where Test1 has an int32 field tagged #1)" do
     # from http://code.google.com/apis/protocolbuffers/docs/encoding.html#embedded
     setup do
-      test1_fields = [Protopuffs::MessageField.new("required", "int32", "a", 1)]
+      test1_fields = [Protopuffs::Int32.new("required", "a", 1)]
       Protopuffs::Message::Base.define_message_class("Test1", test1_fields)
 
-      test3_fields = [Protopuffs::MessageField.new("required", "Test1", "c", 3)]
+      test3_fields = [Protopuffs::Embedded.new("Test1", "required", "c", 3)]
       Protopuffs::Message::Base.define_message_class("Test3", test3_fields)
       @message = Protopuffs::Message::Test3.new
     end
@@ -201,8 +227,8 @@ class WireFormatTest < Test::Unit::TestCase
 
   context "a message with two int32 fields tagged #1 (optional, default=150) and #2 (required)" do
     setup do
-      fields = [Protopuffs::MessageField.new("optional", "int32", "a", 1, 150),
-                Protopuffs::MessageField.new("required", "int32", "b", 2)]
+      fields = [Protopuffs::Int32.new("optional", "a", 1, 150),
+                Protopuffs::Int32.new("required", "b", 2)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -216,8 +242,8 @@ class WireFormatTest < Test::Unit::TestCase
 
   context "a message with two int32 fields tagged #1 (optional, no default) and #2 (required)" do
     setup do
-      fields = [Protopuffs::MessageField.new("optional", "int32", "a", 1),
-                Protopuffs::MessageField.new("required", "int32", "b", 2)]
+      fields = [Protopuffs::Int32.new("optional", "a", 1),
+                Protopuffs::Int32.new("required", "b", 2)]
       Protopuffs::Message::Base.define_message_class("Test1", fields)
       @message = Protopuffs::Message::Test1.new
     end
@@ -228,4 +254,25 @@ class WireFormatTest < Test::Unit::TestCase
                                           :a => 0, :b => 157_372
   end
 
-end
+
+  context "a message with two int32 fields tagged #1 and #2, defined with #2 first" do
+    setup do
+      fields = [Protopuffs::Int32.new("required", "b", 2),
+                Protopuffs::Int32.new("required", "a", 1)]
+      Protopuffs::Message::Base.define_message_class("Test1", fields)
+      @message = Protopuffs::Message::Test1.new
+    end
+
+    # should always encode with fields ordered by tag number, to take
+    # advantage of decoders that optimize for this case
+    should_encode_wire_format_from_fields [0x08, 0x14, 0x10, 0xBC, 0xCD, 0x09],
+                                          :a => 20, :b => 157_372
+
+    # the decoder should still support any field order, though
+    should_decode_wire_format_to_fields   [0x08, 0x14, 0x10, 0xBC, 0xCD, 0x09],
+                                          :a => 20, :b => 157_372
+    should_decode_wire_format_to_fields   [0x10, 0xBC, 0xCD, 0x09, 0x08, 0x14],
+                                          :a => 20, :b => 157_372
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chrisk-protopuffs
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Chris Kampmeier
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-09 00:00:00 -07:00
+date: 2009-03-19 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -73,6 +73,7 @@ files:
 - test/parse_tree_test.rb
 - test/protopuffs_test.rb
 - test/test_helper.rb
+- test/text_format_test.rb
 - test/wire_format_test.rb
 has_rdoc: true
 homepage: http://github.com/chrisk/protopuffs