contrast-agent 6.3.0 → 6.5.1

data/lib/protobuf/code_generator.rb

@@ -0,0 +1,129 @@
+require 'active_support/core_ext/module/aliasing'
+require 'protobuf/generators/file_generator'
+
+module Protobuf
+  class CodeGenerator
+
+    CodeGeneratorFatalError = Class.new(RuntimeError)
+
+    def self.fatal(message)
+      fail CodeGeneratorFatalError, message
+    end
+
+    def self.print_tag_warning_suppress
+      STDERR.puts "Suppress tag warning output with PB_NO_TAG_WARNINGS=1."
+      def self.print_tag_warning_suppress; end # rubocop:disable Lint/DuplicateMethods, Lint/NestedMethodDefinition
+    end
+
+    def self.warn(message)
+      STDERR.puts("[WARN] #{message}")
+    end
+
+    private
+
+    attr_accessor :request
+
+    public
+
+    def initialize(request_bytes)
+      @request_bytes = request_bytes
+      self.request = ::CSGoogle::Protobuf::Compiler::CodeGeneratorRequest.decode(request_bytes)
+    end
+
+    def eval_unknown_extensions!
+      request.proto_file.each do |file_descriptor|
+        ::Protobuf::Generators::FileGenerator.new(file_descriptor).eval_unknown_extensions!
+      end
+      self.request = ::CSGoogle::Protobuf::Compiler::CodeGeneratorRequest.decode(@request_bytes)
+    end
+
+    def generate_file(file_descriptor)
+      ::Protobuf::Generators::FileGenerator.new(file_descriptor).generate_output_file
+    end
+
+    def response_bytes
+      generated_files = request.proto_file.map do |file_descriptor|
+        generate_file(file_descriptor)
+      end
+
+      ::CSGoogle::Protobuf::Compiler::CodeGeneratorResponse.encode(
+        :file => generated_files,
+        :supported_features => supported_features,
+      )
+    end
+
+    def supported_features
+      # The only available feature is proto3 with optional fields.
+      # This is backwards compatible with proto2 optional fields.
+      ::CSGoogle::Protobuf::Compiler::CodeGeneratorResponse::Feature::FEATURE_PROTO3_OPTIONAL.to_i
+    end
+
+    Protobuf::Field::BaseField.module_eval do
+      def define_set_method!
+      end
+
+      def set_without_options(message_instance, bytes)
+        return message_instance[name] = decode(bytes) unless repeated?
+
+        if map?
+          hash = message_instance[name]
+          entry = decode(bytes)
+          # decoded value could be nil for an
+          # enum value that is not recognized
+          hash[entry.key] = entry.value unless entry.value.nil?
+          return hash[entry.key]
+        end
+
+        return message_instance[name] << decode(bytes) unless packed?
+
+        array = message_instance[name]
+        stream = StringIO.new(bytes)
+
+        if wire_type == ::Protobuf::WireType::VARINT
+          array << decode(Varint.decode(stream)) until stream.eof?
+        elsif wire_type == ::Protobuf::WireType::FIXED64
+          array << decode(stream.read(8)) until stream.eof?
+        elsif wire_type == ::Protobuf::WireType::FIXED32
+          array << decode(stream.read(4)) until stream.eof?
+        end
+      end
+
+      # Sets a MessageField that is known to be an option.
+      # We must allow fields to be set one at a time, as option syntax allows us to
+      # set each field within the option using a separate "option" line.
+      def set_with_options(message_instance, bytes)
+        if message_instance[name].is_a?(::Protobuf::Message)
+          gp = CSGoogle::Protobuf
+          if message_instance.is_a?(gp::EnumOptions) || message_instance.is_a?(gp::EnumValueOptions) ||
+             message_instance.is_a?(gp::FieldOptions) || message_instance.is_a?(gp::FileOptions) ||
+             message_instance.is_a?(gp::MethodOptions) || message_instance.is_a?(gp::ServiceOptions) ||
+             message_instance.is_a?(gp::MessageOptions)
+
+            original_field = message_instance[name]
+            decoded_field = decode(bytes)
+            decoded_field.each_field do |subfield, subvalue|
+              option_set(original_field, subfield, subvalue) { decoded_field.field?(subfield.tag) }
+            end
+            return
+          end
+        end
+
+        set_without_options(message_instance, bytes)
+      end
+      alias_method :set, :set_with_options
+
+      def option_set(message_field, subfield, subvalue)
+        return unless yield
+        if subfield.repeated?
+          message_field[subfield.tag].concat(subvalue)
+        elsif message_field[subfield.tag] && subvalue.is_a?(::Protobuf::Message)
+          subvalue.each_field do |f, v|
+            option_set(message_field[subfield.tag], f, v) { subvalue.field?(f.tag) }
+          end
+        else
+          message_field[subfield.tag] = subvalue
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/decoder.rb

@@ -0,0 +1,28 @@
+module Protobuf
+  class Decoder
+
+    # Read bytes from +stream+ and pass to +message+ object.
+    def self.decode_each_field(stream)
+      until stream.eof?
+        bits = Varint.decode(stream)
+        wire_type = bits & 0x07
+        tag = bits >> 3
+
+        bytes = if wire_type == ::Protobuf::WireType::VARINT
+                  Varint.decode(stream)
+                elsif wire_type == ::Protobuf::WireType::LENGTH_DELIMITED
+                  value_length = Varint.decode(stream)
+                  stream.read(value_length)
+                elsif wire_type == ::Protobuf::WireType::FIXED64
+                  stream.read(8)
+                elsif wire_type == ::Protobuf::WireType::FIXED32
+                  stream.read(4)
+                else
+                  fail InvalidWireType, wire_type
+                end
+
+        yield(tag, bytes)
+      end
+    end
+  end
+end

data/lib/protobuf/deprecation.rb

@@ -0,0 +1,117 @@
+require 'active_support/deprecation'
+
+module Protobuf
+  if ::ActiveSupport::Deprecation.is_a?(Class)
+    class DeprecationBase < ::ActiveSupport::Deprecation
+      def deprecate_methods(*args)
+        deprecation_options = { :deprecator => self }
+
+        if args.last.is_a?(Hash)
+          args.last.merge!(deprecation_options)
+        else
+          args.push(deprecation_options)
+        end
+
+        super
+      end
+
+      def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
+        # This ensures ActiveSupport::Deprecation doesn't look for the caller, which is very costly.
+        super(deprecated_method_name, message, caller_backtrace) unless ENV.key?('PB_IGNORE_DEPRECATIONS')
+      end
+    end
+
+    class Deprecation < DeprecationBase
+      def define_deprecated_methods(target_module, method_hash)
+        target_module.module_eval do
+          method_hash.each do |old_method, new_method|
+            alias_method old_method, new_method
+          end
+        end
+
+        deprecate_methods(target_module, method_hash)
+      end
+    end
+
+    class FieldDeprecation < DeprecationBase
+      # this is a convenience deprecator for deprecated proto fields
+
+      def deprecate_method(target_module, method_name)
+        deprecate_methods(target_module, method_name => target_module)
+      end
+
+      private
+
+      def deprecated_method_warning(method_name, target_module)
+        "#{target_module.name}##{method_name} field usage is deprecated"
+      end
+    end
+  else
+    # TODO: remove this clause when Rails < 4 support is no longer needed
+    deprecator = ::ActiveSupport::Deprecation.clone
+    deprecator.instance_eval do
+      def new(deprecation_horizon = nil, *)
+        self.deprecation_horizon = deprecation_horizon if deprecation_horizon
+        self
+      end
+    end
+    Deprecation = deprecator.clone
+    FieldDeprecation = deprecator.clone
+
+    Deprecation.instance_eval do
+      def define_deprecated_methods(target_module, method_hash)
+        target_module.module_eval do
+          method_hash.each do |old_method, new_method|
+            alias_method old_method, new_method
+          end
+        end
+
+        deprecate_methods(target_module, method_hash)
+      end
+    end
+
+    FieldDeprecation.instance_eval do
+      def deprecate_method(target_module, method_name)
+        deprecate_methods(target_module, method_name => target_module)
+      end
+
+      private
+
+      def deprecated_method_warning(method_name, target_module)
+        "#{target_module.name}##{method_name} field usage is deprecated"
+      end
+    end
+  end
+
+  def self.deprecator
+    @deprecator ||= Deprecation.new('4.0', to_s).tap do |deprecation|
+      deprecation.silenced = ENV.key?('PB_IGNORE_DEPRECATIONS')
+      deprecation.behavior = :stderr
+    end
+  end
+
+  def self.field_deprecator
+    @field_deprecator ||= FieldDeprecation.new.tap do |deprecation|
+      deprecation.silenced = ENV.key?('PB_IGNORE_DEPRECATIONS')
+      deprecation.behavior = :stderr
+    end
+  end
+
+  # Print Deprecation Warnings
+  #
+  # Default: true
+  #
+  # Simple boolean to define whether we want field deprecation warnings to
+  # be printed to stderr or not. The rpc_server has an option to set this value
+  # explicitly, or you can turn this option off by setting
+  # ENV['PB_IGNORE_DEPRECATIONS'] to a non-empty value.
+  #
+  # The rpc_server option will override the ENV setting.
+  def self.print_deprecation_warnings?
+    !field_deprecator.silenced
+  end
+
+  def self.print_deprecation_warnings=(value)
+    field_deprecator.silenced = !value
+  end
+end

data/lib/protobuf/descriptors/google/protobuf/compiler/plugin.pb.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf'
+
+
+##
+# Imports
+#
+require 'google/protobuf/descriptor.pb'
+
+module CSGoogle
+  module Protobuf
+    module Compiler
+      ::Protobuf::Optionable.inject(self) { ::CSGoogle::Protobuf::FileOptions }
+
+      ##
+      # Message Classes
+      #
+      class Version < ::Protobuf::Message; end
+      class CodeGeneratorRequest < ::Protobuf::Message; end
+      class CodeGeneratorResponse < ::Protobuf::Message
+        class Feature < ::Protobuf::Enum
+          define :FEATURE_NONE, 0
+          define :FEATURE_PROTO3_OPTIONAL, 1
+        end
+
+        class File < ::Protobuf::Message; end
+
+      end
+
+
+
+      ##
+      # File Options
+      #
+      set_option :java_package, "com.google.protobuf.compiler"
+      set_option :java_outer_classname, "PluginProtos"
+      set_option :go_package, "google.golang.org/protobuf/types/pluginpb"
+
+
+      ##
+      # Message Fields
+      #
+      class Version
+        optional :int32, :major, 1
+        optional :int32, :minor, 2
+        optional :int32, :patch, 3
+        optional :string, :suffix, 4
+      end
+
+      class CodeGeneratorRequest
+        repeated :string, :file_to_generate, 1
+        optional :string, :parameter, 2
+        repeated ::CSGoogle::Protobuf::FileDescriptorProto, :proto_file, 15
+        optional ::CSGoogle::Protobuf::Compiler::Version, :compiler_version, 3
+      end
+
+      class CodeGeneratorResponse
+        class File
+          optional :string, :name, 1
+          optional :string, :insertion_point, 2
+          optional :string, :content, 15
+          optional ::CSGoogle::Protobuf::GeneratedCodeInfo, :generated_code_info, 16
+        end
+
+        optional :string, :error, 1
+        optional :uint64, :supported_features, 2
+        repeated ::CSGoogle::Protobuf::Compiler::CodeGeneratorResponse::File, :file, 15
+      end
+
+    end
+
+  end
+
+end
+