protobuf 2.0.0.rc2 → 2.0.0.rc3

data/lib/protobuf/enum.rb

@@ -1,52 +1,57 @@
-require 'delegate'
+require 'protobuf/enum_value'
 
 module Protobuf
   class Enum
-    class << self
-      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 self.define(name, value)
+      enum_value = ::Protobuf::EnumValue.new(self, name, value)
+      const_set(name, enum_value)
+      @values ||= {}
+      @names ||= []
+      @values[name] = enum_value
+      @names[value] = name
+    end
 
-      def valid_tag?(tag)
-        !! name_by_value(tag)
+    # Fetch the given enum by a variety of type-checking
+    # mechanisms. This is useful for the enum field setters
+    # as well as repeated enum field construction.
+    def self.fetch(value)
+      if value.is_a?(::Protobuf::EnumValue)
+        value
+      elsif value.respond_to?(:to_sym)
+        value_by_name(value.to_sym) rescue nil
+      elsif value.respond_to?(:to_i)
+        enum_by_value(value.to_i) rescue nil
+      else
+        nil
       end
+    end
 
-      def define(name, value)
-        enum_value = EnumValue.new(self, name, value)
-        const_set(name, enum_value)
-        @values ||= {}
-        @values[name] = enum_value
-      end
+    def self.enum_by_value(value)
+      value_by_name(name_by_value(value))
     end
-  end
 
-  class EnumValue < SimpleDelegator
+    def self.name_by_value(value)
+      @names[value]
+    end
 
-    attr_reader :parent_class, :name, :value
+    def self.valid_tag?(tag)
+      !! name_by_value(tag)
+    end
 
-    def initialize(parent_class, name, value)
-      @parent_class = parent_class
-      @name = name
-      @value = value
-      super(@value)
+    def self.value_by_name(name)
+      @values[name]
     end
 
-    def to_s
-      @name.to_s
+    def self.values
+      @values
     end
 
-    def inspect
-      "\#<#{self.class} #{@parent_class}::#{@name}=#{@value}>"
+    ##
+    # Class Aliases
+    #
+    class << self
+      alias_method :get_name_by_tag, :name_by_value
     end
   end
-
 end

data/lib/protobuf/enum_value.rb

@@ -0,0 +1,29 @@
+require 'delegate'
+require 'protobuf/enum'
+
+module Protobuf
+  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 inspect
+      "\#<#{self.class} #{@parent_class}::#{@name}=#{@value}>"
+    end
+
+    def to_hash_value
+      self.to_i
+    end
+
+    def to_s
+      @name.to_s
+    end
+  end
+end
+

data/lib/protobuf/field/base_field.rb

@@ -8,7 +8,7 @@ module Protobuf
       # Attributes
       #
       attr_reader :message_class, :rule, :type, :name, :tag, :default, :default_value, :setter_method_name, :getter_method_name
-      
+
       ##
       # Class Methods
       #
@@ -28,6 +28,7 @@ module Protobuf
         @default   = options.delete(:default)
         @extension = options.delete(:extension)
         @packed    = repeated? && options.delete(:packed)
+        @deprecated = options.delete(:deprecated)
         unless options.empty?
           warn "WARNING: Invalid options: #{options.inspect} (in #{@message_class.name.split('::').last}.#{@name})"
         end
@@ -134,9 +135,14 @@ module Protobuf
         @_optional = (@rule == :optional)
       end
 
+      # Is this a deprecated field?
+      def deprecated?
+        !! @deprecated
+      end
+
       # Is this a packed repeated field?
       def packed?
-        !!@packed
+        !! @packed
       end
 
       # Upper limit for this field.
@@ -153,24 +159,42 @@ module Protobuf
         "#{@rule} #{@type} #{@name} = #{@tag} #{@default ? "[default=#{@default.inspect}]" : ''}"
       end
 
+      def warn_if_deprecated
+        if ::Protobuf.print_deprecation_warnings? && deprecated?
+          $stderr.puts("[WARNING] #{@message_class.name}##{@name} field usage is deprecated.")
+        end
+      end
+
       private
 
-      ## 
+      ##
       # Private Instance Methods
       #
       def define_accessor
-        define_getter
         if repeated?
+          define_array_getter
           define_array_setter
         else
+          define_getter
           define_setter
         end
       end
 
+      def define_array_getter
+        field = self
+        @message_class.class_eval do
+          define_method(field.getter_method_name) do
+            @values[field.name] ||= ::Protobuf::Field::FieldArray.new(field)
+          end
+        end
+      end
+
       def define_array_setter
         field = self
         @message_class.class_eval do
           define_method(field.setter_method_name) do |val|
+            field.warn_if_deprecated
+            @values[field.name] ||= ::Protobuf::Field::FieldArray.new(field)
             @values[field.name].replace(val)
           end
         end
@@ -180,6 +204,7 @@ module Protobuf
         field = self
         @message_class.class_eval do
           define_method(field.getter_method_name) do
+            field.warn_if_deprecated
             @values.fetch(field.name, field.default_value)
           end
         end
@@ -189,10 +214,13 @@ module Protobuf
         field = self
         @message_class.class_eval do
           define_method(field.setter_method_name) do |val|
+            field.warn_if_deprecated
             if val.nil?
               @values.delete(field.name)
             elsif field.acceptable?(val)
               @values[field.name] = val
+            else
+              raise TypeError, "unacceptable value #{val} for type #{field.type}"
             end
           end
         end
@@ -205,6 +233,7 @@ module Protobuf
           @default
         end
       end
-    end 
+
+    end
   end
 end

data/lib/protobuf/field/enum_field.rb

@@ -32,23 +32,15 @@ module Protobuf
       def define_setter
         field = self
         @message_class.class_eval do
-          define_method("#{field.name}=") do |val|
-            if val.nil?
+          define_method("#{field.name}=") do |value|
+            orig_value = value
+            if value.nil?
               @values.delete(field.name)
             else
-              val = \
-                case val
-                when Symbol then
-                  field.type.const_get(val) rescue nil
-                when Integer then
-                  field.type.const_get(field.type.name_by_value(val)) rescue nil
-                when EnumValue then
-                  raise TypeError, "Invalid value: #{val.inspect} for #{field.name}" if val.parent_class != field.type
-                  val
-                end
-              raise TypeError, "Invalid value: #{val.inspect} for #{field.name}" unless val
+              value = field.type.fetch(value)
+              raise TypeError, "Invalid ENUM value: #{orig_value.inspect} for #{field.name}" unless value
 
-              @values[field.name] = val
+              @values[field.name] = value
             end
           end
         end

data/lib/protobuf/field/extension_fields.rb

@@ -1,23 +1,31 @@
 module Protobuf
   module Field
-    class ExtensionFields < Hash
+    class ExtensionFields < Array
       ##
       # Constructor
       #
-      def initialize(key_range=0..-1)
-        @key_range = key_range
+      def initialize
+        @ranges = []
       end
 
       ##
       # Public Instance Methods
       #
+
+      # Append a range to the list of ranges.
+      def add_range(range = (0..-1))
+        @ranges << range
+      end
+
+      # Set value at tag location, if tag is in a valid range.
       def []=(key, value)
-        raise RangeError, "#{key} is not in #{@key_range}" unless @key_range.include?(key)
+        raise RangeError, "#{key} is not in #{@ranges.join(', ')}" unless include_tag?(key)
         super
       end
 
+      # Check if the given tag exists in any of the defined ranges.
       def include_tag?(tag)
-        @key_range.include?(tag)
+        @ranges.any? { |range| range.include?(tag) }
       end
     end
   end

data/lib/protobuf/field/field_array.rb

@@ -8,7 +8,7 @@ module Protobuf
         @field = field
       end
 
-      ## 
+      ##
       # Public Instance Methods
       #
       def []=(nth, val)
@@ -33,21 +33,31 @@ module Protobuf
         super(val)
       end
 
+      # Return a hash-representation of the given values for this field type.
+      # The value in this case would be an array.
+      def to_hash_value
+        self.map do |value|
+          value.respond_to?(:to_hash_value) ? value.to_hash_value : value
+        end
+      end
+
       def to_s
         "[#{@field.name}]"
       end
-      
+
       private
 
       ##
       # Private Instance Methods
       #
-      def normalize(val)
-        raise TypeError unless @field.acceptable?(val)
-        if @field.is_a?(::Protobuf::Field::MessageField) && val.is_a?(Hash)
-          @field.type.new(val)
+      def normalize(value)
+        raise TypeError unless @field.acceptable?(value)
+        if @field.is_a?(::Protobuf::Field::EnumField)
+          @field.type.fetch(value)
+        elsif @field.is_a?(::Protobuf::Field::MessageField) && value.is_a?(Hash)
+          @field.type.new(value)
         else
-          val
+          value
         end
       end
     end

data/lib/protobuf/field/varint_field.rb

@@ -4,8 +4,8 @@ module Protobuf
   module Field
     class VarintField < BaseField
       INT32_MAX  =  2**31 - 1
-      INT32_MIN  = -2**31
-      INT64_MAX  =  2**63 - 1
+      INT32_MIN  = -2**31 
+      INT64_MAX  =  2**63 - 1 
       INT64_MIN  = -2**63
       UINT32_MAX =  2**32 - 1
       UINT64_MAX =  2**64 - 1
@@ -26,8 +26,8 @@ module Protobuf
       end
 
       def self.encode(value)
-        raise RangeError, "#{value} is negative" if value < 0
         return [value].pack('C') if value < 128
+
         bytes = []
         until value == 0
           bytes << (0x80 | (value & 0x7f))
@@ -41,9 +41,7 @@ module Protobuf
       # Public Instance Methods
       #
       def acceptable?(val)
-        raise TypeError, val.class.name unless val.is_a?(Integer)
-        raise RangeError if val < min || max < val
-        true
+        (val > min || val < max) rescue false
       end
 
       def decode(value)

data/lib/protobuf/message.rb

@@ -8,22 +8,21 @@ module Protobuf
   class Message
     STRING_ENCODING = "ASCII-8BIT".freeze
 
-    def self.inherited(klass)
-      @_children ||= Set.new
-      @_children << klass
-    end
-
     def self.all_fields
       @all_fields ||= begin
-                        fields_hash = fields.merge(extension_fields)
-                        ordered_keys = fields_hash.keys.sort
-                        ordered_keys.map { |key| fields_hash[key] }
+                        all_fields_array = []
+                        max_fields = fields.size > extension_fields.size ? fields.size : extension_fields.size
+                        max_fields.times do |field_number|
+                          all_fields_array << (fields[field_number] || extension_fields[field_number])
+                        end
+                        all_fields_array.compact!
+                        all_fields_array
                       end
     end
 
     # Reserve field numbers for extensions. Don't use this method directly.
     def self.extensions(range)
-      @extension_fields = ::Protobuf::Field::ExtensionFields.new(range)
+      extension_fields.add_range(range)
     end
 
     # Define a required field. Don't use this method directly.
@@ -43,18 +42,16 @@ module Protobuf
 
     # Define a field. Don't use this method directly.
     def self.define_field(rule, type, fname, tag, options)
-      field_hash = options[:extension] ? extension_fields : fields
-      field_name_hash = options[:extension] ? extension_fields_by_name : fields_by_name
-      repeated_collection = options[:extension] ? repeated_extension_fields : repeated_fields
+      field_array = options[:extension] ? extension_fields : fields
+      field_name_hash = options[:extension] ? extension_field_name_to_tag : field_name_to_tag
 
-      if field_hash.keys.include?(tag)
+      if field_array[tag]
         raise TagCollisionError, %!{Field number #{tag} has already been used in "#{self.name}" by field "#{fname}".!
       end
 
       field_definition = Field.build(self, rule, type, fname, tag, options)
-      field_name_hash[fname.to_sym] = field_definition
-      repeated_collection << field_definition if rule == :repeated 
-      field_hash[tag] = field_definition
+      field_name_hash[fname] = tag
+      field_array[tag] = field_definition
     end
 
     def self.extension_tag?(tag)
@@ -66,31 +63,23 @@ module Protobuf
       @extension_fields ||= ::Protobuf::Field::ExtensionFields.new
     end
 
-    def self.extension_fields_by_name
+    def self.extension_field_name_to_tag
       @extension_fields_by_name ||= {}
     end
 
     # A collection of field object.
     def self.fields
-      @fields ||= {}
+      @fields ||= []
     end
 
-    def self.fields_by_name
-      @field_by_name ||= {}
-    end
-
-    def self.repeated_fields
-      @repeated_fields ||= []
-    end
-
-    def self.repeated_extension_fields
-      @repeated_extension_fields ||= []
+    def self.field_name_to_tag
+      @field_name_to_tag ||= {}
     end
 
     # Find a field object by +name+.
     def self.get_field_by_name(name)
       # Check if the name has been used before, if not then set it to the sym value
-      fields_by_name[name] ||= fields_by_name[name.to_sym]
+      fields[field_name_to_tag[name]]
     end
 
     # Find a field object by +tag+ number.
@@ -98,62 +87,30 @@ module Protobuf
       fields[tag]
     end
 
-    def self.field_cache
-      @field_cache ||= {}
-    end
-
-    # Find a field object by +tag_or_name+.
-    def self.get_field(tag_or_name)
-      field_cache[tag_or_name] ||= case tag_or_name
-                                   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
-
     def self.get_ext_field_by_name(name)
       # Check if the name has been used before, if not then set it to the sym value
-      extension_fields_by_name[name] ||= extension_fields_by_name[name.to_sym]
+      extension_fields[extension_field_name_to_tag[name]]
     end
 
     def self.get_ext_field_by_tag(tag)
       extension_fields[tag]
     end
 
-    def self.get_ext_field(tag_or_name)
-      case tag_or_name
-      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
-
     ##
     # Constructor
     #
     def initialize(values={})
       @values = {}
 
-      self.class.repeated_fields.each do |field|
-        @values[field.name] = Field::FieldArray.new(field)
-      end
-
-      self.class.repeated_extension_fields.each do |field|
-        @values[field.name] = Field::FieldArray.new(field)
-      end
-
-      values.each { |tag, val| self[tag] = val}
+      values.each { |name, val| self[name] = val}
     end
 
     def initialized?
-      fields.all? {|tag, field| field.initialized?(self) } && \
-        extension_fields.all? {|tag, field| field.initialized?(self) }
+      all_fields.all? { |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, "unknown field: #{tag_or_name.inspect}" unless field
-      @values.has_key?(field.name)
+    def has_field?(name)
+      @values.has_key?(name)
     end
 
     def ==(obj)
@@ -204,42 +161,8 @@ module Protobuf
     end
     private :copy_to
 
-    def inspect(indent=0)
-      result = []
-      i = '  ' * indent
-      field_value_to_string = lambda { |field, value|
-        result << \
-          if field.optional? && ! has_field?(field.name)
-            ''
-          else
-            case field
-            when Field::MessageField then
-              if value.nil?
-                "#{i}#{field.name} {}\n"
-              else
-                "#{i}#{field.name} {\n#{value.inspect(indent + 1)}#{i}}\n"
-              end
-            when Field::EnumField then
-              if value.is_a?(EnumValue)
-                "#{i}#{field.name}: #{value.name}\n"
-              else
-                "#{i}#{field.name}: #{field.type.name_by_value(value)}\n"
-              end
-            else
-              "#{i}#{field.name}: #{value.inspect}\n"
-            end
-          end
-      }
-      each_field do |field, value|
-        if field.repeated?
-          value.each do |v|
-            field_value_to_string.call(field, v)
-          end
-        else
-          field_value_to_string.call(field, value)
-        end
-      end
-      result.join
+    def inspect
+      to_hash.inspect
     end
 
     def parse_from_string(string)
@@ -268,30 +191,29 @@ module Protobuf
       field.set(self, bytes) if field
     end
 
-    def [](tag_or_name)
-      if field = get_field(tag_or_name) || get_ext_field(tag_or_name)
+    def [](name)
+      if field = get_field_by_name(name) || get_ext_field_by_name(name)
         __send__(field.name)
       else
-        raise NoMethodError, "No such field: #{tag_or_name.inspect}"
+        raise NoMethodError, "No such field: #{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)
+    def []=(name, value)
+      if field = get_field_by_name(name) || get_ext_field_by_name(name)
         __send__(field.setter_method_name, value)
       else
-        raise NoMethodError, "No such field: #{tag_or_name.inspect}"
+        raise NoMethodError, "No such field: #{name.inspect}"
       end
     end
 
     # Returns a hash; which key is a tag number, and value is a field object.
     def all_fields
-      @_all_fields ||= self.class.all_fields
+      self.class.all_fields
     end
 
     def fields
-      @_fields ||= self.class.fields
+      self.class.fields
     end
 
     # Returns field object or +nil+.
@@ -304,11 +226,6 @@ module Protobuf
       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
@@ -322,10 +239,6 @@ module Protobuf
       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
@@ -337,40 +250,23 @@ module Protobuf
       end
     end
 
+    # Return a hash-representation of the given fields for this message type.
     def to_hash
-      result = {}
-      build_value = lambda { |field, value|
-        if !field.optional? || (field.optional? && has_field?(field.name))
-          case field
-          when Field::MessageField then
-            value.to_hash
-          when Field::EnumField then
-            if value.is_a?(EnumValue)
-              value.to_i
-            elsif value.is_a?(Symbol)
-              field.type[value].to_i
-            else
-              value
-            end
-          else
-            value
-          end
-        end
-      }
-      each_field do |field, value|
-        if field.repeated?
-          result[field.name] = value.map do |v|
-            build_value.call(field, v)
-          end
-        else
-          result[field.name] = build_value.call(field, value)
-        end
+      result = Hash.new
+
+      @values.keys.each do |field_name|
+        value = __send__(field_name)
+        hashed_value = value.respond_to?(:to_hash_value) ? value.to_hash_value : value
+        result.merge!(field_name => hashed_value)
       end
-      result
+
+      return result
     end
+    alias_method :to_hash_value, :to_hash
 
     def to_json
       to_hash.to_json
     end
+
   end
 end