protobuf 2.2.5-java

data/lib/protobuf/field/enum_field.rb

@@ -0,0 +1,50 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class EnumField < VarintField
+      def acceptable?(val)
+        case val
+        when Symbol then
+          raise TypeError unless @type.const_defined?(val)
+        when EnumValue then
+          raise TypeError if val.parent_class != @type
+        else
+          raise TypeError unless @type.valid_tag?(val)
+        end
+        true
+      end
+
+      def encode(value)
+        super(value.to_i)
+      end
+
+      private
+
+      def typed_default_value
+        if @default.is_a?(Symbol)
+          @type.const_get(@default)
+        else
+          self.class.default
+        end
+      end
+
+      def define_setter
+        field = self
+        @message_class.class_eval do
+          define_method("#{field.name}=") do |value|
+            orig_value = value
+            if value.nil?
+              @values.delete(field.name)
+            else
+              value = field.type.fetch(value)
+              raise TypeError, "Invalid ENUM value: #{orig_value.inspect} for #{field.name}" unless value
+
+              @values[field.name] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/field/extension_fields.rb

@@ -0,0 +1,32 @@
+module Protobuf
+  module Field
+    class ExtensionFields < Array
+      ##
+      # Constructor
+      #
+      def initialize
+        @ranges = []
+      end
+
+      ##
+      # Public Instance Methods
+      #
+
+      # Append a range to the list of ranges.
+      def add_range(range = (0..-1))
+        @ranges << range
+      end
+
+      # Set value at tag location, if tag is in a valid range.
+      def []=(key, value)
+        raise RangeError, "#{key} is not in #{@ranges.join(', ')}" unless include_tag?(key)
+        super
+      end
+
+      # Check if the given tag exists in any of the defined ranges.
+      def include_tag?(tag)
+        @ranges.any? { |range| range.include?(tag) }
+      end
+    end
+  end
+end

data/lib/protobuf/field/field_array.rb

@@ -0,0 +1,65 @@
+module Protobuf
+  module Field
+    class FieldArray < Array
+      ##
+      # Constructor
+      #
+      def initialize(field)
+        @field = field
+      end
+
+      ##
+      # Public Instance Methods
+      #
+      def []=(nth, val)
+        super(nth, normalize(val))
+      end
+
+      def <<(val)
+        super(normalize(val))
+      end
+
+      def push(val)
+        super(normalize(val))
+      end
+
+      def unshift(val)
+        super(normalize(val))
+      end
+
+      def replace(val)
+        raise TypeError unless val.is_a?(Array)
+        val = val.map { |v| normalize(v)}
+        super(val)
+      end
+
+      # Return a hash-representation of the given values for this field type.
+      # The value in this case would be an array.
+      def to_hash_value
+        self.map do |value|
+          value.respond_to?(:to_hash_value) ? value.to_hash_value : value
+        end
+      end
+
+      def to_s
+        "[#{@field.name}]"
+      end
+
+      private
+
+      ##
+      # Private Instance Methods
+      #
+      def normalize(value)
+        raise TypeError unless @field.acceptable?(value)
+        if @field.is_a?(::Protobuf::Field::EnumField)
+          @field.type.fetch(value)
+        elsif @field.is_a?(::Protobuf::Field::MessageField) && value.respond_to?(:to_hash)
+          @field.type.new(value.to_hash)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/field/fixed32_field.rb

@@ -0,0 +1,19 @@
+require 'protobuf/field/uint32_field.rb'
+
+module Protobuf
+  module Field
+    class Fixed32Field < Uint32Field
+      def wire_type
+       ::Protobuf::WireType::FIXED32
+      end
+
+      def decode(bytes)
+        bytes.unpack('V').first
+      end
+
+      def encode(value)
+        [value].pack('V')
+      end
+    end
+  end
+end

data/lib/protobuf/field/fixed64_field.rb

@@ -0,0 +1,22 @@
+require 'protobuf/field/uint64_field'
+
+module Protobuf
+  module Field
+    class Fixed64Field < Uint64Field
+      def wire_type
+        ::Protobuf::WireType::FIXED64
+      end
+
+      def decode(bytes)
+        # we don't use 'Q' for pack/unpack. 'Q' is machine-dependent.
+        values = bytes.unpack('VV')
+        values[0] + (values[1] << 32)
+      end
+
+      def encode(value)
+        # we don't use 'Q' for pack/unpack. 'Q' is machine-dependent.
+        [value & 0xffff_ffff, value >> 32].pack('VV')
+      end
+    end
+  end
+end

data/lib/protobuf/field/float_field.rb

@@ -0,0 +1,31 @@
+require 'protobuf/field/base_field'
+
+module Protobuf
+  module Field
+    class FloatField < BaseField
+      def self.default; 0.0; end
+      def self.max;  1.0/0; end
+      def self.min; -1.0/0; end
+      def max;  1.0/0; end
+      def min; -1.0/0; end
+
+      def wire_type
+        WireType::FIXED32
+      end
+
+      def decode(bytes)
+        bytes.unpack('e').first
+      end
+
+      def encode(value)
+        [value].pack('e')
+      end
+
+      def acceptable?(val)
+        raise TypeError, val.class.name unless val.is_a?(Numeric)
+        raise RangeError if val < min || max < val
+        true
+      end
+    end
+  end
+end

data/lib/protobuf/field/int32_field.rb

@@ -0,0 +1,12 @@
+require 'protobuf/field/integer_field'
+
+module Protobuf
+  module Field
+    class Int32Field < IntegerField
+      def self.max; INT32_MAX; end
+      def self.min; INT32_MIN; end
+      def max; INT32_MAX; end
+      def min; INT32_MIN; end
+    end
+  end
+end

data/lib/protobuf/field/int64_field.rb

@@ -0,0 +1,12 @@
+require 'protobuf/field/integer_field'
+
+module Protobuf
+  module Field
+    class Int64Field < IntegerField
+      def self.max; INT64_MAX; end
+      def self.min; INT64_MIN; end
+      def max; INT64_MAX; end
+      def min; INT64_MIN; end
+    end
+  end
+end

data/lib/protobuf/field/integer_field.rb

@@ -0,0 +1,19 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class IntegerField < VarintField
+
+      def encode(value)
+        # original Google's library uses 64bits integer for negative value
+        VarintField.encode(value & 0xffff_ffff_ffff_ffff)
+      end
+
+      def decode(value)
+        value -= 0x1_0000_0000_0000_0000 if (value & 0x8000_0000_0000_0000).nonzero?
+        value
+      end
+
+    end
+  end
+end

data/lib/protobuf/field/message_field.rb

@@ -0,0 +1,53 @@
+require 'protobuf/field/base_field'
+
+module Protobuf
+  module Field
+    class MessageField < BaseField
+      RAISE_TYPE = lambda { |field, val| raise TypeError, "Expected value of type '#{field.type}', but got '#{val.class}'" }
+
+      ##
+      # Public Instance Methods
+      #
+      def acceptable?(val)
+        RAISE_TYPE.call(self, val) unless val.instance_of?(type) || val.respond_to?(:to_hash)
+        true
+      end
+
+      def decode(bytes)
+        message = type.new
+        message.parse_from_string(bytes)
+        message
+      end
+      
+      def encode(value)
+        bytes = value.serialize_to_string
+        result = VarintField.encode(bytes.size)
+        result << bytes
+      end
+
+      def wire_type
+        ::Protobuf::WireType::LENGTH_DELIMITED
+      end
+
+      private
+
+      def define_setter
+        field = self
+        @message_class.class_eval do
+          define_method("#{field.name}=") do |val|
+            case 
+            when val.nil? then
+              @values.delete(field.name)
+            when val.is_a?(field.type) then
+              @values[field.name] = val
+            when val.respond_to?(:to_hash) then
+              @values[field.name] = field.type.new(val.to_hash)
+            else
+              RAISE_TYPE.call(field, val)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/field/sfixed32_field.rb

@@ -0,0 +1,21 @@
+require 'protobuf/field/int32_field'
+
+module Protobuf
+  module Field
+    class Sfixed32Field < Int32Field
+      def wire_type
+        ::Protobuf::WireType::FIXED32
+      end
+
+      def decode(bytes)
+        value  = bytes.unpack('V').first
+        value -= 0x1_0000_0000 if (value & 0x8000_0000).nonzero?
+        value
+      end
+
+      def encode(value)
+        [value].pack('V')
+      end
+    end
+  end
+end

data/lib/protobuf/field/sfixed64_field.rb

@@ -0,0 +1,24 @@
+require 'protobuf/field/int64_field'
+
+module Protobuf
+  module Field
+    class Sfixed64Field < Int64Field
+      def wire_type
+        ::Protobuf::WireType::FIXED64
+      end
+
+      def decode(bytes)
+        # we don't use 'Q' for pack/unpack. 'Q' is machine-dependent.
+        values = bytes.unpack('VV')
+        value  = values[0] + (values[1] << 32)
+        value -= 0x1_0000_0000_0000_0000 if (value & 0x8000_0000_0000_0000).nonzero?
+        value
+      end
+
+      def encode(value)
+        # we don't use 'Q' for pack/unpack. 'Q' is machine-dependent.
+        [value & 0xffff_ffff, value >> 32].pack('VV')
+      end
+    end
+  end
+end

data/lib/protobuf/field/signed_integer_field.rb

@@ -0,0 +1,23 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class SignedIntegerField < VarintField
+      def decode(value)
+        if (value & 1).zero?
+          value >> 1   # positive value
+        else
+          ~value >> 1  # negative value
+        end
+      end
+
+      def encode(value)
+        if value >= 0
+          VarintField.encode(value << 1)
+        else
+          VarintField.encode(~(value << 1))
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/field/sint32_field.rb

@@ -0,0 +1,12 @@
+require 'protobuf/field/signed_integer_field'
+
+module Protobuf
+  module Field
+    class Sint32Field < SignedIntegerField
+      def self.max; INT32_MAX; end
+      def self.min; INT32_MIN; end
+      def max; INT32_MAX; end
+      def min; INT32_MIN; end
+    end
+  end
+end

data/lib/protobuf/field/sint64_field.rb

@@ -0,0 +1,12 @@
+require 'protobuf/field/signed_integer_field'
+
+module Protobuf
+  module Field
+    class Sint64Field < SignedIntegerField
+      def self.max; INT64_MAX; end
+      def self.min; INT64_MIN; end
+      def max; INT64_MAX; end
+      def min; INT64_MIN; end
+    end
+  end
+end

data/lib/protobuf/field/string_field.rb

@@ -0,0 +1,14 @@
+require 'protobuf/field/bytes_field'
+
+module Protobuf
+  module Field
+    class StringField < BytesField
+      ENCODING = 'UTF-8'.freeze
+
+      def decode(bytes)
+        bytes.force_encoding(::Protobuf::Field::StringField::ENCODING) if bytes.respond_to?(:force_encoding)
+        bytes
+      end
+    end
+  end
+end

data/lib/protobuf/field/uint32_field.rb

@@ -0,0 +1,12 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class Uint32Field < VarintField
+      def self.max; UINT32_MAX; end
+      def self.min; 0; end
+      def max; UINT32_MAX; end
+      def min; 0; end
+    end
+  end
+end

data/lib/protobuf/field/uint64_field.rb

@@ -0,0 +1,12 @@
+require 'protobuf/field/varint_field'
+
+module Protobuf
+  module Field
+    class Uint64Field < VarintField
+      def self.max; UINT64_MAX; end
+      def self.min; 0; end
+      def max; UINT64_MAX; end
+      def min; 0; end
+    end
+  end
+end

data/lib/protobuf/field/varint_field.rb

@@ -0,0 +1,61 @@
+require 'protobuf/field/base_field'
+
+module Protobuf
+  module Field
+    class VarintField < BaseField
+      INT32_MAX  =  2**31 - 1
+      INT32_MIN  = -2**31 
+      INT64_MAX  =  2**63 - 1 
+      INT64_MIN  = -2**63
+      UINT32_MAX =  2**32 - 1
+      UINT64_MAX =  2**64 - 1
+
+      ##
+      # Class Methods
+      #
+      def self.default
+        0
+      end
+
+      def self.decode(bytes)
+        value = 0
+        bytes.each_with_index do |byte, index|
+          value |= byte << (7 * index)
+        end
+        value
+      end
+
+      def self.encode(value)
+        return [value].pack('C') if value < 128
+
+        bytes = []
+        until value == 0
+          bytes << (0x80 | (value & 0x7f))
+          value >>= 7
+        end
+        bytes[-1] &= 0x7f
+        bytes.pack('C*')
+      end
+
+      ##
+      # Public Instance Methods
+      #
+      def acceptable?(val)
+        (val > min || val < max) rescue false
+      end
+
+      def decode(value)
+        value
+      end
+
+      def encode(value)
+        self.class.encode(value)
+      end
+
+      def wire_type
+        ::Protobuf::WireType::VARINT
+      end
+
+    end
+  end
+end

data/lib/protobuf/field.rb

@@ -0,0 +1,57 @@
+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'
+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
+
+    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)
+    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}"
+    end
+
+  end
+end

data/lib/protobuf/logger.rb

@@ -0,0 +1,86 @@
+require 'logger'
+
+module Protobuf
+  class Logger < ::Logger
+
+    class << self
+      attr_accessor :file, :level
+
+      # Stub out the log methods for Protobuf::Logger as singleton methods
+      [:debug, :info, :warn, :error, :fatal, :any, :add, :log].each do |m|
+        define_method(m) do |*params, &block|
+          instance && instance.__send__(m, *params, &block)
+        end
+      end
+    end
+
+    # One-line file/level configuration
+    def self.configure(options)
+      self.file = options.fetch(:file, false)
+      self.level = options.fetch(:level, false)
+    end
+
+    # Use to reset the instance
+    def self.reset_device!
+      self.file = self.level = @__instance = nil
+    end
+
+    # Singleton instance
+    def self.instance
+      @__instance ||= begin
+        log = nil
+
+        if @file && @level
+          log = new(self.file)
+          log.level = self.level
+        end
+
+        log
+      end
+    end
+
+    #
+    # LogMethods module for log method including, e.g.:
+    #
+    # class MyClass
+    #   include Protobuf::Logger::LogMethods
+    #   ...
+    # end
+    #
+    # Produce a module to allow "include" in other classes to avoid
+    # cluttering the namespace of the including class with the other methods defined above
+    #
+    module LogMethods
+      [:debug, :info, :warn, :error, :fatal, :any, :add, :log].each do |m|
+        define_method("log_#{m}") do |*params, &block|
+          params.map! { |message| sign_message(message) }
+          ::Protobuf::Logger.__send__(m, *params, &block)
+        end
+      end
+
+      # When included, also extend the LogMethods module for class access.
+      def self.included(base)
+        base.extend(LogMethods)
+      end
+
+      # We often want to log an exception, so let's make that a core
+      # concern of the logger.
+      #
+      def log_exception(ex)
+        log_error { ex.message }
+        log_error { ex.backtrace[0..5].join("\n") }
+        log_debug { ex.backtrace.join("\n") }
+      end
+
+      def log_signature
+        @_log_signature ||= "[#{self.class == Class ? self.name : self.class.name}]"
+      end
+
+      def sign_message(message)
+        "#{log_signature} #{message}"
+      end
+
+    end
+
+  end
+end