ruby_protobuf 0.3.3 → 0.4.1

data/lib/protobuf/message/decoder.rb

@@ -1,85 +1,83 @@
 require 'protobuf/common/wire_type'
+require 'protobuf/common/exceptions'
 
 module Protobuf
-  class InvalidWireType < StandardError; end
 
-  class Decoder
-    class <<self
-      def decode(stream, message)
-        self.new(stream, message).decode
-      end
-    end
+  module Decoder
 
-    def initialize(stream=nil, message=nil)
-      @stream, @message = stream, message
-    end
+    module_function
 
-    def decode(stream=@stream, message=@message)
+    # Read bytes from +stream+ and pass to +message+ object.
+    def decode(stream, message)
       until stream.eof?
-        tag, wire_type = read_key stream
+        tag, wire_type = read_key(stream)
         bytes =
           case wire_type
           when WireType::VARINT
-            read_varint stream
+            read_varint(stream)
           when WireType::FIXED64
-            read_fixed64 stream
+            read_fixed64(stream)
           when WireType::LENGTH_DELIMITED
-            read_length_delimited stream
+            read_length_delimited(stream)
           when WireType::START_GROUP
-            read_start_group stream
+            read_start_group(stream)
           when WireType::END_GROUP
-            read_end_group stream
+            read_end_group(stream)
           when WireType::FIXED32
-            read_fixed32 stream
+            read_fixed32(stream)
           else
-            raise InvalidWireType.new(wire_type)
+            raise InvalidWireType, wire_type
           end
-        message.set_field tag, bytes
+        message.set_field(tag, bytes)
       end
       message
     end
 
-    protected
-
+    # Read key pair (tag and wire-type) from +stream+.
     def read_key(stream)
-      bytes = read_varint stream
-      bits = Protobuf::Field::VarintField.decode bytes
+      bits = read_varint(stream)
       wire_type = bits & 0x07
       tag = bits >> 3
       [tag, wire_type]
     end
 
+    # Read varint integer value from +stream+.
     def read_varint(stream)
       read_method = stream.respond_to?(:readbyte) ? :readbyte : :readchar
-      bytes = []
+      value = index = 0
       begin
-        byte = stream.send(read_method)
-        bytes << (byte & 0x7f)
+        byte = stream.__send__(read_method)
+        value |= (byte & 0x7f) << (7 * index)
+        index += 1
       end while (byte & 0x80).nonzero?
-      bytes
+      value
     end
 
+    # Read 32-bit string value from +stream+.
     def read_fixed32(stream)
       stream.read(4)
     end
 
+    # Read 64-bit string value from +stream+.
     def read_fixed64(stream)
       stream.read(8)
     end
 
+    # Read length-delimited string value from +stream+.
     def read_length_delimited(stream)
-      bytes = read_varint stream
-      value_length = Protobuf::Field::VarintField.decode bytes
-      value = stream.read value_length
-      value.unpack('C*')
+      value_length = read_varint(stream)
+      stream.read(value_length)
     end
 
+    # Not implemented.
     def read_start_group(stream)
-      raise NotImplementedError.new('Group is duplecated.')
+      raise NotImplementedError, 'Group is deprecated.'
     end
- 
+
+    # Not implemented.
     def read_end_group(stream)
-      raise NotImplementedError.new('Group is duplecated.')
+      raise NotImplementedError, 'Group is deprecated.'
     end
+
   end
 end

data/lib/protobuf/message/encoder.rb

@@ -1,40 +1,44 @@
 require 'protobuf/common/wire_type'
+require 'protobuf/common/exceptions'
 
 module Protobuf
-  class NotInitializedError < StandardError; end
 
-  class Encoder
-    class <<self
-      def encode(stream, message)
-        self.new(stream, message).encode
-      end
-    end
+  module Encoder
 
-    def initialize(stream=nil, message=nil)
-      @stream, @message = stream, message
-    end
+    module_function
 
-    def encode(stream=@stream, message=@message)
+    # Encode +message+ and write to +stream+.
+    def encode(stream, message)
       raise NotInitializedError unless message.initialized?
       message.each_field do |field, value|
         next unless message.has_field?(field.name)
 
         if field.repeated?
-          value.each do |val|
-            write_pair field, val, stream
+          if field.packed?
+            key = (field.tag << 3) | WireType::LENGTH_DELIMITED
+            packed_value = value.map {|val| field.encode(val) }.join
+            stream.write(Field::VarintField.encode(key))
+            stream.write(Field::VarintField.encode(packed_value.size))
+            stream.write(packed_value)
+          else
+            value.each do |val|
+              write_pair(stream, field, val)
+            end
           end
         else
-          write_pair field, value, stream
+          write_pair(stream, field, value)
         end
       end
     end
 
-    def write_pair(field, value, stream)
+    # Encode key and value, and write to +stream+.
+    def write_pair(stream, field, value)
       key = (field.tag << 3) | field.wire_type
-      key_bytes = Protobuf::Field::VarintField.encode key
-      stream.write key_bytes
-      bytes = field.get value
-      stream.write bytes
+      key_bytes = Field::VarintField.encode(key)
+      stream.write(key_bytes)
+      bytes = field.encode(value)
+      stream.write(bytes)
     end
+
   end
 end

data/lib/protobuf/message/enum.rb

@@ -1,28 +1,62 @@
+require 'delegate'
 require 'protobuf/descriptor/enum_descriptor'
 require 'protobuf/message/protoable'
 
 module Protobuf
   class Enum
     class <<self
-      include Protobuf::Protoable
+      include Protoable
 
-      def get_name_by_tag(tag)
-        constants.find do |name|
-          const_get(name) == tag
+      attr_reader :values
+
+      def name_by_value(value)
+        if not defined?(@values)
+          constants.find {|c| const_get(c) == value}  # for compatibility
+        else
+          @values_index ||= @values.inject({}) {|hash, (n, v)| hash[v.value] = n; hash }
+          @values_index[value]
         end
       end
 
+      alias get_name_by_tag name_by_value
+
       def valid_tag?(tag)
-        not get_name_by_tag(tag).nil?
+        !! name_by_value(tag)
       end
 
-      def name_by_value(value)
-        constants.find {|c| const_get(c) == value}
+      def descriptor
+        @descriptor ||= Descriptor::EnumDescriptor.new(self)
       end
 
-      def descriptor
-        @descriptor ||= Protobuf::Descriptor::EnumDescriptor.new(self)
+      private
+
+      def define(name, value)
+        enum_value = EnumValue.new(self, name, value)
+        const_set(name, enum_value)
+        @values ||= {}
+        @values[name] = enum_value
       end
     end
   end
+
+  class EnumValue < SimpleDelegator
+
+    attr_reader :parent_class, :name, :value
+
+    def initialize(parent_class, name, value)
+      @parent_class = parent_class
+      @name = name
+      @value = value
+      super(@value)
+    end
+
+    def to_s
+      @name.to_s
+    end
+
+    def inspect
+      "\#<#{self.class} #{@parent_class}::#{@name}=#{@value}>"
+    end
+  end
+
 end