prepor-protobuf 3.5.0

data/lib/protobuf/encoder.rb

@@ -0,0 +1,67 @@
+module Protobuf
+  class Encoder
+
+    def self.encode(stream, message)
+      new(stream, message).encode
+    end
+
+    private
+
+    attr_writer :message, :stream
+
+    public
+
+    attr_reader :message, :stream
+
+    def initialize(message, stream)
+      unless message.respond_to?(:each_field_for_serialization)
+        fail ArgumentError, "Message instance must respond to :each_field_for_serialization"
+      end
+
+      self.message = message
+      self.stream = stream
+    end
+
+    def encode
+      message.each_field_for_serialization do |field, value|
+        encode_field(field, value)
+      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

@@ -0,0 +1,303 @@
+require 'delegate'
+require 'protobuf/optionable'
+
+##
+# Adding extension to Numeric until
+# we can get people to stop calling #value
+# on Enum instances.
+#
+::Protobuf.deprecator.define_deprecated_methods(Numeric, :value => :to_int)
+
+module Protobuf
+  class Enum < SimpleDelegator
+    # Public: Allows setting Options on the Enum class.
+    include ::Protobuf::Optionable
+
+    def self.aliases_allowed?
+      get_option(:allow_alias)
+    end
+
+    # Public: Get all integer tags defined by this enum.
+    #
+    # Examples
+    #
+    #   class StateMachine < ::Protobuf::Enum
+    #     set_option :allow_alias
+    #     define :ON, 1
+    #     define :STARTED, 1
+    #     define :OFF, 2
+    #   end
+    #
+    #   StateMachine.all_tags #=> [ 1, 2 ]
+    #
+    # Returns an array of unique integers.
+    #
+    def self.all_tags
+      @all_tags ||= enums.map(&:to_i).uniq
+    end
+
+    # Internal: DSL method to create a new Enum. The given name will
+    # become a constant for this Enum pointing to the new instance.
+    #
+    # Examples
+    #
+    #   class StateMachine < ::Protobuf::Enum
+    #     define :ON, 1
+    #     define :OFF, 2
+    #   end
+    #
+    #   StateMachine::ON  #=> #<StateMachine::ON=1>
+    #   StateMachine::OFF #=> #<StateMachine::OFF=2>
+    #
+    # Returns nothing.
+    #
+    def self.define(name, tag)
+      enum = new(self, name, tag)
+      @enums ||= []
+      @enums << enum
+      const_set(name, enum)
+    end
+
+    # Public: All defined enums.
+    #
+    class << self
+      attr_reader :enums
+    end
+
+    # Public: Get an array of Enum objects with the given tag.
+    #
+    # tag - An object that responds to to_i.
+    #
+    # Examples
+    #
+    #   class StateMachine < ::Protobuf::Enum
+    #     set_option :allow_alias
+    #     define :ON, 1
+    #     define :STARTED, 1
+    #     define :OFF, 2
+    #   end
+    #
+    #   StateMachine.enums_for_tag(1) #=> [ #<StateMachine::ON=1>, #<StateMachine::STARTED=1> ]
+    #   StateMachine.enums_for_tag(2) #=> [ #<StateMachine::OFF=2> ]
+    #
+    # Returns an array with zero or more Enum objects or nil.
+    #
+    def self.enums_for_tag(tag)
+      enums.select do |enum|
+        enum.to_i == tag.to_i
+      end
+    end
+
+    # Public: Get the Enum associated with the given name.
+    #
+    # name - A string-like object. Case-sensitive.
+    #
+    # Example
+    #
+    #   class StateMachine < ::Protobuf::Enum
+    #     define :ON, 1
+    #     define :OFF, 2
+    #   end
+    #
+    #   StateMachine.enum_for_name(:ON)  # => #<StateMachine::ON=1>
+    #   StateMachine.enum_for_name("ON") # => #<StateMachine::ON=1>
+    #   StateMachine.enum_for_name(:on)  # => nil
+    #   StateMachine.enum_for_name(:FOO) # => nil
+    #
+    # Returns the Enum object with the given name or nil.
+    #
+    def self.enum_for_name(name)
+      const_get(name)
+    rescue ::NameError
+      nil
+    end
+
+    # Public: Get the Enum object corresponding to the given tag.
+    #
+    # tag - An object that responds to to_i.
+    #
+    # Returns an Enum object or nil. If the tag corresponds to multiple
+    #   Enums, the first enum defined will be returned.
+    #
+    def self.enum_for_tag(tag)
+      enums_for_tag(tag).first
+    end
+
+    # Public: Get an Enum by a variety of type-checking mechanisms.
+    #
+    # candidate - An Enum, Numeric, String, or Symbol object.
+    #
+    # Example
+    #
+    #   class StateMachine < ::Protobuf::Enum
+    #     set_option :allow_alias
+    #     define :ON, 1
+    #     define :STARTED, 1
+    #     define :OFF, 2
+    #   end
+    #
+    #   StateMachine.fetch(StateMachine::ON)  # => #<StateMachine::ON=1>
+    #   StateMachine.fetch(:ON)               # => #<StateMachine::ON=1>
+    #   StateMachine.fetch("STARTED")         # => #<StateMachine::STARTED=1>
+    #   StateMachine.fetch(1)                 # => [ #<StateMachine::ON=1>, #<StateMachine::STARTED=1> ]
+    #
+    # Returns an Enum object or nil.
+    #
+    def self.fetch(candidate)
+      case candidate
+      when self then
+        candidate
+      when ::Numeric then
+        enum_for_tag(candidate.to_i)
+      when ::String, ::Symbol then
+        enum_for_name(candidate)
+      else
+        nil
+      end
+    end
+
+    # Public: Get the Symbol name associated with the given number.
+    #
+    # number - An object that responds to to_i.
+    #
+    # Examples
+    #
+    #   # Without aliases
+    #   class StateMachine < ::Protobuf::Enum
+    #     define :ON, 1
+    #     define :OFF, 2
+    #   end
+    #
+    #   StateMachine.name_for_tag(1) # => :ON
+    #   StateMachine.name_for_tag(2) # => :OFF
+    #   StateMachine.name_for_tag(3) # => nil
+    #
+    #   # With aliases
+    #   class StateMachine < ::Protobuf::Enum
+    #     set_option :allow_alias
+    #     define :STARTED, 1
+    #     define :ON, 1
+    #     define :OFF, 2
+    #   end
+    #
+    #   StateMachine.name_for_tag(1) # => :STARTED
+    #   StateMachine.name_for_tag(2) # => :OFF
+    #
+    # Returns the symbol name of the enum constant given it's associated tag or nil.
+    #   If the given tag has multiple names associated (due to allow_alias)
+    #   the first defined name will be returned.
+    #
+    def self.name_for_tag(tag)
+      enum_for_tag(tag).try(:name)
+    end
+
+    # Public: Check if the given tag is defined by this Enum.
+    #
+    # number - An object that responds to to_i.
+    #
+    # Returns a boolean.
+    #
+    def self.valid_tag?(tag)
+      tag.respond_to?(:to_i) && all_tags.include?(tag.to_i)
+    end
+
+    # Public: [DEPRECATED] Return a hash of Enum objects keyed
+    # by their :name.
+    #
+    def self.values
+      @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,
+      )
+
+      ::Protobuf.deprecator.deprecate_methods(self, :values => :enums)
+    end
+
+    ##
+    # Attributes
+    #
+
+    private
+
+    attr_writer :parent_class, :name, :tag
+
+    public
+
+    attr_reader :parent_class, :name, :tag
+
+    ##
+    # Instance Methods
+    #
+
+    def initialize(parent_class, name, 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
+    #
+    def class
+      Fixnum
+    end
+
+    def inspect
+      "\#<Protobuf::Enum(#{parent_class})::#{name}=#{tag}>"
+    end
+
+    def to_i
+      tag
+    end
+
+    def to_int
+      tag.to_int
+    end
+
+    def to_s(format = :tag)
+      case format
+      when :tag then
+        to_i.to_s
+      when :name then
+        name.to_s
+      else
+        to_i.to_s
+      end
+    end
+
+    # Re-implement `try` in order to fix the problem where
+    # the underlying fixnum doesn't respond to all methods (e.g. name or tag).
+    # If we respond to the first argument, `__send__` the args. Otherwise,
+    # delegate the `try` call to the underlying vlaue fixnum.
+    #
+    def try(*args, &block)
+      case
+      when args.empty? && block_given?
+        yield self
+      when respond_to?(args.first)
+        __send__(*args, &block)
+      else
+        @tag.try(*args, &block)
+      end
+    end
+
+    ::Protobuf.deprecator.define_deprecated_methods(self, :value => :to_i)
+
+    ##
+    # Instance Aliases
+    #
+    alias_method :to_hash_value, :to_i
+  end
+end

data/lib/protobuf/exceptions.rb

@@ -0,0 +1,9 @@
+module Protobuf
+  class Error < StandardError; end
+  class InvalidWireType < Error; end
+  class NotInitializedError < Error; end
+  class TagCollisionError < Error; end
+  class SerializationError < StandardError; end
+  class FieldNotDefinedError < StandardError; end
+  class DuplicateFieldNameError < StandardError; end
+end

data/lib/protobuf/field.rb

@@ -0,0 +1,74 @@
+require 'protobuf/field/base_field'
+require 'protobuf/field/bytes_field'
+require 'protobuf/field/float_field'
+require 'protobuf/field/message_field'
+require 'protobuf/field/varint_field'
+require 'protobuf/field/string_field'
+require 'protobuf/field/double_field'
+require 'protobuf/field/enum_field'
+require 'protobuf/field/integer_field'
+require 'protobuf/field/signed_integer_field'
+require 'protobuf/field/uint32_field'
+require 'protobuf/field/uint64_field'
+require 'protobuf/field/int32_field'
+require 'protobuf/field/int64_field'
+require 'protobuf/field/sint32_field'
+require 'protobuf/field/sint64_field'
+require 'protobuf/field/bool_field'
+require 'protobuf/field/sfixed32_field'
+require 'protobuf/field/sfixed64_field'
+require 'protobuf/field/fixed32_field'
+require 'protobuf/field/fixed64_field'
+
+module Protobuf
+  module Field
+
+    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).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
+        fail ArgumentError, "Invalid field type #{type}"
+      end
+    end
+
+    # 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
+end