protobuffy 3.1.0

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

data/lib/protobuf/message.rb

@@ -0,0 +1,182 @@
+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 unless value.nil?
+      end
+    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.name)
+        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.name]
+
+        if value.nil?
+          raise ::Protobuf::SerializationError, "Required field #{self.class.name}##{field.name} does not have a value."
+        else
+          yield(field, value)
+        end
+      end
+    end
+
+    def has_field?(name)
+      @values.has_key?(name)
+    end
+
+    def inspect
+      to_hash.inspect
+    end
+
+    def respond_to_has?(key)
+      respond_to?(key) && has_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 = Hash.new
+
+      @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
+
+      return result
+    end
+
+    def to_json(options = {})
+      to_hash.to_json(options)
+    end
+
+    def to_proto
+      self
+    end
+
+    def ==(obj)
+      return false unless obj.is_a?(self.class)
+      each_field do |field, value|
+        return false unless value == obj.__send__(field.name)
+      end
+      true
+    end
+
+    def [](name)
+      if field = self.class.get_field(name, true)
+        __send__(field.name)
+      end
+    end
+
+    def []=(name, value)
+      if field = self.class.get_field(name, true)
+        __send__(field.setter_method_name, value)
+      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 { |obj|
+        case obj
+        when Message, String then obj.__send__(method)
+        else                      obj
+        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,122 @@
+require 'protobuf/deprecator'
+
+module Protobuf
+  class Message
+    module Fields
+
+      def self.extended(other)
+        other.extend(::Protobuf::Deprecator)
+        other.deprecate_class_method(:get_ext_field_by_name, :get_extension_field)
+        other.deprecate_class_method(:get_ext_field_by_tag, :get_extension_field)
+        other.deprecate_class_method(:get_field_by_name, :get_field)
+        other.deprecate_class_method(:get_field_by_tag, :get_field)
+      end
+
+      ##
+      # 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
+      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
+
+        class_eval(<<-RAW_GETTER, __FILE__, __LINE__ + 1)
+          define_method("#{field_name}!") do
+            @values[:#{field_name}]
+          end
+        RAW_GETTER
+      end
+
+      def raise_if_tag_collision(tag, field_name)
+        if get_field(tag, true)
+          raise 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)
+          raise DuplicateFieldNameError, %!Field name #{field_name} has already been used in "#{name}".!
+        end
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/message/serialization.rb

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