protobuf 2.8.13 → 3.0.0.rc1

data/lib/protobuf/field.rb

@@ -19,38 +19,55 @@ require 'protobuf/field/sfixed32_field'
 require 'protobuf/field/sfixed64_field'
 require 'protobuf/field/fixed32_field'
 require 'protobuf/field/fixed64_field'
-require 'protobuf/field/extension_fields'
 
 module Protobuf
   module Field
-    PREDEFINED_TYPES = [
-      ::Protobuf::Field::DoubleField,
-      ::Protobuf::Field::FloatField,
-      ::Protobuf::Field::Int32Field,
-      ::Protobuf::Field::Int64Field,
-      ::Protobuf::Field::Uint32Field,
-      ::Protobuf::Field::Uint64Field,
-      ::Protobuf::Field::Sint32Field,
-      ::Protobuf::Field::Sint64Field,
-      ::Protobuf::Field::Fixed32Field,
-      ::Protobuf::Field::Fixed64Field,
-      ::Protobuf::Field::Sfixed32Field,
-      ::Protobuf::Field::Sfixed64Field,
-      ::Protobuf::Field::StringField,
-      ::Protobuf::Field::BytesField,
-      ::Protobuf::Field::BoolField
-    ].freeze
+
+    PRIMITIVE_FIELD_MAP = {
+      :double   => ::Protobuf::Field::DoubleField,
+      :float    => ::Protobuf::Field::FloatField,
+      :int32    => ::Protobuf::Field::Int32Field,
+      :int64    => ::Protobuf::Field::Int64Field,
+      :uint32   => ::Protobuf::Field::Uint32Field,
+      :uint64   => ::Protobuf::Field::Uint64Field,
+      :sint32   => ::Protobuf::Field::Sint32Field,
+      :sint64   => ::Protobuf::Field::Sint64Field,
+      :fixed32  => ::Protobuf::Field::Fixed32Field,
+      :fixed64  => ::Protobuf::Field::Fixed64Field,
+      :sfixed32 => ::Protobuf::Field::Sfixed32Field,
+      :sfixed64 => ::Protobuf::Field::Sfixed64Field,
+      :string   => ::Protobuf::Field::StringField,
+      :bytes    => ::Protobuf::Field::BytesField,
+      :bool     => ::Protobuf::Field::BoolField
+    }.freeze
 
     def self.build(message_class, rule, type, name, tag, options = {})
-      field_class = type_message_or_enum(type)
-      field_class.new(message_class, rule, type, name, tag, options)
+      field_class(type).new(message_class, rule, field_type(type), name, tag, options)
+    end
+
+    # Returns the field class for primitives,
+    # EnumField for types that inherit from Protobuf::Enum,
+    # and MessageField for types that inherit from Protobuf::Message.
+    #
+    def self.field_class(type)
+      if PRIMITIVE_FIELD_MAP.key?(type)
+        PRIMITIVE_FIELD_MAP[type]
+      elsif type < ::Protobuf::Enum
+        EnumField
+      elsif type < ::Protobuf::Message
+        MessageField
+      elsif type < ::Protobuf::Field::BaseField
+        type
+      else
+        raise ArgumentError, "Invalid field type #{type}"
+      end
     end
 
-    def self.type_message_or_enum(defined_type)
-      return defined_type if ::Protobuf::Field::PREDEFINED_TYPES.include?(defined_type)
-      return EnumField if defined_type < Enum
-      return MessageField if defined_type < Message
-      raise "lost in the wilderness #{defined_type}"
+    # Returns the mapped type for primitives,
+    # otherwise the given type is returned.
+    #
+    def self.field_type(type)
+      PRIMITIVE_FIELD_MAP.fetch(type) { type }
     end
 
   end

data/lib/protobuf/generators/enum_generator.rb

@@ -4,18 +4,29 @@ module Protobuf
   module Generators
     class EnumGenerator < Base
 
+      def allow_alias?
+        descriptor.options.try(:allow_alias!) { false }
+      end
+
       def compile
         run_once(:compile) do
           tags = []
 
           print_class(descriptor.name, :enum) do
+            if allow_alias?
+              puts "set_option :allow_alias"
+              puts
+            end
+
             descriptor.value.each do |enum_value_descriptor|
               tags << enum_value_descriptor.number
               puts build_value(enum_value_descriptor)
             end
           end
 
-          self.class.validate_tags(fully_qualified_type_namespace, tags)
+          unless allow_alias?
+            self.class.validate_tags(fully_qualified_type_namespace, tags)
+          end
         end
       end
 

data/lib/protobuf/generators/field_generator.rb

@@ -94,7 +94,7 @@ module Protobuf
                            type_name = modulize(descriptor.type_name)
                          else
                            type_name = descriptor.type.name.to_s.downcase.sub(/type_/, '')
-                           type_name = "::Protobuf::Field::#{modulize(type_name)}Field"
+                           type_name = ":#{type_name}"
                          end
                        end
       end

data/lib/protobuf/lifecycle.rb

@@ -2,10 +2,9 @@ module Protobuf
   class Lifecycle
     include ::Protobuf::Logger::LogMethods
 
-    def self.register( event_name, &blk )
+    def self.register(event_name, &blk)
       raise "Lifecycle register must have a block" unless block_given?
-
-      event_name = normalized_event_name( event_name )
+      event_name = normalized_event_name(event_name)
 
       if ::Protobuf.print_deprecation_warnings?
         $stderr.puts <<-ERROR
@@ -32,7 +31,7 @@ module Protobuf
       ::ActiveSupport::Notifications.instrument(event_name, args)
     end
 
-    def self.normalized_event_name( event_name )
+    def self.normalized_event_name(event_name)
       return "#{event_name}".downcase
     end
 

data/lib/protobuf/message/fields.rb

@@ -0,0 +1,122 @@
+require 'protobuf/deprecator'
+
+module Protobuf
+  class Message
+    module Fields
+
+      def self.extended(other)
+        other.extend(::Protobuf::Deprecator)
+        other.deprecate_class_method(:get_ext_field_by_name, :get_extension_field)
+        other.deprecate_class_method(:get_ext_field_by_tag, :get_extension_field)
+        other.deprecate_class_method(:get_field_by_name, :get_field)
+        other.deprecate_class_method(:get_field_by_tag, :get_field)
+      end
+
+      ##
+      # Field Definition Methods
+      #
+
+      # Define an optional field.
+      #
+      def optional(type_class, name, tag, options = {})
+        define_field(:optional, type_class, name, tag, options)
+      end
+
+      # Define a repeated field.
+      #
+      def repeated(type_class, name, tag, options = {})
+        define_field(:repeated, type_class, name, tag, options)
+      end
+
+      # Define a required field.
+      #
+      def required(type_class, name, tag, options = {})
+        define_field(:required, type_class, name, tag, options)
+      end
+
+      # Define an extension range.
+      #
+      def extensions(range)
+        extension_ranges << range
+      end
+
+      ##
+      # Field Access Methods
+      #
+
+      def all_fields
+        @all_fields ||= field_store.values.uniq
+      end
+
+      def extension_fields
+        @extension_fields ||= all_fields.select(&:extension?)
+      end
+
+      def extension_ranges
+        @extension_ranges ||= []
+      end
+
+      def extension_tag?(tag)
+        tag.respond_to?(:to_i) && get_extension_field(tag).present?
+      end
+
+      def field_store
+        @field_store ||= {}
+      end
+
+      def fields
+        @fields ||= all_fields.reject(&:extension?)
+      end
+
+      def field_tag?(tag, allow_extension = false)
+        tag.respond_to?(:to_i) && get_field(tag, allow_extension).present?
+      end
+
+      def get_extension_field(name_or_tag)
+        name_or_tag = name_or_tag.to_sym if name_or_tag.respond_to?(:to_sym)
+        field = field_store[name_or_tag]
+        field if field.try(:extension?) { false }
+      end
+
+      def get_field(name_or_tag, allow_extension = false)
+        name_or_tag = name_or_tag.to_sym if name_or_tag.respond_to?(:to_sym)
+        field = field_store[name_or_tag]
+
+        if field && (allow_extension || ! field.extension?)
+          field
+        else
+          nil
+        end
+      end
+
+      def define_field(rule, type_class, field_name, tag, options)
+        raise_if_tag_collision(tag, field_name)
+        raise_if_name_collision(field_name)
+
+        field = ::Protobuf::Field.build(self, rule, type_class, field_name, tag, options)
+        field_store[field_name] = field
+        field_store[tag] = field
+
+        class_eval(<<-RAW_GETTER, __FILE__, __LINE__ + 1)
+          define_method("#{field_name}!") do
+            @values[:#{field_name}]
+          end
+        RAW_GETTER
+      end
+
+      def raise_if_tag_collision(tag, field_name)
+        if get_field(tag, true)
+          raise TagCollisionError, %!Field number #{tag} has already been used in "#{name}" by field "#{field_name}".!
+        end
+      end
+
+      def raise_if_name_collision(field_name)
+        if get_field(field_name, true)
+          raise DuplicateFieldNameError, %!Field name #{field_name} has already been used in "#{name}".!
+        end
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/message/serialization.rb

@@ -0,0 +1,84 @@
+require 'stringio'
+require 'protobuf/decoder'
+require 'protobuf/encoder'
+
+module Protobuf
+  class Message
+    module Serialization
+
+      module ClassMethods
+        def decode(bytes)
+          self.new.decode(bytes)
+        end
+
+        # Create a new object with the given values and return the encoded bytes.
+        def encode(fields = {})
+          self.new(fields).encode
+        end
+      end
+
+      def self.included(other)
+        other.extend(ClassMethods)
+      end
+
+      ##
+      # Instance Methods
+      #
+
+      # Decode the given non-stream bytes into this message.
+      #
+      def decode(bytes)
+        decode_from(::StringIO.new(bytes))
+      end
+
+      # Decode the given stream into this message.
+      #
+      def decode_from(stream)
+        ::Protobuf::Decoder.decode_each_field(stream) do |tag, bytes|
+          set_field_bytes(tag, bytes)
+        end
+
+        self
+      end
+
+      # Encode this message
+      #
+      def encode
+        stream = ::StringIO.new.set_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        encode_to(stream).string
+      end
+
+      # Encode this message to the given stream.
+      #
+      def encode_to(stream)
+        ::Protobuf::Encoder.encode(self, stream)
+      end
+
+      ##
+      # Instance Aliases
+      #
+      alias_method :parse_from_string, :decode
+      alias_method :deserialize, :decode
+      alias_method :parse_from, :decode_from
+      alias_method :deserialize_from, :decode_from
+      alias_method :to_s, :encode
+      alias_method :bytes, :encode
+      alias_method :serialize, :encode
+      alias_method :serialize_to_string, :encode
+      alias_method :serialize_to, :encode_to
+
+      private
+
+      def field_must_be_serialized?(field)
+        field.required? || ! @values[field.name].nil?
+      end
+
+      def set_field_bytes(tag, bytes)
+        field = self.class.get_field(tag, true)
+        field.set(self, bytes) if field
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/message.rb

@@ -1,147 +1,33 @@
-require 'stringio'
-require 'set'
 require 'protobuf/field'
 require 'protobuf/enum'
 require 'protobuf/exceptions'
-require 'protobuf/message/decoder'
+require 'protobuf/message/fields'
+require 'protobuf/message/serialization'
 
 module Protobuf
   class Message
 
     ##
-    # Class Methods
+    # Includes & Extends
     #
-    def self.all_fields
-      @all_fields ||= begin
-                        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
-
-    def self.decode(bytes)
-      self.new.decode(bytes)
-    end
-
-    # Define a field. Don't use this method directly.
-    def self.define_field(rule, type, fname, tag, options)
-      field_array = options[:extension] ? extension_fields : fields
-      field_name_hash = options[:extension] ? extension_field_name_to_tag : field_name_to_tag
-
-      previous_tag_field = get_field_by_tag(tag) || get_ext_field_by_tag(tag)
-      if previous_tag_field
-        raise TagCollisionError, %!Field number #{tag} has already been used in "#{self.name}" by field "#{fname}".!
-      end
-
-      previous_name_field = get_field_by_name(fname) || get_ext_field_by_name(fname)
-      if previous_name_field
-        raise DuplicateFieldNameError, %!Field name #{fname} has already been used in "#{self.name}".!
-      end
-
-      field_definition = ::Protobuf::Field.build(self, rule, type, fname, tag, options)
-      field_name_hash[fname] = tag
-      field_array[tag] = field_definition
-
-      define_method("#{fname}!") do
-        @values[fname]
-      end
-    end
-
-    # Create a new object with the given values and return the encoded bytes.
-    def self.encode(values = {})
-      self.new(values).encode
-    end
-
-    # Reserve field numbers for extensions. Don't use this method directly.
-    def self.extensions(range)
-      extension_fields.add_range(range)
-    end
-
-    def self.extension_field_name_to_tag
-      @extension_fields_by_name ||= {}
-    end
-
-    # An extension field object.
-    def self.extension_fields
-      @extension_fields ||= ::Protobuf::Field::ExtensionFields.new
-    end
-
-    def self.extension_tag?(tag)
-      extension_fields.include_tag?(tag)
-    end
-
-    # A collection of field object.
-    def self.fields
-      @fields ||= []
-    end
-
-    def self.field_name_to_tag
-      @field_name_to_tag ||= {}
-    end
-
-    def self.get_ext_field_by_name(name)
-      tag = extension_field_name_to_tag[name.to_sym]
-      extension_fields[tag] unless tag.nil?
-    end
-
-    def self.get_ext_field_by_tag(tag)
-      extension_fields[tag]
-    end
-
-    # Find a field object by +name+.
-    def self.get_field_by_name(name)
-      name = name.to_sym if name.respond_to?(:to_sym)
-      tag = field_name_to_tag[name]
-      fields[tag] unless tag.nil?
-    end
-
-    # Find a field object by +tag+ number.
-    def self.get_field_by_tag(tag)
-      fields[tag]
-    rescue TypeError
-      tag = tag.nil? ? 'nil' : tag.to_s
-      raise FieldNotDefinedError.new("Tag '#{tag}' does not reference a message field for '#{self.name}'")
-    end
-
-    # Define a optional field. Don't use this method directly.
-    def self.optional(type, name, tag, options = {})
-      define_field(:optional, type, name, tag, options)
-    end
-
-    # Define a repeated field. Don't use this method directly.
-    def self.repeated(type, name, tag, options = {})
-      define_field(:repeated, type, name, tag, options)
-    end
 
-    # Define a required field. Don't use this method directly.
-    def self.required(type, name, tag, options = {})
-      define_field(:required, type, name, tag, options)
-    end
-
-    # Backported fix to prevent recursive to_json issues.
-    def self.to_json
-      name
-    end
+    extend ::Protobuf::Message::Fields
+    include ::Protobuf::Message::Serialization
 
     ##
     # Constructor
     #
-    def initialize(values = {})
+    def initialize(fields = {})
       @values = {}
-      values = values.to_hash
-      values.each { |name, val| self[name] = val unless val.nil? }
+
+      fields.to_hash.each_pair do |name, value|
+        self[name] = value unless value.nil?
+      end
     end
 
     ##
     # Public Instance Methods
     #
-    def all_fields
-      self.class.all_fields
-    end
 
     def clear!
       @values.delete_if do |_, value|
@@ -159,95 +45,33 @@ module Protobuf
       copy_to(super, :clone)
     end
 
-    # Decode the given string bytes into this object.
-    def decode(string)
-      decode_from(::StringIO.new(string))
-    end
-
-    # Decode the given stream into this object.
-    def decode_from(stream)
-      Decoder.decode(stream, self)
-    end
-
     def dup
       copy_to(super, :dup)
     end
 
-    # Iterate over a field collection.
-    #   message.each_field do |field_object, value|
-    #     # do something
-    #   end
+    # Iterate over every field, invoking the given block
+    #
     def each_field
-      all_fields.each do |field|
+      self.class.all_fields.each do |field|
         value = __send__(field.name)
         yield(field, value)
       end
     end
 
     def each_field_for_serialization
-      all_fields.each do |field|
-        next unless __field_must_be_serialized__?(field)
+      self.class.all_fields.each do |field|
+        next unless field_must_be_serialized?(field)
 
         value = @values[field.name]
 
         if value.nil?
-          # Only way you can get here is if you are required and nil
-          raise ::Protobuf::SerializationError, "#{field.name} is required on #{field.message_class}"
+          raise ::Protobuf::SerializationError, "Required field #{self.name}##{field.name} does not have a value."
         else
           yield(field, value)
         end
       end
     end
 
-    def encode
-      stream = ""
-
-      each_field_for_serialization do |field, value|
-        if field.repeated?
-          if field.packed?
-            key = (field.tag << 3) | ::Protobuf::WireType::LENGTH_DELIMITED
-            packed_value = value.map { |val| field.encode(val) }.join
-            stream << ::Protobuf::Field::VarintField.encode(key)
-            stream << ::Protobuf::Field::VarintField.encode(packed_value.size)
-            stream << packed_value
-          else
-            value.each { |val| write_pair(stream, field, val) }
-          end
-        else
-          write_pair(stream, field, value)
-        end
-      end
-
-      return stream
-    end
-
-    # Returns extension fields. See Message#fields method.
-    def extension_fields
-      self.class.extension_fields
-    end
-
-    def fields
-      self.class.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
-
-    # Returns field object or +nil+.
-    def get_field_by_name(name)
-      self.class.get_field_by_name(name)
-    end
-
-    # Returns field object or +nil+.
-    def get_field_by_tag(tag)
-      self.class.get_field_by_tag(tag)
-    end
-
     def has_field?(name)
       @values.has_key?(name)
     end
@@ -257,17 +81,12 @@ module Protobuf
     end
 
     def respond_to_has?(key)
-      self.respond_to?(key) && self.has_field?(key)
+      respond_to?(key) && has_field?(key)
     end
 
     def respond_to_has_and_present?(key)
-      self.respond_to_has?(key) &&
-        (self.__send__(key).present? || [true, false].include?(self.__send__(key)))
-    end
-
-    def set_field(tag, bytes)
-      field = (get_field_by_tag(tag) || get_ext_field_by_tag(tag))
-      field.set(self, bytes) if field
+      respond_to_has?(key) &&
+        (__send__(key).present? || [true, false].include?(__send__(key)))
     end
 
     # Return a hash-representation of the given fields for this message type.
@@ -300,13 +119,13 @@ module Protobuf
     end
 
     def [](name)
-      if field = get_field_by_name(name) || get_ext_field_by_name(name)
+      if field = self.class.get_field(name, true)
         __send__(field.name)
       end
     end
 
     def []=(name, value)
-      if field = get_field_by_name(name) || get_ext_field_by_name(name)
+      if field = self.class.get_field(name, true)
         __send__(field.setter_method_name, value)
       end
     end
@@ -314,14 +133,6 @@ module Protobuf
     ##
     # Instance Aliases
     #
-    alias_method :parse_from_string, :decode
-    alias_method :deserialize, :decode
-    alias_method :parse_from, :decode_from
-    alias_method :deserialize_from, :decode_from
-    alias_method :to_s, :encode
-    alias_method :bytes, :encode
-    alias_method :serialize, :encode
-    alias_method :serialize_to_string, :encode
     alias_method :to_hash_value, :to_hash
     alias_method :to_proto_hash, :to_hash
     alias_method :responds_to_has?, :respond_to_has?
@@ -358,16 +169,5 @@ module Protobuf
       object
     end
 
-    def __field_must_be_serialized__?(field)
-      field.required? || !@values[field.name].nil?
-    end
-
-    # Encode key and value, and write to +stream+.
-    def write_pair(stream, field, value)
-      key = (field.tag << 3) | field.wire_type
-      stream << ::Protobuf::Field::VarintField.encode(key)
-      stream << field.encode(value)
-    end
-
   end
 end

data/lib/protobuf/optionable.rb

@@ -0,0 +1,23 @@
+require 'active_support/concern'
+
+module Protobuf
+  module Optionable
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+      def get_option(name)
+        @_optionable_options.try(:[], name)
+      end
+
+      def set_option(name, value = true)
+        @_optionable_options ||= {}
+        @_optionable_options[name] = value
+      end
+    end
+
+    def get_option(name)
+      self.class.get_option(name)
+    end
+
+  end
+end