ruby_protobuf 0.3.3 → 0.4.1

data/lib/protobuf/message/field.rb

@@ -1,91 +1,178 @@
+require 'protobuf/common/util'
 require 'protobuf/common/wire_type'
 require 'protobuf/descriptor/field_descriptor'
 
 module Protobuf
   module Field
-    def self.build(message_class, rule, type, name, tag, opts={})
-      field_class =
-        if [:double, :float, :int32, :int64, :uint32, :uint64,
-          :sint32, :sint64, :fixed32, :fixed64, :sfixed32, :sfixed64,
-          :bool, :string, :bytes].include? type
-          eval "Protobuf::Field::#{type.to_s.capitalize}Field"
+
+    PREDEFINED_TYPES = [
+      :double,   :float,
+      :int32,    :int64,
+      :uint32,   :uint64,
+      :sint32,   :sint64,
+      :fixed32,  :fixed64,
+      :sfixed32, :sfixed64,
+      :string,   :bytes,
+      :bool,
+    ].freeze
+
+    def self.build(message_class, rule, type, name, tag, options={})
+      field_class = \
+        if PREDEFINED_TYPES.include?(type)
+          const_get("#{type.to_s.capitalize}Field")
         else
-          Protobuf::Field::FieldProxy
+          FieldProxy
         end
-      field_class.new message_class, rule, type, name, tag, opts
+      field_class.new(message_class, rule, type, name, tag, options)
     end
 
-    class InvalidRuleError < StandardError; end
-
     class BaseField
-      class <<self
-        def descriptor
-          @descriptor ||= Protobuf::Descriptor::FieldDescriptor.new
-        end
 
-        def default; nil end
+      def self.descriptor
+        @descriptor ||= Descriptor::FieldDescriptor.new
+      end
+
+      def self.default
+        nil
       end
 
-      attr_accessor :message_class, :rule, :type, :name, :tag, :default
+      attr_reader :message_class, :rule, :type, :name, :tag, :default
+      attr_reader :default_value
 
       def descriptor
-        @descriptor ||= Protobuf::Descriptor::FieldDescriptor.new self
+        @descriptor ||= Descriptor::FieldDescriptor.new(self)
       end
 
-      def initialize(message_class, rule, type, name, tag, opts={})
-        @message_class, @rule, @type, @name, @tag, @default, @extension =
-          message_class, rule, type, name, tag, opts[:default], opts[:extension]
-        @error_message = 'Type invalid'
+      def initialize(message_class, rule, type, name, tag, options)
+        @message_class, @rule, @type, @name, @tag = \
+          message_class, rule, type, name, tag
+
+        @default   = options.delete(:default)
+        @extension = options.delete(:extension)
+        @packed    = repeated? && options.delete(:packed)
+        unless options.empty?
+          warn "WARNING: Invalid options: #{options.inspect} (in #{@message_class.name.split('::').last}.#{@name})"
+        end
+        if packed? && ! [WireType::VARINT, WireType::FIXED32, WireType::FIXED64].include?(wire_type)
+          raise "Can't use packed encoding for `#{@type}' type"
+        end
+
+        @default_value = \
+          case @rule
+          when :repeated
+            FieldArray.new(self).freeze
+          when :required
+            nil
+          when :optional
+            typed_default_value
+          end
+
         define_accessor
       end
 
-      def ready?; true end
+      def ready?
+        true
+      end
 
-      def initialized?(message)
-        case rule
+      def initialized?(message_instance)
+        value = message_instance.__send__(@name)
+        case @rule
         when :required
-          return false if message[name].nil?
-          return false if is_a?(Protobuf::Field::MessageField) and not message[name].initialized?
+          ! value.nil? && (! kind_of?(MessageField) || value.initialized?)
         when :repeated
-          return message[name].all? {|msg|
-            (not is_a?(Protobuf::Field::MessageField)) or msg.initialized?
-          }
+          value.all? {|msg| ! kind_of?(MessageField) || msg.initialized? }
         when :optional
-          return false if message[name] and is_a?(Protobuf::Field::MessageField) and not message[name].initialized?
+          value.nil? || ! kind_of?(MessageField) || value.initialized?
         end
-        true
       end
 
-      def clear(message)
-        if repeated?
-          message[name].clear
+      # Decode +bytes+ and pass to +message_instance+.
+      def set(message_instance, bytes)
+        if packed?
+          array = message_instance.__send__(@name)
+          method = \
+            case wire_type
+            when WireType::FIXED32 then :read_fixed32
+            when WireType::FIXED64 then :read_fixed64
+            when WireType::VARINT  then :read_varint
+            end
+          stream = StringIO.new(bytes)
+          until stream.eof?
+            array << decode(Decoder.__send__(method, stream))
+          end
         else
-          message.instance_variable_get(:@values).delete(name)
+          value = decode(bytes)
+          if repeated?
+            message_instance.__send__(@name) << value
+          else
+            message_instance.__send__("#{@name}=", value)
+          end
         end
       end
 
-      def default_value
-        case rule
-        when :repeated
-          FieldArray.new self
-        when :required
-          nil
-        when :optional
-          typed_default_value default
+      # Decode +bytes+ and return a field value.
+      def decode(bytes)
+        raise NotImplementedError, "#{self.class.name}\#decode"
+      end
+
+      # Encode +value+ and return a byte string.
+      def encode(value)
+        raise NotImplementedError, "#{self.class.name}\#encode"
+      end
+
+      # Merge +value+ with +message_instance+.
+      def merge(message_instance, value)
+        if repeated?
+          merge_array(message_instance, value)
         else
-          raise InvalidRuleError
+          merge_value(message_instance, value)
         end
       end
 
-      def typed_default_value(default=nil)
-        default or self.class.default
+      # Is this a repeated field?
+      def repeated?
+        @rule == :repeated
+      end
+
+      # Is this a required field?
+      def required?
+        @rule == :required
+      end
+
+      # Is this a optional field?
+      def optional?
+        @rule == :optional
+      end
+
+      # Is this a packed repeated field?
+      def packed?
+        !!@packed
+      end
+
+      # Upper limit for this field.
+      def max
+        self.class.max
+      end
+
+      # Lower limit for this field.
+      def min
+        self.class.min
+      end
+
+      # Is a +value+ acceptable for this field?
+      def acceptable?(value)
+        true
+      end
+
+      def to_s
+        "#{@rule} #{@type} #{@name} = #{@tag} #{@default ? "[default=#{@default.inspect}]" : ''}"
       end
 
       private
 
       def define_accessor
         define_getter
-        if rule == :repeated
+        if repeated?
           define_array_setter
         else
           define_setter
@@ -111,7 +198,7 @@ module Protobuf
           define_method("#{field.name}=") do |val|
             if val.nil?
               @values.delete(field.name)
-            elsif field.acceptable? val
+            elsif field.acceptable?(val)
               @values[field.name] = val
             end
           end
@@ -127,117 +214,77 @@ module Protobuf
         end
       end
 
-      public
-
-      # encoder/decoder related methods
-
-      def set(message_instance, bytes)
-        value = decode(bytes)
-        if repeated?
-          message_instance.send(name) << value
-        else
-          message_instance.send("#{name}=", value)
-        end
-      end
-
-      def get(value)
-        encode(value)
-      end
-
-      def decode(bytes)
-        raise NotImplementedError.new("#{self.class.name}\#decode")
+      def merge_array(message_instance, value)
+        message_instance.__send__(@name).concat(value)
       end
-      private :decode
 
-      def encode(value)
-        raise NotImplementedError.new("#{self.class.name}\#encode")
+      def merge_value(message_instance, value)
+        message_instance.__send__("#{@name}=", value)
       end
-      private :encode
 
-      def merge(message_instance, value)
-        if repeated?
-          merge_array message_instance, value
+      def typed_default_value
+        if @default.nil?
+          self.class.default
         else
-          merge_value message_instance, value
+          @default
         end
       end
 
-      def merge_array(message_instance, value)
-        message_instance[tag].concat value
-      end
+    end # BaseField
 
-      def merge_value(message_instance, value)
-        message_instance[tag] = value
-      end
-
-      # utility methods
-
-      def repeated?; rule == :repeated end
-      def required?; rule == :required end
-      def optional?; rule == :optional end
-
-      def max; self.class.max end
-      def min; self.class.min end
-
-      def acceptable?(val)
-        true
-      end
 
-      def error_message
-        @error_message
-      end
+    class FieldProxy
 
-      def to_s
-        "#{rule} #{type} #{name} = #{tag} #{default ? "[default=#{default}]" : ''}"
+      def initialize(message_class, rule, type, name, tag, options)
+        @message_class, @rule, @type, @name, @tag, @options =
+          message_class, rule, type, name, tag, options
       end
-    end
 
-    class FieldProxy
-      def initialize(message_class, rule, type, name, tag, opts={})
-        @message_class, @rule, @type, @name, @tag, @opts =
-          message_class, rule, type, name, tag, opts
+      def ready?
+        false
       end
 
-      def ready?; false end
-
       def setup
-        type = typename_to_class @message_class, @type
-        field_class =
-          if type.superclass == Protobuf::Enum
-            Protobuf::Field::EnumField
-          elsif type.superclass == Protobuf::Message
-            Protobuf::Field::MessageField
+        type = typename_to_class(@message_class, @type)
+        field_class = \
+          if type < Enum
+            EnumField
+          elsif type < Message
+            MessageField
           else
-            raise TypeError.new(type.inspect)
+            raise TypeError, type.inspect
           end
-        field_class.new @message_class, @rule, type, @name, @tag, @opts
+        field_class.new(@message_class, @rule, type, @name, @tag, @options)
       end
 
+      private
+
       def typename_to_class(message_class, type)
-        suffix = type.to_s.split('::')
-        modules = message_class.to_s.split('::')
-        args = (Object.method(:const_defined?).arity == 1) ? [] : [nil, false]
+        names = type.to_s.split('::').map {|s| Util.camelize(s) }
+        outer = message_class.to_s.split('::')
+        args = (Object.method(:const_defined?).arity == 1) ? [] : [false]
         while
-          mod = modules.empty? ? Object : eval(modules.join('::'))
-          mod = suffix.inject(mod) {|m, s|
-            args[0] = s
-            m and m.const_defined?(*args) and m.const_get(s)
+          mod = outer.empty? ? Object : eval(outer.join('::'))
+          mod = names.inject(mod) {|m, s|
+            m && m.const_defined?(s, *args) && m.const_get(s)
           }
           break if mod
-          raise NameError.new("type not found: #{type}", type) if modules.empty?
-          modules.pop
+          raise NameError.new("type not found: #{type}", type) if outer.empty?
+          outer.pop
         end
         mod
       end
+
     end
 
     class FieldArray < Array
+
       def initialize(field)
         @field = field
       end
 
       def []=(nth, val)
-        super(normalize(val))
+        super(nth, normalize(val))
       end
 
       def <<(val)
@@ -272,39 +319,49 @@ module Protobuf
           val
         end
       end
+
     end
 
+    # Field class for +bytes+ type.
     class BytesField < BaseField
-      class <<self
-        def default; '' end
+      def self.default
+        ''
       end
 
       def wire_type
-        Protobuf::WireType::LENGTH_DELIMITED
+        WireType::LENGTH_DELIMITED
       end
 
       def acceptable?(val)
-        raise TypeError unless val.instance_of? String
+        raise TypeError unless val.instance_of?(String)
         true
       end
 
       def decode(bytes)
-        bytes.pack('C*')
+        bytes.force_encoding(Encoding::ASCII_8BIT) if bytes.respond_to?(:force_encoding)
+        bytes
       end
 
       def encode(value)
-        value = value.dup
-        value.force_encoding('ASCII-8BIT') if value.respond_to?(:force_encoding)
-        string_size = VarintField.encode(value.size)
-        string_size << value
+        if value.respond_to?(:force_encoding)
+          # Ruby 1.9
+          old_encoding = value.encoding
+          result = VarintField.encode(value.bytesize)
+          result << value.force_encoding(Encoding::ASCII_8BIT)
+          value.force_encoding(old_encoding)
+          result
+        else
+          # Ruby 1.8
+          result = VarintField.encode(value.size)
+          result << value
+        end
       end
     end
 
     class StringField < BytesField
       def decode(bytes)
-        message = bytes.pack('C*')
-        message.force_encoding('UTF-8') if message.respond_to?(:force_encoding)
-        message
+        bytes.force_encoding(Encoding::UTF_8) if bytes.respond_to?(:force_encoding)
+        bytes
       end
     end
 
@@ -317,7 +374,9 @@ module Protobuf
       UINT64_MAX =  2**64 - 1
 
       class <<self
-        def default; 0 end
+        def default
+          0
+        end
 
         def decode(bytes)
           value = 0
@@ -328,7 +387,7 @@ module Protobuf
         end
 
         def encode(value)
-          raise RangeError.new(value) if value < 0
+          raise RangeError, "#{value} is negative" if value < 0
           return [value].pack('C') if value < 128
           bytes = []
           until value == 0
@@ -341,11 +400,11 @@ module Protobuf
       end
 
       def wire_type
-        Protobuf::WireType::VARINT
+        WireType::VARINT
       end
 
-      def decode(bytes)
-        self.class.decode(bytes)
+      def decode(value)
+        value
       end
 
       def encode(value)
@@ -353,8 +412,8 @@ module Protobuf
       end
 
       def acceptable?(val)
-        raise TypeError.new(val.class.name) unless val.is_a? Integer
-        raise RangeError.new(val) if val < min or max < val
+        raise TypeError, val.class.name unless val.is_a?(Integer)
+        raise RangeError if val < min || max < val
         true
       end
     end
@@ -366,8 +425,7 @@ module Protobuf
         VarintField.encode(value & 0xffff_ffff_ffff_ffff)
       end
 
-      def decode(bytes)
-        value  = VarintField.decode(bytes)
+      def decode(value)
         value -= 0x1_0000_0000_0000_0000 if (value & 0x8000_0000_0000_0000).nonzero?
         value
       end
@@ -395,8 +453,7 @@ module Protobuf
 
     # Base class for sint32 and sint64
     class SignedIntegerField < VarintField
-      def decode(bytes)
-        value = VarintField.decode(bytes)
+      def decode(value)
         if (value & 1).zero?
           value >> 1   # positive value
         else
@@ -429,7 +486,7 @@ module Protobuf
       def self.min; -1.0/0; end
 
       def wire_type
-        Protobuf::WireType::FIXED32
+        WireType::FIXED32
       end
 
       def decode(bytes)
@@ -441,15 +498,15 @@ module Protobuf
       end
 
       def acceptable?(val)
-        raise TypeError.new(val.class.name) unless val.is_a? Numeric
-        raise RangeError.new(val) if val < min or max < val
+        raise TypeError, val.class.name unless val.is_a?(Numeric)
+        raise RangeError if val < min || max < val
         true
       end
     end
 
     class DoubleField < FloatField
       def wire_type
-        Protobuf::WireType::FIXED64
+        WireType::FIXED64
       end
 
       def decode(bytes)
@@ -463,7 +520,7 @@ module Protobuf
 
     class Fixed32Field < Uint32Field
       def wire_type
-        Protobuf::WireType::FIXED32
+        WireType::FIXED32
       end
 
       def decode(bytes)
@@ -477,7 +534,7 @@ module Protobuf
 
     class Fixed64Field < Uint64Field
       def wire_type
-        Protobuf::WireType::FIXED64
+        WireType::FIXED64
       end
 
       def decode(bytes)
@@ -494,7 +551,7 @@ module Protobuf
 
     class Sfixed32Field < Int32Field
       def wire_type
-        Protobuf::WireType::FIXED32
+        WireType::FIXED32
       end
 
       def decode(bytes)
@@ -510,7 +567,7 @@ module Protobuf
 
     class Sfixed64Field < Int64Field
       def wire_type
-        Protobuf::WireType::FIXED64
+        WireType::FIXED64
       end
 
       def decode(bytes)
@@ -528,17 +585,17 @@ module Protobuf
     end
 
     class BoolField < VarintField
-      class <<self
-        def default; false end
+      def self.default
+        false
       end
 
       def acceptable?(val)
-        raise TypeError unless [TrueClass, FalseClass].include? val.class
+        raise TypeError unless [true, false].include?(val)
         true
       end
 
-      def decode(bytes)
-        bytes.first == 1
+      def decode(value)
+        value == 1
       end
 
       def encode(value)
@@ -546,11 +603,31 @@ module Protobuf
       end
     end
 
+
     class MessageField < BaseField
-      class <<self
-        def default; nil end
+      def wire_type
+        WireType::LENGTH_DELIMITED
+      end
+
+      def acceptable?(val)
+        raise TypeError unless val.instance_of?(type) || val.instance_of?(Hash)
+        true
+      end
+
+      def decode(bytes)
+        message = type.new
+        message.parse_from_string(bytes)
+        message
+      end
+
+      def encode(value)
+        bytes = value.serialize_to_string
+        result = VarintField.encode(bytes.size)
+        result << bytes
       end
 
+      private
+
       def define_setter
         field = self
         @message_class.class_eval do
@@ -563,59 +640,70 @@ module Protobuf
             when field.type
               @values[field.name] = val
             else
-              raise TypeError
+              raise TypeError, "Expected value of type '#{field.type}', but got '#{val.class}'"
             end
           end
         end
       end
 
-      def wire_type
-        Protobuf::WireType::LENGTH_DELIMITED
+      def merge_value(message_instance, value)
+        message_instance.__send__(@name).merge_from(value)
       end
+    end
 
-      def typed_default_value(default=nil)
-        if default.is_a? Symbol
-          type.module_eval default.to_s
-        else
-          default
-        end
-      end
 
+    class EnumField < VarintField
       def acceptable?(val)
-        raise TypeError unless val.instance_of?(type) or val.instance_of?(Hash)
+        case val
+        when Symbol
+          raise TypeError unless @type.const_defined?(val)
+        when EnumValue
+          raise TypeError if val.parent_class != @type
+        else
+          raise TypeError unless @type.valid_tag?(val)
+        end
         true
       end
 
-      def decode(bytes)
-        message = type.new
-        message.parse_from_string bytes.pack('C*') # TODO
-        message
-      end
-
       def encode(value)
-        bytes = value.serialize_to_string
-        string_size = VarintField.encode bytes.size
-        string_size << bytes
+        super(value.to_i)
       end
 
-      def merge_value(message_instance, value)
-        message_instance[tag].merge_from value
-      end
-    end
+      private
 
-    class EnumField < VarintField
-      def default
+      def typed_default_value
         if @default.is_a?(Symbol)
-          type.const_get @default
+          @type.const_get(@default)
         else
-          @default
+          self.class.default
         end
       end
 
-      def acceptable?(val)
-        raise TypeError unless type.valid_tag? val
-        true
+      def define_setter
+        field = self
+        @message_class.class_eval do
+          define_method("#{field.name}=") do |val|
+            if val.nil?
+              @values.delete(field.name)
+            else
+              val = \
+                case val
+                when Symbol
+                  field.type.const_get(val) rescue nil
+                when Integer
+                  field.type.const_get(field.type.name_by_value(val)) rescue nil
+                when EnumValue
+                  raise TypeError, "Invalid value: #{val.inspect}" if val.parent_class != field.type
+                  val
+                end
+              raise TypeError, "Invalid value: #{val.inspect}" unless val
+
+              @values[field.name] = val
+            end
+          end
+        end
       end
+
     end
   end
 end