contrast-agent 6.7.0 → 6.8.0

data/lib/protobuf/generators/service_generator.rb

@@ -1,50 +0,0 @@
-require 'protobuf/generators/base'
-require 'protobuf/generators/option_generator'
-
-module Protobuf
-  module Generators
-    class ServiceGenerator < Base
-
-      def compile
-        run_once(:compile) do
-          print_class(descriptor.name, :service) do
-            print OptionGenerator.new(descriptor.options, current_indent).to_s if descriptor.options
-            descriptor.method.each do |method_descriptor|
-              print_method(method_descriptor)
-            end
-          end
-        end
-      end
-
-      private
-
-      def print_method(method_descriptor)
-        request_klass = modulize(method_descriptor.input_type)
-        response_klass = modulize(method_descriptor.output_type)
-        name = ENV.key?('PB_USE_RAW_RPC_NAMES') ? method_descriptor.name : method_descriptor.name.underscore
-        options = {}
-        if method_descriptor.options
-          method_descriptor.options.each_field do |field_option|
-            option_value = method_descriptor.options[field_option.name]
-            next unless method_descriptor.options.field?(field_option.name)
-            options[field_option.fully_qualified_name] = serialize_value(option_value)
-          end
-        end
-
-        rpc = "rpc :#{name}, #{request_klass}, #{response_klass}"
-
-        if options.empty?
-          puts rpc
-          return
-        end
-
-        puts rpc + " do"
-        options.each do |option_name, value|
-          indent { puts "set_option #{option_name.inspect}, #{value}" }
-        end
-        puts "end"
-      end
-
-    end
-  end
-end

data/lib/protobuf/lifecycle.rb

@@ -1,33 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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/fields.rb

@@ -1,233 +0,0 @@
-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

data/lib/protobuf/message/serialization.rb

@@ -1,85 +0,0 @@
-require 'stringio'
-require 'protobuf/decoder'
-require 'protobuf/encoder'
-
-module Protobuf
-  class Message
-    module Serialization
-
-      module ClassMethods
-        def decode(bytes)
-          new.decode(bytes)
-        end
-
-        def decode_from(stream)
-          new.decode_from(stream)
-        end
-
-        # Create a new object with the given values and return the encoded bytes.
-        def encode(fields = {})
-          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
-        stream.set_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
-        encode_to(stream)
-        stream.string
-      end
-
-      # Encode this message to the given stream.
-      #
-      def encode_to(stream)
-        ::Protobuf::Encoder.encode(self, stream)
-      end
-
-      ##
-      # Instance Aliases
-      #
-      alias :parse_from_string decode
-      alias :deserialize decode
-      alias :parse_from decode_from
-      alias :deserialize_from decode_from
-      alias :to_s encode
-      alias :bytes encode
-      alias :serialize encode
-      alias :serialize_to_string encode
-      alias :serialize_to encode_to
-
-      private
-
-      def set_field_bytes(tag, bytes)
-        field = _protobuf_message_field[tag]
-        field.set(self, bytes) if field
-      end
-
-    end
-  end
-end

data/lib/protobuf/message.rb

@@ -1,241 +0,0 @@
-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) { ::CSGoogle::Protobuf::MessageOptions }
-
-    ##
-    # Class Methods
-    #
-
-    def self.to_json
-      name
-    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.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
-      result = {}
-
-      @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)
-                         value.to_json_hash_value
-                       elsif field.respond_to?(:json_encode)
-                         field.json_encode(value)
-                       else
-                         value
-                       end
-
-        result[field.name] = 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