protobuffy 3.6.0 → 4.0.0

data/lib/protobuf/generators/group_generator.rb

@@ -2,6 +2,7 @@ require 'protobuf/generators/enum_generator'
 require 'protobuf/generators/extension_generator'
 require 'protobuf/generators/field_generator'
 require 'protobuf/generators/message_generator'
+require 'protobuf/generators/option_generator'
 require 'protobuf/generators/service_generator'
 
 module Protobuf
@@ -18,10 +19,14 @@ module Protobuf
         @comments = {}
         @handlers = {}
         @indent_level = indent_level
-        @order = [ :enum, :message_declaration, :message, :extended_message, :service ]
+        @order = [:enum, :message_declaration, :options, :message, :extended_message, :service]
         init_printer(indent_level)
       end
 
+      def add_options(option_descriptor)
+        @groups[:options] << OptionGenerator.new(option_descriptor, indent_level)
+      end
+
       def add_enums(enum_descriptors, options)
         enum_descriptors.each do |enum_descriptor|
           @groups[:enum] << EnumGenerator.new(enum_descriptor, indent_level, options)
@@ -32,8 +37,9 @@ module Protobuf
         @comments[type] = message
       end
 
-      def add_extended_messages(extended_messages)
+      def add_extended_messages(extended_messages, skip_empty_fields = true)
         extended_messages.each do |message_type, field_descriptors|
+          next if skip_empty_fields && field_descriptors.empty?
           @groups[:extended_message] << ExtensionGenerator.new(message_type, field_descriptors, indent_level)
         end
       end
@@ -80,25 +86,25 @@ module Protobuf
       def compile
         @order.each do |type|
           items = @groups[type]
-          if items.count > 0
-            item_handler = @handlers[type]
+          next if items.empty?
 
-            item_header = @headers[type]
-            header(item_header) if item_header
+          item_handler = @handlers[type]
 
-            item_comment = @comments[type]
-            comment(item_comment) if item_comment
+          item_header = @headers[type]
+          header(item_header) if item_header
 
-            items.each do |item|
-              if item_handler
-                puts item_handler.call(item)
-              else
-                print item.to_s
-              end
-            end
+          item_comment = @comments[type]
+          comment(item_comment) if item_comment
 
-            puts if type == :message_declaration
+          items.each do |item|
+            if item_handler
+              puts item_handler.call(item)
+            else
+              print item.to_s
+            end
           end
+
+          puts if type == :message_declaration || type == :options
         end
       end
 
@@ -110,4 +116,3 @@ module Protobuf
     end
   end
 end
-

data/lib/protobuf/generators/message_generator.rb

@@ -23,7 +23,7 @@ module Protobuf
 
       def compile_declaration
         run_once(:compile_declaration) do
-          if is_printable?
+          if printable?
             print_class(descriptor.name, :message) do
               group = GroupGenerator.new(current_indent)
               group.add_enums(descriptor.enum_type, :namespace => type_namespace)
@@ -38,7 +38,7 @@ module Protobuf
 
       def compile_message
         run_once(:compile_message) do
-          if is_printable?
+          if printable?
             print_class(descriptor.name, nil) do
               group = GroupGenerator.new(current_indent)
               group.add_messages(descriptor.nested_type, :extension_fields => @extension_fields, :namespace => type_namespace)
@@ -52,7 +52,7 @@ module Protobuf
 
               group.add_extension_fields(message_extension_fields)
 
-              group.order = [ :message, :field, :extension_range, :extension_field ]
+              group.order = [:message, :field, :extension_range, :extension_field]
               print group.to_s
             end
           end
@@ -61,31 +61,31 @@ module Protobuf
 
       private
 
-      def has_extensions?
-        ! message_extension_fields.empty?
+      def extensions?
+        !message_extension_fields.empty?
       end
 
-      def has_fields?
+      def fields?
         descriptor.field.count > 0
       end
 
-      def has_nested_enums?
+      def nested_enums?
         descriptor.enum_type.count > 0
       end
 
-      def has_nested_messages?
+      def nested_messages?
         descriptor.nested_type.count > 0
       end
 
-      def has_nested_types?
-        has_nested_enums? || has_nested_messages?
+      def nested_types?
+        nested_enums? || nested_messages?
       end
 
-      def is_printable?
+      def printable?
         if @only_declarations
-          has_nested_types?
+          nested_types?
         else
-          has_fields? || has_nested_messages? || has_extensions?
+          fields? || nested_messages? || extensions?
         end
       end
 
@@ -96,4 +96,3 @@ module Protobuf
     end
   end
 end
-

data/lib/protobuf/generators/option_generator.rb

@@ -0,0 +1,17 @@
+require 'protobuf/generators/base'
+
+module Protobuf
+  module Generators
+    class OptionGenerator < Base
+      def compile
+        run_once(:compile) do
+          descriptor.each_field.map do |field, value|
+            next unless descriptor.field?(field.name)
+            serialized_value = serialize_value(value)
+            puts "set_option #{field.fully_qualified_name.inspect}, #{serialized_value}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/generators/printable.rb

@@ -11,9 +11,13 @@ module Protobuf
       #
       def init_printer(indent_level)
         @io = ::StringIO.new
-        @_indent_level = indent_level.to_i || 0
+        self.current_indent = indent_level.to_i
       end
 
+      protected
+
+      attr_accessor :current_indent
+
       private
 
       # Print a one-line comment.
@@ -22,10 +26,6 @@ module Protobuf
         puts "# #{message}"
       end
 
-      def current_indent
-        @_indent_level
-      end
-
       # Print a "header" comment.
       #
       #   header("Lorem ipsum dolor")
@@ -43,7 +43,7 @@ module Protobuf
       # (after the block is finished).
       #
       def indent
-        @_indent_level += 1
+        self.current_indent += 1
         yield
         outdent
       end
@@ -61,14 +61,14 @@ module Protobuf
       #
       def modulize(name)
         name = name.gsub(/\./, '::')
-        name = name.gsub(/(^(?:::)?[a-z]|::[a-z])/) { |match| match.upcase }
+        name = name.gsub(/(^(?:::)?[a-z]|::[a-z])/, &:upcase)
         name
       end
 
       # Decrease the indent level. Cannot be negative.
       #
       def outdent
-        @_indent_level -= 1 unless @_indent_level == 0
+        self.current_indent -= 1 unless current_indent.zero?
       end
 
       # Return the parent class for a given type.
@@ -84,7 +84,7 @@ module Protobuf
         when :service then
           PARENT_CLASS_SERVICE
         else
-          raise "Unknown parent class type #{type}: #{caller[0..5].join("\n")}"
+          fail "Unknown parent class type #{type}: #{caller[0..5].join("\n")}"
         end
       end
 
@@ -93,14 +93,14 @@ module Protobuf
       # If a block is given, call the block from within an indent block.
       # Otherwise, end the block on the same line.
       #
-      def print_block(name, parent_klass, type, &block)
+      def print_block(name, parent_klass, type)
         name = modulize(name)
         block_def = "#{type} #{name}"
         block_def += " < #{parent_class(parent_klass)}" if parent_klass
 
         if block_given?
           puts block_def
-          indent { block.call }
+          indent { yield }
           puts "end"
           puts
         else
@@ -136,7 +136,7 @@ module Protobuf
       #
       def puts(message = nil)
         if message
-          @io.puts(("  " * @_indent_level) + message)
+          @io.puts(("  " * current_indent) + message)
         else
           @io.puts
         end
@@ -158,4 +158,3 @@ module Protobuf
     end
   end
 end
-

data/lib/protobuf/generators/service_generator.rb

@@ -15,13 +15,12 @@ module Protobuf
       end
 
       def build_method(method_descriptor)
-        name = method_descriptor.name
         request_klass = modulize(method_descriptor.input_type)
         response_klass = modulize(method_descriptor.output_type)
-        return "rpc :#{name.underscore}, #{request_klass}, #{response_klass}"
+        name = ENV.key?('PB_USE_RAW_RPC_NAMES') ? method_descriptor.name : method_descriptor.name.underscore
+        "rpc :#{name}, #{request_klass}, #{response_klass}"
       end
 
     end
   end
 end
-

data/lib/protobuf/http.rb

@@ -14,7 +14,7 @@
 #   gem 'protobuf', :require => 'protobuf/http'
 #
 require 'protobuf'
-Protobuf.connector_type = :http
-
 require 'protobuf/rpc/servers/http/server'
 require 'protobuf/rpc/connectors/http'
+
+::Protobuf.connector_type_class = ::Protobuf::Rpc::Connectors::Http

data/lib/protobuf/lifecycle.rb

@@ -1,46 +1,33 @@
 module Protobuf
   class Lifecycle
-    include ::Protobuf::Logger::LogMethods
-
-    def self.register(event_name, &blk)
-      raise "Lifecycle register must have a block" unless block_given?
-      event_name = normalized_event_name(event_name)
+    class << self
+      def register(event_name)
+        fail "Lifecycle register must have a block" unless block_given?
+        event_name = normalized_event_name(event_name)
 
-      if ::Protobuf.print_deprecation_warnings?
-        $stderr.puts <<-ERROR
-            [DEPRECATED] ::Protobuf::Lifecycle has been deprecated and will be removed in a future version.
-                         Use ::ActiveSupport::Notifications.subscribe('#{event_name}')
-        ERROR
+        ::ActiveSupport::Notifications.subscribe(event_name) do |_name, _start, _finish, _id, args|
+          yield(*args)
+        end
       end
+      alias :on register
 
-      ::ActiveSupport::Notifications.subscribe(event_name) do |name, start, finish, id, args|
-        blk.call(*args)
-      end
-    end
+      def trigger(event_name, *args)
+        event_name = normalized_event_name(event_name)
 
-    def self.trigger( event_name, *args )
-      if ::Protobuf.print_deprecation_warnings?
-        $stderr.puts <<-ERROR
-            [DEPRECATED] ::Protobuf::Lifecycle has been deprecated and will be removed in a future version.
-                         Use ::ActiveSupport::Notifications.instrument(...)
-        ERROR
+        ::ActiveSupport::Notifications.instrument(event_name, args)
       end
 
-      event_name = normalized_event_name( event_name )
+      replacement = ::ActiveSupport::Notifications
 
-      ::ActiveSupport::Notifications.instrument(event_name, args)
-    end
+      ::Protobuf.deprecator.deprecate_methods(
+        self,
+        :register => "#{replacement}.#{replacement.method(:subscribe).name}".to_sym,
+        :trigger => "#{replacement}.#{replacement.method(:instrument).name}".to_sym
+      )
 
-    def self.normalized_event_name(event_name)
-      return "#{event_name}".downcase
-    end
-
-    class << self
-      attr_accessor :lifecycle_events
-
-      alias_method :on, :register
+      def normalized_event_name(event_name)
+        event_name.to_s.downcase
+      end
     end
-
-    @lifecycle_events ||= {}
   end
 end

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

@@ -1,9 +1,17 @@
-require 'protobuf/field'
-require 'protobuf/enum'
-require 'protobuf/exceptions'
 require 'protobuf/message/fields'
 require 'protobuf/message/serialization'
 
+# Under MRI, this optimizes proto decoding by around 15% in tests.
+# When unavailable, we fall to pure Ruby.
+# rubocop:disable Lint/HandleExceptions
+begin
+  require 'varint/varint'
+rescue LoadError
+end
+# rubocop:enable Lint/HandleExceptions
+
+require 'protobuf/varint'
+
 module Protobuf
   class Message
 
@@ -13,6 +21,7 @@ module Protobuf
 
     extend ::Protobuf::Message::Fields
     include ::Protobuf::Message::Serialization
+    ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::MessageOptions }
 
     ##
     # Class Methods
@@ -28,10 +37,11 @@ module Protobuf
 
     def initialize(fields = {})
       @values = {}
-
-      fields.to_hash.each_pair do |name, value|
-        self[name] = value unless value.nil?
+      fields.to_hash.each do |name, value|
+        set_field(name, value, true)
       end
+
+      yield self if block_given?
     end
 
     ##
@@ -61,54 +71,66 @@ module Protobuf
     # Iterate over every field, invoking the given block
     #
     def each_field
+      return to_enum(:each_field) unless block_given?
+
       self.class.all_fields.each do |field|
-        value = __send__(field.name)
+        value = self[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]
-
+        value = @values[field.fully_qualified_name]
         if value.nil?
-          raise ::Protobuf::SerializationError, "Required field #{self.class.name}##{field.name} does not have a value."
-        else
-          yield(field, value)
+          fail ::Protobuf::SerializationError, "Required field #{self.class.name}##{field.name} does not have a value." if field.required?
+          next
         end
+
+        yield(field, value)
       end
     end
 
-    def has_field?(name)
-      @values.has_key?(name)
+    def field?(name)
+      field = self.class.get_field(name, true)
+      return false if field.nil?
+      if field.repeated?
+        @values.key?(field.fully_qualified_name) && @values[field.fully_qualified_name].present?
+      else
+        @values.key?(field.fully_qualified_name)
+      end
     end
+    ::Protobuf.deprecator.define_deprecated_methods(self, :has_field? => :field?)
 
     def inspect
-      to_hash.inspect
+      attrs = self.class.fields.map do |field|
+        [field.name, self[field.name].inspect].join('=')
+      end.join(' ')
+
+      "#<#{self.class} #{attrs}>"
     end
 
     def respond_to_has?(key)
-      respond_to?(key) && has_field?(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)))
+        (self[key].present? || [true, false].include?(self[key]))
     end
 
     # Return a hash-representation of the given fields for this message type.
     def to_hash
-      result = Hash.new
+      result = {}
 
-      @values.keys.each do |field_name|
-        value = __send__(field_name)
+      @values.each_key do |field_name|
+        value = self[field_name]
+        field = self.class.get_field(field_name, true)
         hashed_value = value.respond_to?(:to_hash_value) ? value.to_hash_value : value
-        result.merge!(field_name => hashed_value)
+        result[field.name] = hashed_value
       end
 
-      return result
+      result
     end
 
     def to_json(options = {})
@@ -119,60 +141,105 @@ module Protobuf
       self
     end
 
-    def ==(obj)
-      return false unless obj.is_a?(self.class)
+    def ==(other)
+      return false unless other.is_a?(self.class)
       each_field do |field, value|
-        return false unless value == obj.__send__(field.name)
+        return false unless value == other[field.name]
       end
       true
     end
 
     def [](name)
-      if field = self.class.get_field(name, true)
-        __send__(field.name)
+      field = self.class.get_field(name, true)
+
+      fail ArgumentError, "invalid field name=#{name.inspect}" unless field
+
+      if field.repeated?
+        @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(field)
+      elsif @values.key?(field.fully_qualified_name)
+        @values[field.fully_qualified_name]
+      else
+        field.default_value
       end
     end
 
     def []=(name, value)
-      if field = self.class.get_field(name, true)
-        __send__(field.setter_method_name, value)
-      end
+      set_field(name, value, true)
     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?
+    alias :to_hash_value to_hash
+    alias :to_proto_hash to_hash
+    alias :responds_to_has? respond_to_has?
+    alias :respond_to_and_has? respond_to_has?
+    alias :responds_to_and_has? respond_to_has?
+    alias :respond_to_has_present? respond_to_has_and_present?
+    alias :respond_to_and_has_present? respond_to_has_and_present?
+    alias :respond_to_and_has_and_present? respond_to_has_and_present?
+    alias :responds_to_has_present? respond_to_has_and_present?
+    alias :responds_to_and_has_present? respond_to_has_and_present?
+    alias :responds_to_and_has_and_present? respond_to_has_and_present?
 
     ##
     # Private Instance Methods
     #
+
     private
 
+    def set_field(name, value, ignore_nil_for_repeated)
+      if (field = self.class.get_field(name, true))
+        if field.repeated?
+          if value.nil? && ignore_nil_for_repeated
+            ::Protobuf.deprecator.deprecation_warning("#{self.class}#[#{name}]=nil", "use an empty array instead of nil")
+            return
+          end
+          unless value.is_a?(Array)
+            fail TypeError, <<-TYPE_ERROR
+                Expected repeated value of type '#{field.type_class}'
+                Got '#{value.class}' for repeated protobuf field #{field.name}
+            TYPE_ERROR
+          end
+
+          value = value.compact
+
+          if value.empty?
+            @values.delete(field.fully_qualified_name)
+          else
+            @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(field)
+            @values[field.fully_qualified_name].replace(value)
+          end
+        else
+          if value.nil? # rubocop:disable Style/IfInsideElse
+            @values.delete(field.fully_qualified_name)
+          elsif field.acceptable?(value)
+            @values[field.fully_qualified_name] = field.coerce!(value)
+          else
+            fail TypeError, "Unacceptable value #{value} for field #{field.name} of type #{field.type_class}"
+          end
+        end
+      else
+        unless ::Protobuf.ignore_unknown_fields?
+          fail ::Protobuf::FieldNotDefinedError, name
+        end
+      end
+    end
+
     def copy_to(object, method)
-      duplicate = proc { |obj|
+      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)})
+          object[name].replace(value.map { |v| duplicate.call(v) })
         else
-          object.__send__("#{name}=", duplicate.call(value))
+          object[name] = duplicate.call(value)
         end
       end
       object