protobuf-cucumber 3.10.4

data/lib/protobuf/lifecycle.rb

@@ -0,0 +1,33 @@
+module Protobuf
+  class Lifecycle
+    class << self
+      def register(event_name)
+        fail "Lifecycle register must have a block" unless block_given?
+        event_name = normalized_event_name(event_name)
+
+        ::ActiveSupport::Notifications.subscribe(event_name) do |_name, _start, _finish, _id, args|
+          yield(*args)
+        end
+      end
+      alias :on register
+
+      def trigger(event_name, *args)
+        event_name = normalized_event_name(event_name)
+
+        ::ActiveSupport::Notifications.instrument(event_name, args)
+      end
+
+      replacement = ::ActiveSupport::Notifications
+
+      ::Protobuf.deprecator.deprecate_methods(
+        self,
+        :register => "#{replacement}.#{replacement.method(:subscribe).name}".to_sym,
+        :trigger => "#{replacement}.#{replacement.method(:instrument).name}".to_sym,
+      )
+
+      def normalized_event_name(event_name)
+        event_name.to_s.downcase
+      end
+    end
+  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

@@ -0,0 +1,260 @@
+require 'protobuf/message/fields'
+require 'protobuf/message/serialization'
+require 'protobuf/varint'
+
+module Protobuf
+  class Message
+
+    ##
+    # Includes & Extends
+    #
+
+    extend ::Protobuf::Message::Fields
+    include ::Protobuf::Message::Serialization
+    ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::MessageOptions }
+
+    ##
+    # Class Methods
+    #
+
+    def self.to_json
+      name
+    end
+
+    def self.from_json(json)
+      fields = normalize_json(JSON.parse(json))
+      new(fields)
+    end
+
+    def self.normalize_json(ob)
+      case ob
+      when Array
+        ob.map { |value| normalize_json(value) }
+      when Hash
+        Hash[*ob.flat_map { |key, value| [key.underscore, normalize_json(value)] }]
+      else
+        ob
+      end
+    end
+
+    ##
+    # Constructor
+    #
+
+    def initialize(fields = {})
+      @values = {}
+      fields.to_hash.each do |name, value|
+        set_field(name, value, true)
+      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.is_a?(::Protobuf::Field::FieldHash)
+          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
+      return to_enum(:each_field) unless block_given?
+
+      self.class.all_fields.each do |field|
+        value = self[field.name]
+        yield(field, value)
+      end
+    end
+
+    def each_field_for_serialization
+      _protobuf_message_unset_required_field_tags.each do |tag|
+        fail ::Protobuf::SerializationError, "Required field #{self.class.name}##{_protobuf_message_field[tag].name} does not have a value."
+      end
+
+      @values.each_key do |fully_qualified_name|
+        field = _protobuf_message_field[fully_qualified_name]
+        yield(field, field.value_from_values_for_serialization(@values))
+      end
+    end
+
+    def field?(name)
+      field = _protobuf_message_field[name]
+
+      if field
+        field.field?(@values)
+      else
+        false
+      end
+    end
+    alias :respond_to_has? field?
+    ::Protobuf.deprecator.define_deprecated_methods(self, :has_field? => :field?)
+
+    def 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_and_present?(key)
+      field = _protobuf_message_field[key]
+
+      if field
+        field.field_and_present?(@values)
+      else
+        false
+      end
+    end
+
+    # Return a hash-representation of the given fields for this message type.
+    def to_hash
+      result = {}
+
+      @values.each_key do |field_name|
+        field = _protobuf_message_field[field_name]
+        field.to_message_hash(@values, result)
+      end
+
+      result
+    end
+
+    def to_hash_with_string_keys
+      result = {}
+
+      @values.each_key do |field_name|
+        field = _protobuf_message_field[field_name]
+        field.to_message_hash_with_string_key(@values, result)
+      end
+
+      result
+    end
+
+    def to_json(options = {})
+      to_json_hash(options).to_json(options)
+    end
+
+    # Return a hash-representation of the given fields for this message type that
+    # is safe to convert to JSON.
+    def to_json_hash(options = {})
+      result = {}
+
+      lower_camel_case = options[:lower_camel_case]
+
+      @values.each_key do |field_name|
+        value = self[field_name]
+        field = self.class.get_field(field_name, true)
+
+        # NB: to_json_hash_value should come before json_encode so as to handle
+        # repeated fields without extra logic.
+        hashed_value = if value.respond_to?(:to_json_hash_value) && !field.is_a?(::Protobuf::Field::EnumField)
+                         value.to_json_hash_value(options)
+                       elsif field.respond_to?(:json_encode)
+                         field.json_encode(value)
+                       else
+                         value
+                       end
+
+        key = lower_camel_case ? field.name.to_s.camelize(:lower).to_sym : field.name
+        result[key] = hashed_value
+      end
+
+      result
+    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[field.name]
+      end
+      true
+    end
+
+    def [](name)
+      field = _protobuf_message_field[name]
+      field.value_from_values(@values)
+    rescue # not having a field should be the exceptional state
+      raise if field
+      fail ArgumentError, "invalid field name=#{name.inspect}"
+    end
+
+    def []=(name, value)
+      set_field(name, value, true)
+    end
+
+    def set_field(name, value, ignore_nil_for_repeated, field = nil)
+      field ||= _protobuf_message_field[name]
+
+      if field
+        field.set_field(@values, value, ignore_nil_for_repeated, self)
+      else
+        fail(::Protobuf::FieldNotDefinedError, name) unless ::Protobuf.ignore_unknown_fields?
+      end
+    end
+
+    ##
+    # Instance Aliases
+    #
+    alias :to_hash_value to_hash
+    alias :to_json_hash_value to_json_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 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[name].replace(value.map { |v| duplicate.call(v) })
+        else
+          object[name] = duplicate.call(value)
+        end
+      end
+      object
+    end
+
+  end
+end

data/lib/protobuf/message/fields.rb

@@ -0,0 +1,233 @@
+require "set"
+
+module Protobuf
+  class Message
+    module Fields
+
+      ACCESSOR_SUFFIXES = ["", "=", "!", "?"].freeze
+
+      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,
+        )
+      end
+
+      module ClassMethods
+        def inherited(subclass)
+          inherit_fields!(subclass)
+          subclass.const_set("PROTOBUF_MESSAGE_REQUIRED_FIELD_TAGS", subclass.required_field_tags)
+          subclass.const_set("PROTOBUF_MESSAGE_GET_FIELD", subclass.field_store)
+          subclass.class_eval <<-RUBY, __FILE__, __LINE__
+            def _protobuf_message_field
+              PROTOBUF_MESSAGE_GET_FIELD
+            end
+
+            def _protobuf_message_unset_required_field_tags
+              @_protobuf_message_unset_required_field_tags ||= PROTOBUF_MESSAGE_REQUIRED_FIELD_TAGS.dup
+            end
+          RUBY
+        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 = {})
+          required_field_tags << tag
+          define_field(:required, type_class, name, tag, options)
+        end
+
+        # Define a map field.
+        #
+        def map(key_type_class, value_type_class, name, tag, options = {})
+          # manufacture a message that represents the map entry, used for
+          # serialization and deserialization
+          entry_type = Class.new(::Protobuf::Message) do
+            set_option :map_entry, true
+            optional key_type_class, :key, 1
+            optional value_type_class, :value, 2
+          end
+          define_field(:repeated, entry_type, 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 required_field_tags
+          @required_field_tags ||= []
+        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)
+          field = field_store[name_or_tag]
+          field if field.try(:extension?) { false }
+        end
+
+        def get_field(name_or_tag, allow_extension = false)
+          field = field_store[name_or_tag]
+
+          if field && (allow_extension || !field.extension?)
+            field
+          else
+            nil
+          end
+        end
+
+        def define_field(rule, type_class, fully_qualified_field_name, tag, options)
+          raise_if_tag_collision(tag, fully_qualified_field_name)
+          raise_if_name_collision(fully_qualified_field_name)
+
+          # Determine appropirate accessor for fields depending on name collisions via extensions:
+
+          # Case 1: Base field = "string_field" and no extensions of the same name
+          # Result:
+          #   message.string_field #=> @values["string_field"]
+          #   message[:string_field] #=> @values["string_field"]
+          #   message['string_field'] #=> @values["string_field"]
+
+          # Case 2: Base field = "string_field" and extension 1 = ".my_package.string_field", extension N = ".package_N.string_field"...
+          # Result:
+          #   message.string_field #=> @values["string_field"]
+          #   message[:string_field] #=> @values["string_field"]
+          #   message['string_field'] #=> @values["string_field"]
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+          #   message['.my_package.string_field']  #=> @values[".my_package.string_field"]
+
+          # Case 3: No base field, extension 1 = ".my_package.string_field", extension 2 = ".other_package.string_field", extension N...
+          # Result:
+          #   message.string_field #=> raise NoMethodError (no simple accessor allowed)
+          #   message[:string_field] #=> raise NoMethodError (no simple accessor allowed)
+          #   message['string_field'] #=> raise NoMethodError (no simple accessor allowed)
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+          #   message['.my_package.string_field']  #=> @values[".my_package.string_field"]
+          #   message[:'.other_package.string_field'] #=> @values[".other_package.string_field"]
+          #   message['.other_package.string_field']  #=> @values[".other_package.string_field"]
+
+          # Case 4: No base field, extension = ".my_package.string_field", no other extensions
+          # Result:
+          #   message.string_field #=> @values[".my_package.string_field"]
+          #   message[:string_field] #=> @values[".my_package.string_field"]
+          #   message['string_field'] #=> @values[".my_package.string_field"]
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+          #   message[:'.my_package.string_field'] #=> @values[".my_package.string_field"]
+
+          simple_name =
+            if options[:extension]
+              base_name = fully_qualified_field_name.to_s.split('.').last.to_sym
+              if field_store[base_name]
+                # Case 3
+                if field_store[base_name].extension?
+                  remove_existing_accessors(base_name)
+                end
+                nil
+              # Case 4
+              else
+                base_name
+              end
+            else
+              # Case 1
+              fully_qualified_field_name
+            end
+
+          field = ::Protobuf::Field.build(self, rule, type_class, fully_qualified_field_name,
+                                          tag, simple_name, options)
+          field_store[tag] = field
+          field_store[fully_qualified_field_name.to_sym] = field
+          field_store[fully_qualified_field_name.to_s] = field
+          if simple_name && simple_name != fully_qualified_field_name
+            field_store[simple_name.to_sym] = field
+            field_store[simple_name.to_s] = field
+          end
+          # defining a new field for the message will cause cached @all_fields, @extension_fields,
+          # and @fields to be incorrect; reset them
+          @all_fields = @extension_fields = @fields = nil
+        end
+
+        def remove_existing_accessors(accessor)
+          field_store.delete(accessor.to_sym).try(:fully_qualified_name_only!)
+          field_store.delete(accessor.to_s)
+          ACCESSOR_SUFFIXES.each do |modifier|
+            begin
+              remove_method("#{accessor}#{modifier}")
+            # rubocop: disable Lint/HandleExceptions
+            rescue NameError
+              # Do not remove the method
+            end
+          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