contrast-agent 6.6.4 → 6.8.0

data/lib/protobuf/field/varint_field.rb

@@ -1,77 +0,0 @@
-require 'protobuf/field/base_field'
-
-module Protobuf
-  module Field
-    class VarintField < BaseField
-
-      ##
-      # Constants
-      #
-      INT32_MAX  =  2**31 - 1
-      INT32_MIN  = -2**31
-      INT64_MAX  =  2**63 - 1
-      INT64_MIN  = -2**63
-      UINT32_MAX =  2**32 - 1
-      UINT64_MAX =  2**64 - 1
-
-      ##
-      # Class Methods
-      #
-
-      def self.default
-        0
-      end
-
-      def self.encode(value)
-        ::Protobuf::Varint.encode(value)
-      end
-
-      ##
-      # Public Instance Methods
-      #
-      def acceptable?(val)
-        int_val = if val.is_a?(Integer)
-                    return true if val >= 0 && val < INT32_MAX # return quickly for smallest integer size, hot code path
-                    val
-                  elsif val.is_a?(Numeric)
-                    val.to_i
-                  else
-                    Integer(val, 10)
-                  end
-
-        int_val >= self.class.min && int_val <= self.class.max
-      rescue
-        false
-      end
-
-      def coerce!(val)
-        if val.is_a?(Integer) && val >= 0 && val <= INT32_MAX
-          val
-        else
-          fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{val.class}'" unless acceptable?(val)
-
-          if val.is_a?(Integer) || val.is_a?(Numeric)
-            val.to_i
-          else
-            Integer(val, 10)
-          end
-        end
-      rescue ArgumentError
-        fail TypeError, "Expected value of type '#{type_class}' for field #{name}, but got '#{val.class}'"
-      end
-
-      def decode(value)
-        value
-      end
-
-      def encode(value)
-        ::Protobuf::Field::VarintField.encode(value)
-      end
-
-      def wire_type
-        ::Protobuf::WireType::VARINT
-      end
-
-    end
-  end
-end

data/lib/protobuf/field.rb

@@ -1,74 +0,0 @@
-require 'protobuf/field/base_field'
-require 'protobuf/field/bytes_field'
-require 'protobuf/field/float_field'
-require 'protobuf/field/message_field'
-require 'protobuf/field/varint_field'
-require 'protobuf/field/string_field'
-require 'protobuf/field/double_field'
-require 'protobuf/field/enum_field'
-require 'protobuf/field/integer_field'
-require 'protobuf/field/signed_integer_field'
-require 'protobuf/field/uint32_field'
-require 'protobuf/field/uint64_field'
-require 'protobuf/field/int32_field'
-require 'protobuf/field/int64_field'
-require 'protobuf/field/sint32_field'
-require 'protobuf/field/sint64_field'
-require 'protobuf/field/bool_field'
-require 'protobuf/field/sfixed32_field'
-require 'protobuf/field/sfixed64_field'
-require 'protobuf/field/fixed32_field'
-require 'protobuf/field/fixed64_field'
-
-module Protobuf
-  module Field
-
-    PRIMITIVE_FIELD_MAP = {
-      :double   => ::Protobuf::Field::DoubleField,
-      :float    => ::Protobuf::Field::FloatField,
-      :int32    => ::Protobuf::Field::Int32Field,
-      :int64    => ::Protobuf::Field::Int64Field,
-      :uint32   => ::Protobuf::Field::Uint32Field,
-      :uint64   => ::Protobuf::Field::Uint64Field,
-      :sint32   => ::Protobuf::Field::Sint32Field,
-      :sint64   => ::Protobuf::Field::Sint64Field,
-      :fixed32  => ::Protobuf::Field::Fixed32Field,
-      :fixed64  => ::Protobuf::Field::Fixed64Field,
-      :sfixed32 => ::Protobuf::Field::Sfixed32Field,
-      :sfixed64 => ::Protobuf::Field::Sfixed64Field,
-      :string   => ::Protobuf::Field::StringField,
-      :bytes    => ::Protobuf::Field::BytesField,
-      :bool     => ::Protobuf::Field::BoolField,
-    }.freeze
-
-    def self.build(message_class, rule, type, name, tag, simple_name, options = {})
-      field_class(type).new(message_class, rule, field_type(type), name, tag, simple_name, options)
-    end
-
-    # Returns the field class for primitives,
-    # EnumField for types that inherit from Protobuf::Enum,
-    # and MessageField for types that inherit from Protobuf::Message.
-    #
-    def self.field_class(type)
-      if PRIMITIVE_FIELD_MAP.key?(type)
-        PRIMITIVE_FIELD_MAP[type]
-      elsif type < ::Protobuf::Enum
-        EnumField
-      elsif type < ::Protobuf::Message
-        MessageField
-      elsif type < ::Protobuf::Field::BaseField
-        type
-      else
-        fail ArgumentError, "Invalid field type #{type}"
-      end
-    end
-
-    # Returns the mapped type for primitives,
-    # otherwise the given type is returned.
-    #
-    def self.field_type(type)
-      PRIMITIVE_FIELD_MAP.fetch(type) { type }
-    end
-
-  end
-end

data/lib/protobuf/generators/base.rb

@@ -1,85 +0,0 @@
-require 'protobuf/generators/printable'
-
-module Protobuf
-  module Generators
-    class Base
-      include ::Protobuf::Generators::Printable
-
-      def self.validate_tags(type_name, tags)
-        return if tags.empty?
-
-        unique_tags = tags.uniq
-
-        if unique_tags.size < tags.size
-          ::Protobuf::CodeGenerator.fatal("#{type_name} object has duplicate tags. Expected #{unique_tags.size} tags, but got #{tags.size}. Suppress with PB_NO_TAG_WARNINGS=1.")
-        end
-
-        unless ENV.key?('PB_NO_TAG_WARNINGS')
-          expected_size = tags.max - tags.min + 1
-          if tags.size < expected_size
-            ::Protobuf::CodeGenerator.print_tag_warning_suppress
-            ::Protobuf::CodeGenerator.warn("#{type_name} object should have #{expected_size} tags (#{tags.min}..#{tags.max}), but found #{tags.size} tags.")
-          end
-        end
-      end
-
-      attr_reader :descriptor, :namespace, :options
-
-      def initialize(descriptor, indent_level = 0, options = {})
-        @descriptor = descriptor
-        @options = options
-        @namespace = @options.fetch(:namespace) { [] }
-        init_printer(indent_level)
-      end
-
-      def fully_qualified_type_namespace
-        ".#{type_namespace.join('.')}"
-      end
-
-      def run_once(label)
-        tracker_ivar = "@_#{label}_compiled"
-        value_ivar = "@_#{label}_compiled_value"
-
-        if instance_variable_get(tracker_ivar)
-          return instance_variable_get(value_ivar)
-        end
-
-        return_value = yield
-        instance_variable_set(tracker_ivar, true)
-        instance_variable_set(value_ivar, return_value)
-        return_value
-      end
-
-      def to_s
-        compile
-        print_contents # see Printable
-      end
-
-      def type_namespace
-        @type_namespace ||= @namespace + [descriptor.name]
-      end
-
-      def serialize_value(value)
-        case value
-        when Message
-          fields = value.each_field.map do |field, inner_value|
-            next unless value.field?(field.name)
-            serialized_inner_value = serialize_value(inner_value)
-            "#{field.fully_qualified_name.inspect} => #{serialized_inner_value}"
-          end.compact
-          "{ #{fields.join(', ')} }"
-        when Enum
-          "::#{value.parent_class}::#{value.name}"
-        when String
-          value.inspect
-        when nil
-          "nil"
-        when Array
-          '[' + value.map { |x| serialize_value(x) }.join(', ') + ']'
-        else
-          value
-        end
-      end
-    end
-  end
-end

data/lib/protobuf/generators/enum_generator.rb

@@ -1,39 +0,0 @@
-require 'protobuf/generators/base'
-require 'protobuf/generators/option_generator'
-
-module Protobuf
-  module Generators
-    class EnumGenerator < Base
-
-      def compile
-        run_once(:compile) do
-          tags = []
-
-          print_class(descriptor.name, :enum) do
-            if descriptor.options
-              print OptionGenerator.new(descriptor.options, current_indent).to_s
-              puts
-            end
-
-            descriptor.value.each do |enum_value_descriptor|
-              tags << enum_value_descriptor.number
-              puts build_value(enum_value_descriptor)
-            end
-          end
-
-          unless descriptor.options.try(:allow_alias)
-            self.class.validate_tags(fully_qualified_type_namespace, tags)
-          end
-        end
-      end
-
-      def build_value(enum_value_descriptor)
-        name = enum_value_descriptor.name
-        name.upcase! if ENV.key?('PB_UPCASE_ENUMS')
-        number = enum_value_descriptor.number
-        "define :#{name}, #{number}"
-      end
-
-    end
-  end
-end

data/lib/protobuf/generators/extension_generator.rb

@@ -1,27 +0,0 @@
-require 'protobuf/generators/base'
-require 'protobuf/generators/group_generator'
-
-module Protobuf
-  module Generators
-    class ExtensionGenerator < Base
-
-      def initialize(message_type, field_descriptors, indent_level)
-        super(nil, indent_level)
-        @message_type = modulize(message_type)
-        @field_descriptors = field_descriptors
-      end
-
-      def compile
-        run_once(:compile) do
-          print_class(@message_type, :message) do
-            group = GroupGenerator.new(current_indent)
-            group.add_extension_fields(@field_descriptors)
-            group.order = [:extension_field]
-            print group.to_s
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/protobuf/generators/field_generator.rb

@@ -1,193 +0,0 @@
-require 'protobuf/generators/base'
-
-module Protobuf
-  module Generators
-    class FieldGenerator < Base
-
-      ##
-      # Constants
-      #
-      PROTO_INFINITY_DEFAULT          = /^inf$/i
-      PROTO_NEGATIVE_INFINITY_DEFAULT = /^-inf$/i
-      PROTO_NAN_DEFAULT               = /^nan$/i
-      RUBY_INFINITY_DEFAULT           = '::Float::INFINITY'.freeze
-      RUBY_NEGATIVE_INFINITY_DEFAULT  = '-::Float::INFINITY'.freeze
-      RUBY_NAN_DEFAULT                = '::Float::NAN'.freeze
-
-      ##
-      # Attributes
-      #
-      attr_reader :field_options
-
-      def initialize(field_descriptor, enclosing_msg_descriptor, indent_level)
-        super(field_descriptor, indent_level)
-        @enclosing_msg_descriptor = enclosing_msg_descriptor
-      end
-
-      def applicable_options
-        # Note on the strange use of `#inspect`:
-        #   :boom.inspect #=> ":boom"
-        #   :".boom.foo".inspect #=> ":\".boom.foo\""
-        # An alternative to `#inspect` would be always adding double quotes,
-        # but the generatated code looks un-idiomatic:
-        #   ":\"#{:boom}\"" #=> ":\"boom\"" <-- Note the unnecessary double quotes
-        @applicable_options ||= field_options.map { |k, v| "#{k.inspect} => #{v}" }
-      end
-
-      def default_value
-        @default_value ||= begin
-                             if defaulted?
-                               case descriptor.type.name
-                               when :TYPE_ENUM
-                                 enum_default_value
-                               when :TYPE_STRING, :TYPE_BYTES
-                                 string_default_value
-                               when :TYPE_FLOAT, :TYPE_DOUBLE
-                                 float_double_default_value
-                               else
-                                 verbatim_default_value
-                               end
-                             end
-                           end
-      end
-
-      def defaulted?
-        descriptor.respond_to_has_and_present?(:default_value)
-      end
-
-      def deprecated?
-        descriptor.options.try(:deprecated?) { false }
-      end
-
-      def extension?
-        descriptor.respond_to_has_and_present?(:extendee)
-      end
-
-      def compile
-        run_once(:compile) do
-          field_definition = if map?
-                               ["map #{map_key_type_name}", map_value_type_name, name, number, applicable_options]
-                             else
-                               ["#{label} #{type_name}", name, number, applicable_options]
-                             end
-          puts field_definition.flatten.compact.join(', ')
-        end
-      end
-
-      def label
-        @label ||= descriptor.label.name.to_s.downcase.sub(/label_/, '') # required, optional, repeated
-      end
-
-      def name
-        @name ||= descriptor.name.to_sym.inspect
-      end
-
-      def number
-        @number ||= descriptor.number
-      end
-
-      def field_options
-        @field_options ||= begin
-                             opts = {}
-                             opts[:default] = default_value if defaulted?
-                             opts[:packed] = 'true' if packed?
-                             opts[:deprecated] = 'true' if deprecated?
-                             opts[:extension] = 'true' if extension?
-                             if descriptor.options
-                               descriptor.options.each_field do |field_option|
-                                 next unless descriptor.options.field?(field_option.name)
-                                 option_value = descriptor.options[field_option.name]
-                                 opts[field_option.fully_qualified_name] = serialize_value(option_value)
-                               end
-                             end
-                             opts
-                           end
-      end
-
-      def packed?
-        descriptor.options.try(:packed?) { false }
-      end
-
-      # Determine the field type
-      def type_name
-        @type_name ||= determine_type_name(descriptor)
-      end
-
-      # If this field is a map field, this returns a message descriptor that
-      # represents the entries in the map. Returns nil if this field is not
-      # a map field.
-      def map_entry
-        @map_entry ||= determine_map_entry
-      end
-
-      def map?
-        !map_entry.nil?
-      end
-
-      def map_key_type_name
-        return nil if map_entry.nil?
-        determine_type_name(map_entry.field.find { |v| v.name == 'key' && v.number == 1 })
-      end
-
-      def map_value_type_name
-        return nil if map_entry.nil?
-        determine_type_name(map_entry.field.find { |v| v.name == 'value' && v.number == 2 })
-      end
-
-      private
-
-      def enum_default_value
-        optionally_upcased_default =
-          if ENV.key?('PB_UPCASE_ENUMS')
-            verbatim_default_value.upcase
-          else
-            verbatim_default_value
-          end
-        "#{type_name}::#{optionally_upcased_default}"
-      end
-
-      def float_double_default_value
-        case verbatim_default_value
-        when PROTO_INFINITY_DEFAULT then
-          RUBY_INFINITY_DEFAULT
-        when PROTO_NEGATIVE_INFINITY_DEFAULT then
-          RUBY_NEGATIVE_INFINITY_DEFAULT
-        when PROTO_NAN_DEFAULT then
-          RUBY_NAN_DEFAULT
-        else
-          verbatim_default_value
-        end
-      end
-
-      def string_default_value
-        %("#{verbatim_default_value.gsub(/'/, '\\\\\'')}")
-      end
-
-      def verbatim_default_value
-        descriptor.default_value
-      end
-
-      def determine_type_name(descriptor)
-        case descriptor.type.name
-        when :TYPE_MESSAGE, :TYPE_ENUM, :TYPE_GROUP then
-          modulize(descriptor.type_name)
-        else
-          type_name = descriptor.type.name.to_s.downcase.sub(/^type_/, '')
-          ":#{type_name}"
-        end
-      end
-
-      def determine_map_entry
-        return nil if @enclosing_msg_descriptor.nil?
-        return nil unless descriptor.label.name == :LABEL_REPEATED && descriptor.type.name == :TYPE_MESSAGE
-        # find nested message type
-        name_parts = descriptor.type_name.split(".")
-        return nil if name_parts.size < 2 || name_parts[-2] != @enclosing_msg_descriptor.name
-        nested = @enclosing_msg_descriptor.nested_type.find { |e| e.name == name_parts[-1] }
-        return nested if !nested.nil? && nested.options.try(:map_entry?)
-        nil
-      end
-
-    end
-  end
-end