ruby_protobuf 0.3.3 → 0.4.1

data/lib/protobuf/message/message.rb

@@ -10,7 +10,6 @@ module Protobuf
   OPTIONS = {}
 
   class Message
-    class TagCollisionError < StandardError; end
 
     class ExtensionFields < Hash
       def initialize(key_range=0..-1)
@@ -18,65 +17,78 @@ module Protobuf
       end
 
       def []=(key, value)
-        raise RangeError.new("#{key} is not in #{@key_range}") unless @key_range.include? key
+        raise RangeError, "#{key} is not in #{@key_range}" unless @key_range.include?(key)
         super
       end
 
       def include_tag?(tag)
-        @key_range.include? tag
+        @key_range.include?(tag)
       end
     end
 
     class <<self
-      include Protobuf::Protoable
-      def fields; @fields ||= {} end
+      include Protoable
 
+      # Reserve field numbers for extensions. Don't use this method directly.
       def extensions(range)
-        @extension_fields = ExtensionFields.new range
+        @extension_fields = ExtensionFields.new(range)
       end
 
-      def required(type, name, tag, opts={})
-        define_field :required, type, name, tag, opts
+      # Define a required field. Don't use this method directly.
+      def required(type, name, tag, options={})
+        define_field(:required, type, name, tag, options)
       end
 
-      def optional(type, name, tag, opts={})
-        define_field :optional, type, name, tag, opts
+      # Define a optional field. Don't use this method directly.
+      def optional(type, name, tag, options={})
+        define_field(:optional, type, name, tag, options)
       end
 
-      def repeated(type, name, tag, opts={})
-        define_field :repeated, type, name, tag, opts
+      # Define a repeated field. Don't use this method directly.
+      def repeated(type, name, tag, options={})
+        define_field(:repeated, type, name, tag, options)
       end
 
-      def define_field(rule, type, fname, tag, opts={})
-        field_hash = opts[:extension] ? extension_fields : (@fields ||= {})
-        raise Protobuf::Message::TagCollisionError.new(<<-eos.strip) if field_hash.keys.include? tag
-          Field number #{tag} has already been used in "#{self.name}" by field "#{fname}".
-        eos
-        field_hash[tag] = Protobuf::Field.build self, rule, type, fname, tag, opts
+      # Define a field. Don't use this method directly.
+      def define_field(rule, type, fname, tag, options)
+        field_hash = options[:extension] ? extension_fields : fields
+        if field_hash.keys.include?(tag)
+          raise TagCollisionError, %!{Field number #{tag} has already been used in "#{self.name}" by field "#{fname}".!
+        end
+        field_hash[tag] = Field.build(self, rule, type, fname, tag, options)
       end
 
       def extension_tag?(tag)
-        extension_fields.include_tag? tag
+        extension_fields.include_tag?(tag)
+      end
+
+      # A collection of field object.
+      def fields
+        @fields ||= {}
       end
 
+      # An extension field object.
       def extension_fields
         @extension_fields ||= ExtensionFields.new
       end
 
+      # Find a field object by +name+.
       def get_field_by_name(name)
         name = name.to_sym
         fields.values.find {|field| field.name == name}
       end
 
+      # Find a field object by +tag+ number.
       def get_field_by_tag(tag)
         fields[tag]
       end
 
+      # Find a field object by +tag_or_name+.
       def get_field(tag_or_name)
         case tag_or_name
-        when Integer; get_field_by_tag tag_or_name
-        when String, Symbol; get_field_by_name tag_or_name
-        else; raise TypeError.new(tag_or_name.class)
+        when Integer        then get_field_by_tag(tag_or_name)
+        when String, Symbol then get_field_by_name(tag_or_name)
+        else                     raise TypeError, tag_or_name.class
         end
       end
 
@@ -94,38 +106,38 @@ module Protobuf
       #TODO merge to get_field
       def get_ext_field(tag_or_name)
         case tag_or_name
-        when Integer; get_ext_field_by_tag tag_or_name
-        when String, Symbol; get_ext_field_by_name tag_or_name
-        else; raise TypeError.new(tag_or_name.class)
+        when Integer        then get_ext_field_by_tag(tag_or_name)
+        when String, Symbol then get_ext_field_by_name(tag_or_name)
+        else                     raise TypeError, tag_or_name.class
         end
       end
 
       def descriptor
-        @descriptor ||= Protobuf::Descriptor::Descriptor.new(self)
+        @descriptor ||= Descriptor::Descriptor.new(self)
       end
     end
 
     def initialize(values={})
       @values = {}
 
-      self.class.fields.each do |tag, field|
+      self.class.fields.to_a.each do |tag, field|
         unless field.ready?
           field = field.setup
-          self.class.class_eval {@fields[tag] = field}
+          self.class.fields[tag] = field
         end
         if field.repeated?
-          @values[field.name] = Protobuf::Field::FieldArray.new(field)
+          @values[field.name] = Field::FieldArray.new(field)
         end
       end
 
       # TODO
-      self.class.extension_fields.each do |tag, field|
+      self.class.extension_fields.to_a.each do |tag, field|
         unless field.ready?
           field = field.setup
-          self.class.class_eval {@extension_fields[tag] = field}
+          self.class.extension_fields[tag] = field
         end
         if field.repeated?
-          @values[field.name] = Protobuf::Field::FieldArray.new(field)
+          @values[field.name] = Field::FieldArray.new(field)
         end
       end
 
@@ -134,175 +146,219 @@ module Protobuf
 
     def initialized?
       fields.all? {|tag, field| field.initialized?(self) } && \
-      extension_fields.all? {|tag, field| field.initialized?(self) }
+        extension_fields.all? {|tag, field| field.initialized?(self) }
     end
 
     def has_field?(tag_or_name)
       field = get_field(tag_or_name) || get_ext_field(tag_or_name)
-      raise ArgumentError.new("unknown field: #{tag_or_name.inspect}") unless field
+      raise ArgumentError, "unknown field: #{tag_or_name.inspect}" unless field
       @values.has_key?(field.name)
     end
 
     def ==(obj)
-      return false unless obj.is_a? self.class
+      return false unless obj.is_a?(self.class)
       each_field do |field, value|
-        return false unless value == obj.send(field.name)
+        return false unless value == obj.__send__(field.name)
       end
       true
     end
 
     def clear!
-      each_field do |field, value|
-        field.clear self
+      @values.delete_if do |_, value|
+        if value.is_a?(Field::FieldArray)
+          value.clear
+          false
+        else
+          true
+        end
       end
+      self
     end
 
     def dup
-      ret = self.class.new
-      each_field do |field, value|
-        if field.repeated?
-          field_array = ret.send(field.name)
-          value.each do |v|
-            field_array << (v.is_a?(Numeric) ? v : v.dup)
-          end
+      copy_to(super, :dup)
+    end
+
+    def clone
+      copy_to(super, :clone)
+    end
+
+    def copy_to(object, method)
+      duplicate = proc {|obj|
+        case obj
+        when Message, String then obj.__send__(method)
+        else                      obj
+        end
+      }
+
+      object.__send__(:initialize)
+      @values.each do |name, value|
+        if value.is_a?(Field::FieldArray)
+          object.__send__(name).replace(value.map {|v| duplicate.call(v)})
         else
-          ret.send("#{field.name}=", value.is_a?(Numeric) ? value : value.dup)
+          object.__send__("#{name}=", duplicate.call(value))
         end
       end
-      ret
+      object
     end
+    private :copy_to
 
     def inspect(indent=0)
-      ret = ''
+      result = []
       i = '  ' * indent
-      field_value_to_string = lambda do |field, value|
-        ret +=
-          if field.is_a? Protobuf::Field::MessageField
-            if value.nil?
-              if $DEBUG
-                "#{i}#{field.name} {\n#{'  ' * (indent + 1)}nil\n#{i}}\n"
-              else
+      field_value_to_string = lambda {|field, value|
+        result << \
+          if field.optional? && ! has_field?(field.name)
+            ''
+          else
+            case field
+            when Field::MessageField
+              if value.nil?
                 "#{i}#{field.name} {}\n"
+              else
+                "#{i}#{field.name} {\n#{value.inspect(indent + 1)}#{i}}\n"
               end
-            else
-              "#{i}#{field.name} {\n#{value.inspect(indent + 1)}#{i}}\n"
-            end
-          elsif field.is_a? Protobuf::Field::EnumField
-	    if field.optional? and not has_field?(field.name)
-	      ''
-	    else
-              "#{i}#{field.name}: #{field.type.name_by_value(value)}\n"
-            end
-          else
-            if $DEBUG
-              "#{i}#{field.name}: #{value.inspect}\n"
-            else
-              if field.optional? and not has_field?(field.name)
-                ''
+            when Field::EnumField
+              if value.is_a?(EnumValue)
+                "#{i}#{field.name}: #{value.name}\n"
               else
-                "#{i}#{field.name}: #{value.inspect}\n"
+                "#{i}#{field.name}: #{field.type.name_by_value(value)}\n"
               end
+            else
+              "#{i}#{field.name}: #{value.inspect}\n"
             end
           end
-      end
+      }
       each_field do |field, value|
         if field.repeated?
-          value.each do |v| 
-            field_value_to_string.call field, v
+          value.each do |v|
+            field_value_to_string.call(field, v)
           end
-        else 
-          field_value_to_string.call field, value
+        else
+          field_value_to_string.call(field, value)
         end
       end
-      ret
+      result.join
     end
 
     def parse_from_string(string)
-      parse_from StringIO.new(string)
+      parse_from(StringIO.new(string))
     end
 
     def parse_from_file(filename)
-      if filename.is_a? File
-        parse_from filename
+      if filename.is_a?(File)
+        parse_from(filename)
       else
         File.open(filename, 'rb') do |f|
-          parse_from f
+          parse_from(f)
         end
       end
     end
 
     def parse_from(stream)
-      Protobuf::Decoder.decode stream, self
+      Decoder.decode(stream, self)
     end
 
     def serialize_to_string(string='')
-      io = StringIO.new string
-      serialize_to io
+      io = StringIO.new(string)
+      serialize_to(io)
       result = io.string
-      result.force_encoding('ASCII-8BIT') if result.respond_to?(:force_encoding)
+      result.force_encoding(Encoding::ASCII_8BIT) if result.respond_to?(:force_encoding)
       result
     end
     alias to_s serialize_to_string
 
     def serialize_to_file(filename)
-      if filename.is_a? File
-        serialize_to filename
+      if filename.is_a?(File)
+        serialize_to(filename)
       else
         File.open(filename, 'wb') do |f|
-          serialize_to f
+          serialize_to(f)
         end
       end
     end
 
     def serialize_to(stream)
-      Protobuf::Encoder.encode stream, self
+      Encoder.encode(stream, self)
     end
 
     def merge_from(message)
       # TODO
-      fields.each {|tag, field| merge_field tag, message[tag]}
-      self.class.extension_fields.each {|tag, field| merge_field tag, message[tag]}
+      fields.each {|tag, field| merge_field(tag, message.__send__(field.name))}
+      extension_fields.each {|tag, field| merge_field(tag, message.__send__(field.name))}
     end
 
     def set_field(tag, bytes)
-      field = (get_field_by_tag(tag) or get_ext_field_by_tag(tag))
-      field.set self, bytes if field
+      field = (get_field_by_tag(tag) || get_ext_field_by_tag(tag))
+      field.set(self, bytes) if field
     end
-    
+
     def merge_field(tag, value)
       #get_field_by_tag(tag).merge self, bytes #TODO
-      (get_field_by_tag(tag) or get_ext_field_by_tag(tag)).merge self, value
+      (get_field_by_tag(tag) || get_ext_field_by_tag(tag)).merge(self, value)
     end
-    
+
     def [](tag_or_name)
       if field = get_field(tag_or_name) || get_ext_field(tag_or_name)
-        send field.name
+        __send__(field.name)
       else
-        raise NoMethodError.new("No such field: #{tag_or_name.inspect}")
+        raise NoMethodError, "No such field: #{tag_or_name.inspect}"
       end
     end
 
     def []=(tag_or_name, value)
       if field = get_field(tag_or_name) || get_ext_field(tag_or_name)
-        send "#{field.name}=", value
+        __send__("#{field.name}=", value)
       else
-        raise NoMethodError.new("No such field: #{tag_or_name.inspect}")
+        raise NoMethodError, "No such field: #{tag_or_name.inspect}"
       end
     end
 
-    def fields; self.class.fields end
-    def get_field_by_name(name); self.class.get_field_by_name(name) end
-    def get_field_by_tag(tag); self.class.get_field_by_tag(tag) end
-    def get_field(tag_or_name); self.class.get_field(tag_or_name) end
+    # Returns a hash; which key is a tag number, and value is a field object.
+    def fields
+      self.class.fields
+    end
+
+    # Returns field object or +nil+.
+    def get_field_by_name(name)
+      self.class.get_field_by_name(name)
+    end
 
-    def extension_fields; self.class.extension_fields end
-    def get_ext_field_by_name(name); self.class.get_ext_field_by_name(name) end
-    def get_ext_field_by_tag(tag); self.class.get_ext_field_by_tag(tag) end
-    def get_ext_field(tag_or_name); self.class.get_ext_field(tag_or_name) end
+    # Returns field object or +nil+.
+    def get_field_by_tag(tag)
+      self.class.get_field_by_tag(tag)
+    end
+
+    # Returns field object or +nil+.
+    def get_field(tag_or_name)
+      self.class.get_field(tag_or_name)
+    end
+
+    # Returns extension fields. See Message#fields method.
+    def extension_fields
+      self.class.extension_fields
+    end
+
+    def get_ext_field_by_name(name) # :nodoc:
+      self.class.get_ext_field_by_name(name)
+    end
+
+    def get_ext_field_by_tag(tag) # :nodoc:
+      self.class.get_ext_field_by_tag(tag)
+    end
+
+    def get_ext_field(tag_or_name) # :nodoc:
+      self.class.get_ext_field(tag_or_name)
+    end
 
+    # Iterate over a field collection.
+    #   message.each_field do |field_object, value|
+    #     # do something
+    #   end
     def each_field
-      (fields.merge extension_fields).sort_by {|tag, field| tag}.each do |tag, field|
-        yield field, send(field.name)
+      fields.merge(extension_fields).sort_by {|tag, _| tag}.each do |_, field|
+        value = __send__(field.name)
+        yield(field, value)
       end
     end
   end

data/lib/protobuf/message/protoable.rb

@@ -5,7 +5,8 @@ module Protobuf
     end
 
     def defined_in(filename)
-      defined_filenames << File.expand_path(filename)
+      path = File.expand_path(filename)
+      defined_filenames << path unless defined_filenames.include?(path)
     end
 
     def proto_filenames
@@ -17,8 +18,8 @@ module Protobuf
     def proto_contents
       #TODO: temporary implementation because the result includes not only this message but also all messages
       ret = {}
-      defined_filenames.map do |filename|
-        header = retrieve_header File.read(filename)
+      defined_filenames.each do |filename|
+        header = retrieve_header(File.read(filename))
         ret[header.first] = header.last
       end
       ret

data/lib/protobuf/message/service.rb

@@ -2,7 +2,7 @@ module Protobuf
   class Service
     class <<self
       def rpc(hash)
-        raise NotImplementedError('TODO')
+        raise NotImplementedError, 'TODO'
       end
     end
   end

data/lib/protobuf/rpc/client.rb

@@ -8,11 +8,11 @@ module Protobuf
       end
 
       def call(name, request, response)
-        socket = TCPSocket.open @host, @port
+        socket = TCPSocket.open(@host, @port)
         socket.write "#{name}\n"
-        request.serialize_to socket
+        request.serialize_to(socket)
         socket.close_write
-        response.parse_from socket
+        response.parse_from(socket)
       end
     end
   end

data/lib/protobuf/rpc/handler.rb

@@ -7,7 +7,7 @@ module Protobuf
         def request(request_class)
           @request_class = request_class
         end
-        
+
         def response(response_class)
           @response_class = response_class
         end

data/lib/protobuf/rpc/server.rb

@@ -5,7 +5,7 @@ module Protobuf
   module Rpc
     class Server < WEBrick::GenericServer
       def initialize(config={:Port => 9999}, default=WEBrick::Config::General)
-        super config, default
+        super(config, default)
         setup_handlers
       end
 
@@ -20,17 +20,17 @@ module Protobuf
       def run(socket)
         handler = get_handler socket
         request = handler.request_class.new
-        request.parse_from socket
+        request.parse_from(socket)
         response = handler.response_class.new
         begin
-          handler.process_request request, response
-        rescue StandardError => ex
-          @logger.error ex
+          handler.process_request(request, response)
+        rescue StandardError
+          @logger.error $!
         ensure
           begin
-            response.serialize_to socket
-          rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN => ex
-            @logger.error ex
+            response.serialize_to(socket)
+          rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN
+            @logger.error $!
           end
         end
       end

data/lib/ruby_protobuf.rb

@@ -1,3 +1,3 @@
 class RubyProtobuf
-  VERSION = '0.3.3'
+  VERSION = '0.4.1'
 end

data/test/check_unbuild.rb

@@ -14,17 +14,17 @@ class DescriptorTest < Test::Unit::TestCase
 
     assert_nothing_raised {Tutorial::Person}
     assert_nothing_raised {Tutorial::Person.new}
-    assert_equal ['email', 'id', 'name', 'phone'], 
-      Tutorial::Person.fields.map{|tag, field| field.name}.sort
+    assert_equal(['age', 'email', 'id', 'name', 'phone'], 
+      Tutorial::Person.fields.map{|tag, field| field.name}.sort)
 
     assert_nothing_raised {Tutorial::Person::PhoneNumber}
     assert_nothing_raised {Tutorial::Person::PhoneNumber.new}
-    assert_equal ['number', 'type'], 
-      Tutorial::Person::PhoneNumber.fields.map{|tag, field| field.name}.sort
+    assert_equal(['number', 'type'], 
+      Tutorial::Person::PhoneNumber.fields.map{|tag, field| field.name}.sort)
 
     assert_nothing_raised {Tutorial::Person::PhoneType}
-    assert_equal 0, Tutorial::Person::PhoneType::MOBILE
-    assert_equal 1, Tutorial::Person::PhoneType::HOME
-    assert_equal 2, Tutorial::Person::PhoneType::WORK
+    assert_equal(0, Tutorial::Person::PhoneType::MOBILE)
+    assert_equal(1, Tutorial::Person::PhoneType::HOME)
+    assert_equal(2, Tutorial::Person::PhoneType::WORK)
   end
 end

data/test/proto/addressbook.pb.rb

@@ -0,0 +1,67 @@
+### Generated by rprotoc. DO NOT EDIT!
+### <proto file: test/proto/addressbook.proto>
+# package tutorial;
+# 
+# message Person {
+#   required string name = 1;
+#   required int32 id = 2;
+#   optional string email = 3;
+# 
+#   enum PhoneType {
+#     MOBILE = 0;
+#     HOME = 1;
+#     WORK = 2;
+#   }
+# 
+#   message PhoneNumber {
+#     required string number = 1;
+#     optional PhoneType type = 2 [default = HOME];
+#   }
+# 
+#   repeated PhoneNumber phone = 4;
+#   optional uint32 age = 5 [default = 20];
+# 
+#   extensions 100 to 200;
+# }
+# 
+# /*
+# extend Person {
+#   optional int32 age = 100;
+# }
+# */
+# 
+# message AddressBook {
+#   repeated Person person = 1;
+# }
+
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'protobuf/message/service'
+require 'protobuf/message/extend'
+
+module Tutorial
+  class Person < ::Protobuf::Message
+    defined_in __FILE__
+    required :string, :name, 1
+    required :int32, :id, 2
+    optional :string, :email, 3
+    class PhoneType < ::Protobuf::Enum
+      defined_in __FILE__
+      define :MOBILE, 0
+      define :HOME, 1
+      define :WORK, 2
+    end
+    class PhoneNumber < ::Protobuf::Message
+      defined_in __FILE__
+      required :string, :number, 1
+      optional :PhoneType, :type, 2, :default => :HOME
+    end
+    repeated :PhoneNumber, :phone, 4
+    optional :uint32, :age, 5, :default => 20
+    extensions 100..200
+  end
+  class AddressBook < ::Protobuf::Message
+    defined_in __FILE__
+    repeated :Person, :person, 1
+  end
+end

data/test/proto/addressbook.proto

@@ -22,9 +22,11 @@ message Person {
   extensions 100 to 200;
 }
 
+/*
 extend Person {
   optional int32 age = 100;
 }
+*/
 
 message AddressBook {
   repeated Person person = 1;