prepor-protobuf 3.5.0

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

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

data/lib/protobuf/rpc/buffer.rb

@@ -0,0 +1,77 @@
+module Protobuf
+  module Rpc
+    class Buffer
+
+      attr_accessor :mode, :data, :size
+
+      MODES = [:read, :write]
+
+      # constantize this so we don't re-initialize the regex every time we need it
+      SIZE_REGEX = /^\d+-/
+
+      def initialize(mode = :read)
+        @flush = false
+        @data = ""
+        @size = 0
+        self.mode = mode
+      end
+
+      def mode=(mode)
+        if MODES.include?(mode)
+          @mode = mode
+        else
+          @mode = :read
+        end
+      end
+
+      def write(force_mode = true)
+        if force_mode && reading?
+          self.mode = :write
+        elsif !force_mode && reading?
+          fail 'You chose to write the buffer when in read mode'
+        end
+
+        @size = @data.length
+        "#{@size}-#{@data}"
+      end
+
+      def <<(data)
+        @data << data
+        if reading?
+          get_data_size
+          check_for_flush
+        end
+      end
+
+      def set_data(data) # rubocop:disable Style/AccessorMethodName
+        @data = data.to_s
+        @size = @data.size
+      end
+
+      def reading?
+        mode == :read
+      end
+
+      def writing?
+        mode == :write
+      end
+
+      def flushed?
+        @flush
+      end
+
+      def get_data_size # rubocop:disable Style/AccessorMethodName
+        if @size == 0 || @data.match(SIZE_REGEX)
+          sliced_size = @data.slice!(SIZE_REGEX)
+          @size = sliced_size.gsub('-', '').to_i unless sliced_size.nil?
+        end
+      end
+
+      private
+
+      def check_for_flush
+        @flush = true if !@size.nil? && @data.length == @size
+      end
+    end
+  end
+end