protobuf-core 3.5.0

data/lib/protobuf/logging.rb

@@ -0,0 +1,39 @@
+require 'logger'
+
+module Protobuf
+  module Logging
+    def self.initialize_logger(log_target = $stdout, log_level = ::Logger::INFO)
+      @logger = Logger.new(log_target)
+      @logger.level = log_level
+      @logger
+    end
+
+    def self.logger
+      defined?(@logger) ? @logger : initialize_logger
+    end
+
+    class << self
+      attr_writer :logger
+    end
+
+    def logger
+      ::Protobuf::Logging.logger
+    end
+
+    def log_exception(ex)
+      logger.error { ex.message }
+      logger.error { ex.backtrace[0..5].join("\n") }
+      logger.debug { ex.backtrace.join("\n") }
+    end
+
+    def log_signature
+      @_log_signature ||= "[#{self.class == Class ? name : self.class.name}]"
+    end
+
+    def sign_message(message)
+      "#{log_signature} #{message}"
+    end
+  end
+end
+
+# Inspired by [mperham](https://github.com/mperham/sidekiq)

data/lib/protobuf/message.rb

@@ -0,0 +1,193 @@
+require 'protobuf/field'
+require 'protobuf/enum'
+require 'protobuf/exceptions'
+require 'protobuf/message/fields'
+require 'protobuf/message/serialization'
+
+module Protobuf
+  class Message
+
+    ##
+    # Includes & Extends
+    #
+
+    extend ::Protobuf::Message::Fields
+    include ::Protobuf::Message::Serialization
+
+    ##
+    # Class Methods
+    #
+
+    def self.to_json
+      name
+    end
+
+    ##
+    # Constructor
+    #
+
+    def initialize(fields = {})
+      @values = {}
+      fields.to_hash.each_pair do |name, value|
+        self[name] = value
+      end
+
+      yield self if block_given?
+    end
+
+    ##
+    # Public Instance Methods
+    #
+
+    def clear!
+      @values.delete_if do |_, value|
+        if value.is_a?(::Protobuf::Field::FieldArray)
+          value.clear
+          false
+        else
+          true
+        end
+      end
+      self
+    end
+
+    def clone
+      copy_to(super, :clone)
+    end
+
+    def dup
+      copy_to(super, :dup)
+    end
+
+    # Iterate over every field, invoking the given block
+    #
+    def each_field
+      self.class.all_fields.each do |field|
+        value = __send__(field.getter)
+        yield(field, value)
+      end
+    end
+
+    def each_field_for_serialization
+      self.class.all_fields.each do |field|
+        next unless field_must_be_serialized?(field)
+
+        value = @values[field.getter]
+
+        if value.nil?
+          fail ::Protobuf::SerializationError, "Required field #{self.class.name}##{field.name} does not have a value."
+        else
+          yield(field, value)
+        end
+      end
+    end
+
+    def field?(name)
+      @values.key?(name)
+    end
+    ::Protobuf.deprecator.define_deprecated_methods(self, :has_field? => :field?)
+
+    def inspect
+      attrs = self.class.fields.map do |field|
+        [field.name, send(field.name).inspect].join('=')
+      end.join(' ')
+
+      "#<#{self.class} #{attrs}>"
+    end
+
+    def respond_to_has?(key)
+      respond_to?(key) && field?(key)
+    end
+
+    def respond_to_has_and_present?(key)
+      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.
+    def to_hash
+      result = {}
+
+      @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
+    end
+
+    def to_json(options = {})
+      to_hash.to_json(options)
+    end
+
+    def to_proto
+      self
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      each_field do |field, value|
+        return false unless value == other.__send__(field.name)
+      end
+      true
+    end
+
+    def [](name)
+      if (field = self.class.get_field(name, true))
+        __send__(field.getter)
+      end
+    end
+
+    def []=(name, value)
+      if (field = self.class.get_field(name, true))
+        __send__(field.setter, value) unless value.nil?
+      else
+        unless ::Protobuf.ignore_unknown_fields?
+          fail ::Protobuf::FieldNotDefinedError, name
+        end
+      end
+    end
+
+    ##
+    # Instance Aliases
+    #
+    alias_method :to_hash_value, :to_hash
+    alias_method :to_proto_hash, :to_hash
+    alias_method :responds_to_has?, :respond_to_has?
+    alias_method :respond_to_and_has?, :respond_to_has?
+    alias_method :responds_to_and_has?, :respond_to_has?
+    alias_method :respond_to_has_present?, :respond_to_has_and_present?
+    alias_method :respond_to_and_has_present?, :respond_to_has_and_present?
+    alias_method :respond_to_and_has_and_present?, :respond_to_has_and_present?
+    alias_method :responds_to_has_present?, :respond_to_has_and_present?
+    alias_method :responds_to_and_has_present?, :respond_to_has_and_present?
+    alias_method :responds_to_and_has_and_present?, :respond_to_has_and_present?
+
+    ##
+    # Private Instance Methods
+    #
+
+    private
+
+    def copy_to(object, method)
+      duplicate = proc do |obj|
+        case obj
+        when Message, String then obj.__send__(method)
+        else                      obj
+        end
+      end
+
+      object.__send__(:initialize)
+      @values.each do |name, value|
+        if value.is_a?(::Protobuf::Field::FieldArray)
+          object.__send__(name).replace(value.map { |v| duplicate.call(v) })
+        else
+          object.__send__("#{name}=", duplicate.call(value))
+        end
+      end
+      object
+    end
+
+  end
+end

data/lib/protobuf/message/fields.rb

@@ -0,0 +1,133 @@
+module Protobuf
+  class Message
+    module Fields
+
+      def self.extended(other)
+        other.extend(ClassMethods)
+        ::Protobuf.deprecator.define_deprecated_methods(
+          other.singleton_class,
+          :get_ext_field_by_name => :get_extension_field,
+          :get_ext_field_by_tag => :get_extension_field,
+          :get_field_by_name => :get_field,
+          :get_field_by_tag => :get_field,
+        )
+
+        def inherited(subclass)
+          inherit_fields!(subclass)
+        end
+      end
+
+      module ClassMethods
+
+        ##
+        # 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.sort_by(&:tag)
+        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
+
+          define_method("#{field_name}!") do
+            @values[field_name]
+          end
+        end
+
+        def raise_if_tag_collision(tag, field_name)
+          if get_field(tag, true)
+            fail 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)
+            fail DuplicateFieldNameError, %(Field name #{field_name} has already been used in "#{name}".)
+          end
+        end
+
+        def inherit_fields!(subclass)
+          instance_variables.each do |iv|
+            subclass.instance_variable_set(iv, instance_variable_get(iv))
+          end
+        end
+        private :inherit_fields!
+
+      end
+    end
+  end
+end

data/lib/protobuf/message/serialization.rb

@@ -0,0 +1,89 @@
+require 'stringio'
+require 'protobuf/decoder'
+require 'protobuf/encoder'
+
+module Protobuf
+  class Message
+    module Serialization
+
+      module ClassMethods
+        def decode(bytes)
+          new.decode(bytes)
+        end
+
+        def decode_from(stream)
+          new.decode_from(stream)
+        end
+
+        # Create a new object with the given values and return the encoded bytes.
+        def encode(fields = {})
+          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
+        stream.set_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        encode_to(stream)
+        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