protobuffy 3.6.0 → 4.0.0

data/lib/protobuf/encoder.rb

@@ -1,62 +1,22 @@
 module Protobuf
   class Encoder
-
-    def self.encode(stream, message)
-      new(stream, message).encode
-    end
-
-    attr_reader :message, :stream
-
-    def initialize(message, stream)
-      unless message.respond_to?(:each_field_for_serialization)
-        raise ArgumentError, "Message instance must respond to :each_field_for_serialization"
-      end
-
-      @message = message
-      @stream = stream
-    end
-
-    def encode
+    def self.encode(message, stream)
       message.each_field_for_serialization do |field, value|
-        encode_field(field, value)
+        if field.repeated?
+          if field.packed?
+            packed_value = value.map { |val| field.encode(val) }.join
+            stream << "#{field.tag_encoded}#{::Protobuf::Field::VarintField.encode(packed_value.size)}#{packed_value}"
+          else
+            value.each do |val|
+              stream << "#{field.tag_encoded}#{field.encode(val)}"
+            end
+          end
+        else
+          stream << "#{field.tag_encoded}#{field.encode(value)}"
+        end
       end
 
       stream
     end
-
-    private
-
-    def encode_field(field, value)
-      if field.repeated?
-        encode_repeated_field(field, value)
-      else
-        write_pair(field, value)
-      end
-    end
-
-    def encode_packed_field(field, value)
-      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
-    end
-
-    def encode_repeated_field(field, value)
-      if field.packed?
-        encode_packed_field(field, value)
-      else
-        value.each { |val| write_pair(field, val) }
-      end
-    end
-
-    # Encode key and value, and write to +stream+.
-    def write_pair(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/enum.rb

@@ -1,38 +1,19 @@
 require 'delegate'
-require 'protobuf/optionable'
-require 'protobuf/deprecator'
 
 ##
 # Adding extension to Numeric until
 # we can get people to stop calling #value
 # on Enum instances.
 #
-class Numeric
-  unless method_defined?(:value)
-    def value
-      $stderr.puts <<-DEPRECATION
-[DEPRECATED] Enum#value is deprecated and will be removed in the next release.
-              Use Enum#to_i instead.
-DEPRECATION
-      self
-    end
-  end
-end
+::Protobuf.deprecator.define_deprecated_methods(Numeric, :value => :to_int)
 
 module Protobuf
   class Enum < SimpleDelegator
-
-    ##
-    # Deprecations
-    #
-
-    extend ::Protobuf::Deprecator
-
     # Public: Allows setting Options on the Enum class.
-    include ::Protobuf::Optionable
+    ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::EnumOptions }
 
     def self.aliases_allowed?
-      self.get_option(:allow_alias)
+      get_option(:allow_alias)
     end
 
     # Public: Get all integer tags defined by this enum.
@@ -51,7 +32,7 @@ module Protobuf
     # Returns an array of unique integers.
     #
     def self.all_tags
-      @all_tags ||= self.enums.map(&:to_i).uniq
+      @all_tags ||= enums.map(&:to_i).uniq
     end
 
     # Internal: DSL method to create a new Enum. The given name will
@@ -70,16 +51,28 @@ module Protobuf
     # Returns nothing.
     #
     def self.define(name, tag)
-      enum = self.new(self, name, tag)
+      enum = new(self, name, tag)
       @enums ||= []
       @enums << enum
+      # defining a new field for the enum will cause cached @values and @mapped_enums
+      # to be incorrect; reset them
+      @mapped_enums = @values = nil
       const_set(name, enum)
     end
 
+    # Internal: A mapping of enum number -> enums defined
+    # used for speeding up our internal enum methods.
+    def self.mapped_enums
+      @mapped_enums ||= enums.each_with_object({}) do |enum, hash|
+        list = hash[enum.to_i] ||= []
+        list << enum
+      end
+    end
+
     # Public: All defined enums.
     #
-    def self.enums
-      @enums
+    class << self
+      attr_reader :enums
     end
 
     # Public: Get an array of Enum objects with the given tag.
@@ -101,9 +94,7 @@ module Protobuf
     # Returns an array with zero or more Enum objects or nil.
     #
     def self.enums_for_tag(tag)
-      self.enums.select { |enum|
-        enum.to_i == tag.to_i
-      }
+      tag && mapped_enums[tag.to_i] || []
     end
 
     # Public: Get the Enum associated with the given name.
@@ -125,7 +116,7 @@ module Protobuf
     # Returns the Enum object with the given name or nil.
     #
     def self.enum_for_name(name)
-      self.const_get(name)
+      const_get(name)
     rescue ::NameError
       nil
     end
@@ -138,7 +129,7 @@ module Protobuf
     #   Enums, the first enum defined will be returned.
     #
     def self.enum_for_tag(tag)
-      self.enums_for_tag(tag).first
+      tag && (mapped_enums[tag.to_i] || []).first
     end
 
     # Public: Get an Enum by a variety of type-checking mechanisms.
@@ -162,12 +153,14 @@ module Protobuf
     # Returns an Enum object or nil.
     #
     def self.fetch(candidate)
+      return enum_for_tag(candidate) if candidate.is_a?(::Integer)
+
       case candidate
-      when self then
+      when self
         candidate
-      when ::Numeric then
+      when ::Numeric
         enum_for_tag(candidate.to_i)
-      when ::String, ::Symbol then
+      when ::String, ::Symbol
         enum_for_name(candidate)
       else
         nil
@@ -206,7 +199,7 @@ module Protobuf
     #   the first defined name will be returned.
     #
     def self.name_for_tag(tag)
-      self.enum_for_tag(tag).try(:name)
+      enum_for_tag(tag).try(:name)
     end
 
     # Public: Check if the given tag is defined by this Enum.
@@ -216,37 +209,43 @@ module Protobuf
     # Returns a boolean.
     #
     def self.valid_tag?(tag)
-      tag.respond_to?(:to_i) && self.all_tags.include?(tag.to_i)
+      tag.respond_to?(:to_i) && mapped_enums.key?(tag.to_i)
     end
 
     # Public: [DEPRECATED] Return a hash of Enum objects keyed
     # by their :name.
     #
     def self.values
-      self.warn_deprecated(:values, :enums)
-
-      @values ||= begin
-                    self.enums.inject({}) do |hash, enum|
-                      hash[enum.name] = enum
-                      hash
-                    end
-                  end
+      @values ||= enums.each_with_object({}) do |enum, hash|
+        hash[enum.name] = enum
+      end
     end
 
     ##
     # Class Deprecations
     #
+    class << self
+      ::Protobuf.deprecator.define_deprecated_methods(
+        self,
+        :enum_by_value => :enum_for_tag,
+        :name_by_value => :name_for_tag,
+        :get_name_by_tag => :name_for_tag,
+        :value_by_name => :enum_for_name
+      )
 
-    deprecate_class_method :enum_by_value,   :enum_for_tag
-    deprecate_class_method :name_by_value,   :name_for_tag
-    deprecate_class_method :get_name_by_tag, :name_for_tag
-    deprecate_class_method :value_by_name,   :enum_for_name
-
+      ::Protobuf.deprecator.deprecate_methods(self, :values => :enums)
+    end
 
     ##
     # Attributes
     #
 
+    private
+
+    attr_writer :parent_class, :name, :tag
+
+    public
+
     attr_reader :parent_class, :name, :tag
 
     ##
@@ -254,10 +253,10 @@ module Protobuf
     #
 
     def initialize(parent_class, name, tag)
-      @parent_class = parent_class
-      @name = name
-      @tag = tag
-      super(@tag)
+      self.parent_class = parent_class
+      self.name = name
+      self.tag = tag
+      super(tag)
     end
 
     # Overriding the class so ActiveRecord/Arel visitor will visit the enum as a Fixnum
@@ -280,12 +279,12 @@ module Protobuf
 
     def to_s(format = :tag)
       case format
-      when :tag then
-        self.to_i.to_s
-      when :name then
+      when :tag
+        to_i.to_s
+      when :name
         name.to_s
       else
-        self.to_i.to_s
+        to_i.to_s
       end
     end
 
@@ -305,15 +304,11 @@ module Protobuf
       end
     end
 
-    def value
-      parent_class.warn_deprecated(:value, :to_i)
-      to_i
-    end
+    ::Protobuf.deprecator.define_deprecated_methods(self, :value => :to_i)
 
     ##
     # Instance Aliases
     #
-    alias_method :to_hash_value, :to_i
+    alias :to_hash_value to_i
   end
 end
-

data/lib/protobuf/field.rb

@@ -38,11 +38,11 @@ module Protobuf
       :sfixed64 => ::Protobuf::Field::Sfixed64Field,
       :string   => ::Protobuf::Field::StringField,
       :bytes    => ::Protobuf::Field::BytesField,
-      :bool     => ::Protobuf::Field::BoolField
+      :bool     => ::Protobuf::Field::BoolField,
     }.freeze
 
-    def self.build(message_class, rule, type, name, tag, options = {})
-      field_class(type).new(message_class, rule, field_type(type), name, tag, options)
+    def self.build(message_class, rule, type, name, tag, simple_name, options = {})
+      field_class(type).new(message_class, rule, field_type(type), name, tag, simple_name, options)
     end
 
     # Returns the field class for primitives,
@@ -59,7 +59,7 @@ module Protobuf
       elsif type < ::Protobuf::Field::BaseField
         type
       else
-        raise ArgumentError, "Invalid field type #{type}"
+        fail ArgumentError, "Invalid field type #{type}"
       end
     end
 

data/lib/protobuf/field/base_field.rb

@@ -1,9 +1,10 @@
-require 'protobuf/wire_type'
+require 'active_support/core_ext/hash/slice'
 require 'protobuf/field/field_array'
-
 module Protobuf
   module Field
     class BaseField
+      include ::Protobuf::Logging
+      ::Protobuf::Optionable.inject(self, false) { ::Google::Protobuf::FieldOptions }
 
       ##
       # Constants
@@ -12,17 +13,13 @@ module Protobuf
       PACKED_TYPES = [
         ::Protobuf::WireType::VARINT,
         ::Protobuf::WireType::FIXED32,
-        ::Protobuf::WireType::FIXED64
+        ::Protobuf::WireType::FIXED64,
       ].freeze
 
       ##
       # Attributes
       #
-
-      attr_reader :default, :default_value, :deprecated, :extension,
-                  :getter_method_name, :message_class, :name, :optional,
-                  :packed, :repeated, :required, :rule, :setter_method_name,
-                  :tag, :type_class
+      attr_reader :message_class, :name, :fully_qualified_name, :options, :rule, :tag, :type_class
 
       ##
       # Class Methods
@@ -36,123 +33,136 @@ module Protobuf
       # Constructor
       #
 
-      def initialize(message_class, rule, type_class, name, tag, options)
-        @message_class, @rule, @type_class, @name, @tag = \
-          message_class, rule, type_class, name, tag
-
-        set_rule_predicates
-
-        @getter_method_name = name
-        @setter_method_name = "#{name}="
-        @default   = options.delete(:default)
-        @extension = options.delete(:extension)
-        @packed    = repeated? && options.delete(:packed)
-        @deprecated = options.delete(:deprecated)
+      def initialize(message_class, rule, type_class, fully_qualified_name, tag, simple_name, options)
+        @message_class = message_class
+        @name = simple_name || fully_qualified_name
+        @fully_qualified_name = fully_qualified_name
+        @rule          = rule
+        @tag           = tag
+        @type_class    = type_class
+        # Populate the option hash with all the original default field options, for backwards compatibility.
+        # However, both default and custom options should ideally be accessed through the Optionable .{get,get!}_option functions.
+        @options = options.slice(:ctype, :packed, :deprecated, :lazy, :jstype, :weak, :uninterpreted_option, :default, :extension)
+        options.each do |option_name, value|
+          set_option(option_name, value)
+        end
 
-        set_default_value
-        warn_excess_options(options) unless options.empty?
         validate_packed_field if packed?
-        define_accessor
+        define_accessor(simple_name, fully_qualified_name) if simple_name
+        tag_encoded
       end
 
       ##
       # Public Instance Methods
       #
 
-      def acceptable?(value)
+      def acceptable?(_value)
         true
       end
 
-      def enum?
-        false
+      def coerce!(value)
+        value
       end
 
-      def message?
-        false
+      def decode(_bytes)
+        fail NotImplementedError, "#{self.class.name}##{__method__}"
       end
 
-      # Decode +bytes+ and pass to +message_instance+.
-      def set(message_instance, bytes)
-        if packed?
-          array = message_instance.__send__(getter_method_name)
-          method = \
-            case wire_type
-            when ::Protobuf::WireType::FIXED32 then :read_fixed32
-            when ::Protobuf::WireType::FIXED64 then :read_fixed64
-            when ::Protobuf::WireType::VARINT  then :read_varint
-            end
-          stream = StringIO.new(bytes)
-
-          until stream.eof?
-            array << decode(::Protobuf::Decoder.__send__(method, stream))
-          end
-        else
-          value = decode(bytes)
-          if repeated?
-            message_instance.__send__(getter_method_name) << value
-          else
-            message_instance.__send__(setter_method_name, value)
-          end
-        end
+      def default
+        options[:default]
+      end
+
+      def default_value
+        @default_value ||= if optional? || required?
+                             typed_default_value
+                           elsif repeated?
+                             ::Protobuf::Field::FieldArray.new(self).freeze
+                           else
+                             fail "Unknown field label -- something went very wrong"
+                           end
       end
 
-      # Decode +bytes+ and return a field value.
-      def decode(bytes)
-        raise NotImplementedError, "#{self.class.name}\#decode"
+      def deprecated?
+        options.key?(:deprecated)
       end
 
-      # Encode +value+ and return a byte string.
-      def encode(value)
-        raise NotImplementedError, "#{self.class.name}\#encode"
+      def encode(_value)
+        fail NotImplementedError, "#{self.class.name}##{__method__}"
       end
 
       def extension?
-        !! extension
+        options.key?(:extension)
+      end
+
+      def enum?
+        false
+      end
+
+      def message?
+        false
+      end
+
+      def optional?
+        rule == :optional
+      end
+
+      def packed?
+        repeated? && options.key?(:packed)
       end
 
-      # Is this a repeated field?
       def repeated?
-        !! repeated
+        rule == :repeated
       end
 
-      # Is this a repeated message field?
       def repeated_message?
         repeated? && message?
       end
 
-      # Is this a required field?
       def required?
-        !! required
+        rule == :required
       end
 
-      # Is this a optional field?
-      def optional?
-        !! optional
-      end
-
-      # Is this a deprecated field?
-      def deprecated?
-        !! deprecated
+      # FIXME: need to cleanup (rename) this warthog of a method.
+      def set(message_instance, bytes)
+        return message_instance[name] = decode(bytes) unless repeated?
+        return message_instance[name] << decode(bytes) unless packed?
+
+        array = message_instance[name]
+        stream = StringIO.new(bytes)
+
+        if wire_type == ::Protobuf::WireType::VARINT
+          array << decode(Varint.decode(stream)) until stream.eof?
+        elsif wire_type == ::Protobuf::WireType::FIXED64
+          array << decode(stream.read(8)) until stream.eof?
+        elsif wire_type == ::Protobuf::WireType::FIXED32
+          array << decode(stream.read(4)) until stream.eof?
+        end
       end
 
-      # Is this a packed repeated field?
-      def packed?
-        !! packed
+      def tag_encoded
+        @tag_encoded ||= begin
+                           case
+                           when repeated? && packed?
+                             ::Protobuf::Field::VarintField.encode((tag << 3) | ::Protobuf::WireType::LENGTH_DELIMITED)
+                           else
+                             ::Protobuf::Field::VarintField.encode((tag << 3) | wire_type)
+                           end
+                         end
       end
 
+      # FIXME: add packed, deprecated, extension options to to_s output
       def to_s
         "#{rule} #{type_class} #{name} = #{tag} #{default ? "[default=#{default.inspect}]" : ''}"
       end
 
-      def type
-        $stderr.puts("[DEPRECATED] #{self.class.name}#type usage is deprecated.\nPlease use #type_class instead.")
-        type_class
+      ::Protobuf.deprecator.define_deprecated_methods(self, :type => :type_class)
+
+      def wire_type
+        ::Protobuf::WireType::VARINT
       end
 
-      def warn_if_deprecated
-        if ::Protobuf.print_deprecation_warnings? && deprecated?
-          $stderr.puts("[WARNING] #{message_class.name}##{name} field usage is deprecated.")
-        end
+      def fully_qualified_name_only!
+        @name = @fully_qualified_name
       end
 
       private
@@ -161,99 +171,23 @@ module Protobuf
       # Private Instance Methods
       #
 
-      def define_accessor
-        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
-            field.warn_if_deprecated
-            @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
-
-            if val.is_a?(Array)
-              val = val.dup
-              val.compact!
-            else
-              raise TypeError, <<-TYPE_ERROR
-                Expected repeated value of type '#{field.type_class}'
-                Got '#{val.class}' for repeated protobuf field #{field.name}
-              TYPE_ERROR
-            end
-
-            if val.nil? || (val.respond_to?(:empty?) && val.empty?)
-              @values.delete(field.name)
-            else
-              @values[field.name] ||= ::Protobuf::Field::FieldArray.new(field)
-              @values[field.name].replace(val)
-            end
-          end
-        end
-      end
-
-      def define_getter
-        field = self
+      def define_accessor(simple_field_name, fully_qualified_field_name)
         message_class.class_eval do
-          define_method(field.getter_method_name) do
-            field.warn_if_deprecated
-            @values.fetch(field.name, field.default_value)
+          define_method("#{simple_field_name}!") do
+            @values[fully_qualified_field_name] if field?(fully_qualified_field_name)
           end
         end
-      end
 
-      def define_setter
-        field = self
         message_class.class_eval do
-          define_method(field.setter_method_name) do |val|
-            field.warn_if_deprecated
-
-            if val.nil? || (val.respond_to?(:empty?) && val.empty?)
-              @values.delete(field.name)
-            elsif field.acceptable?(val)
-              @values[field.name] = val
-            else
-              raise TypeError, "Unacceptable value #{val} for field #{field.name} of type #{field.type_class}"
-            end
-          end
+          define_method(simple_field_name) { self[fully_qualified_field_name] }
+          define_method("#{simple_field_name}=") { |v| set_field(fully_qualified_field_name, v, false) }
         end
-      end
 
-      def set_default_value
-        @default_value = case
-                         when repeated? then ::Protobuf::Field::FieldArray.new(self).freeze
-                         when required? then nil
-                         when optional? then typed_default_value
-                         end
-      end
+        return unless deprecated?
 
-      def set_rule_predicates
-        case rule
-        when :repeated then
-          @required = @optional = false
-          @repeated = true
-        when :required then
-          @repeated = @optional = false
-          @required = true
-        when :optional then
-          @repeated = @required = false
-          @optional = true
-        end
+        ::Protobuf.field_deprecator.deprecate_method(message_class, simple_field_name)
+        ::Protobuf.field_deprecator.deprecate_method(message_class, "#{simple_field_name}!")
+        ::Protobuf.field_deprecator.deprecate_method(message_class, "#{simple_field_name}=")
       end
 
       def typed_default_value
@@ -266,15 +200,9 @@ module Protobuf
 
       def validate_packed_field
         if packed? && ! ::Protobuf::Field::BaseField::PACKED_TYPES.include?(wire_type)
-          raise "Can't use packed encoding for '#{type_class}' type"
+          fail "Can't use packed encoding for '#{type_class}' type"
         end
       end
-
-      def warn_excess_options(options)
-        warn "WARNING: Invalid options: #{options.inspect} (in #{message_class.name}##{name})"
-      end
-
     end
   end
 end
-