contrast-agent 6.6.4 → 6.8.0

data/lib/protobuf/generators/file_generator.rb

@@ -1,262 +0,0 @@
-require 'set'
-require 'protobuf/generators/base'
-require 'protobuf/generators/group_generator'
-
-module Protobuf
-  module Generators
-    class FileGenerator < Base
-
-      attr_reader :output_file
-
-      def initialize(*args)
-        super
-        @output_file = ::CSGoogle::Protobuf::Compiler::CodeGeneratorResponse::File.new(:name => file_name)
-        @extension_fields = Hash.new { |h, k| h[k] = [] }
-        @known_messages = {}
-        @known_enums = {}
-        @dangling_messages = {}
-      end
-
-      def file_name
-        convert_filename(descriptor.name, false)
-      end
-
-      def compile
-        run_once(:compile) do
-          map_extensions(descriptor, [descriptor.package])
-
-          print_file_comment
-          print_generic_requires
-          print_import_requires
-
-          print_package do
-            inject_optionable
-            group = GroupGenerator.new(current_indent)
-            group.add_options(descriptor.options) if descriptor.options
-            group.add_enums(descriptor.enum_type, :namespace => [descriptor.package])
-            group.add_message_declarations(descriptor.message_type)
-            group.add_messages(descriptor.message_type, :extension_fields => @extension_fields, :namespace => [descriptor.package])
-            group.add_extended_messages(unknown_extensions)
-            group.add_services(descriptor.service)
-
-            group.add_header(:enum, 'Enum Classes')
-            group.add_header(:message_declaration, 'Message Classes')
-            group.add_header(:options, 'File Options')
-            group.add_header(:message, 'Message Fields')
-            group.add_header(:extended_message, 'Extended Message Fields')
-            group.add_header(:service, 'Service Classes')
-            print group.to_s
-          end
-
-        end
-      end
-
-      def unknown_extensions
-        @unknown_extensions ||= @extension_fields.map do |message_name, fields|
-          message_klass = modulize(message_name).safe_constantize
-          if message_klass
-            unknown_fields = fields.reject do |field|
-              @known_messages[message_name] && message_klass.get_field(field.name, true)
-            end
-            [message_name, unknown_fields]
-          else
-            [message_name, fields]
-          end
-        end
-      end
-
-      def generate_output_file
-        compile
-        output_file.content = to_s
-        output_file
-      end
-
-      # Recursively map out all extensions known in this file.
-      # The key is the type_name of the message being extended, and
-      # the value is an array of field descriptors.
-      #
-      def map_extensions(descriptor, namespaces)
-        if fully_qualified_token?(descriptor.name)
-          fully_qualified_namespace = descriptor.name
-        elsif !(namespace = namespaces.reject(&:empty?).join(".")).empty?
-          fully_qualified_namespace = ".#{namespace}"
-        end
-        # Record all the message descriptor name's we encounter (should be the whole tree).
-        if descriptor.is_a?(::CSGoogle::Protobuf::DescriptorProto)
-          @known_messages[fully_qualified_namespace || descriptor.name] = descriptor
-        elsif descriptor.is_a?(::CSGoogle::Protobuf::EnumDescriptorProto)
-          @known_enums[fully_qualified_namespace || descriptor.name] = descriptor
-          return
-        end
-
-        descriptor.extension.each do |field_descriptor|
-          unless fully_qualified_token?(field_descriptor.name) && fully_qualified_namespace
-            field_descriptor.name = "#{fully_qualified_namespace}.#{field_descriptor.name}"
-          end
-          @extension_fields[field_descriptor.extendee] << field_descriptor
-        end
-
-        [:message_type, :nested_type, :enum_type].each do |type|
-          next unless descriptor.respond_to_has_and_present?(type)
-
-          descriptor.public_send(type).each do |type_descriptor|
-            map_extensions(type_descriptor, (namespaces + [type_descriptor.name]))
-          end
-        end
-      end
-
-      def print_file_comment
-        puts "# encoding: utf-8"
-        puts
-        puts "##"
-        puts "# This file is auto-generated. DO NOT EDIT!"
-        puts "#"
-      end
-
-      def print_generic_requires
-        print_require("protobuf")
-        print_require("protobuf/rpc/service") if descriptor.service.count > 0
-        puts
-      end
-
-      def print_import_requires
-        return if descriptor.dependency.empty?
-
-        header "Imports"
-
-        descriptor.dependency.each do |dependency|
-          print_require(convert_filename(dependency), ENV.key?('PB_REQUIRE_RELATIVE'))
-        end
-
-        puts
-      end
-
-      def print_package(&block)
-        namespaces = descriptor.package.split('.')
-        if namespaces.empty? && ENV.key?('PB_ALLOW_DEFAULT_PACKAGE_NAME')
-          namespaces = [File.basename(descriptor.name).sub('.proto', '')]
-        end
-        namespaces.reverse.reduce(block) do |previous, namespace|
-          -> { print_module(namespace, &previous) }
-        end.call
-      end
-
-      def eval_unknown_extensions!
-        @@evaled_dependencies ||= Set.new # rubocop:disable Style/ClassVars
-        @@all_messages ||= {} # rubocop:disable Style/ClassVars
-        @@all_enums ||= {} # rubocop:disable Style/ClassVars
-
-        map_extensions(descriptor, [descriptor.package])
-        @known_messages.each do |name, descriptor|
-          @@all_messages[name] = descriptor
-        end
-        @known_enums.each do |name, descriptor|
-          @@all_enums[name] = descriptor
-        end
-
-        # create package namespace
-        print_package {}
-        eval_code
-
-        unknown_extensions.each do |extendee, fields|
-          eval_dependencies(extendee)
-          fields.each do |field|
-            eval_dependencies(field.type_name)
-          end
-        end
-        group = GroupGenerator.new(0)
-        group.add_extended_messages(unknown_extensions, false)
-        print group.to_s
-        eval_code
-      rescue => e
-        warn "Error loading unknown extensions #{descriptor.name.inspect} error=#{e}"
-        raise e
-      end
-
-      private
-
-      def convert_filename(filename, for_require = true)
-        filename.sub(/\.proto/, (for_require ? '.pb' : '.pb.rb'))
-      end
-
-      def fully_qualified_token?(token)
-        token[0] == '.'
-      end
-
-      def eval_dependencies(name, namespace = nil)
-        name = "#{namespace}.#{name}" if namespace && !fully_qualified_token?(name)
-        return if name.empty? || @@evaled_dependencies.include?(name) || modulize(name).safe_constantize
-
-        # if name = .foo.bar.Baz look for classes / modules named ::Foo::Bar and ::Foo
-        # module == pure namespace (e.g. the descriptor package name)
-        # class == nested messages
-        create_ruby_namespace_heiarchy(name)
-
-        if (message = @@all_messages[name])
-          # Create the blank namespace in case there are nested types
-          eval_message_code(name)
-
-          message.nested_type.each do |nested_type|
-            eval_dependencies(nested_type.name, name) unless nested_type.name.empty?
-          end
-          message.field.each do |field|
-            eval_dependencies(field.type_name, name) unless field.type_name.empty?
-          end
-          message.enum_type.each do |enum_type|
-            eval_dependencies(enum_type.name, name)
-          end
-
-          # Check @@evaled_dependencies again in case there was a dependency
-          # loop that already loaded this message
-          return if @@evaled_dependencies.include?(name)
-          eval_message_code(name, message.field)
-          @@evaled_dependencies << name
-
-        elsif (enum = @@all_enums[name])
-          # Check @@evaled_dependencies again in case there was a dependency
-          # loop that already loaded this enum
-          return if @@evaled_dependencies.include?(name)
-          namespace = name.split(".")
-          eval_enum_code(enum, namespace[0..-2].join("."))
-          @@evaled_dependencies << name
-        else
-          fail "Error loading unknown dependencies, could not find message or enum #{name.inspect}"
-        end
-      end
-
-      def eval_message_code(fully_qualified_namespace, fields = [])
-        group = GroupGenerator.new(0)
-        group.add_extended_messages({ fully_qualified_namespace => fields }, false)
-        print group.to_s
-        eval_code
-      end
-
-      def eval_enum_code(enum, fully_qualified_namespace)
-        group = GroupGenerator.new(0)
-        group.add_enums([enum], :namespace => [fully_qualified_namespace])
-        print group.to_s
-        eval_code(modulize(fully_qualified_namespace).safe_constantize || Object)
-      end
-
-      def eval_code(context = Object)
-        warn "#{context.inspect}.module_eval #{print_contents.inspect}" if ENV['PB_DEBUG']
-        context.module_eval print_contents.to_s
-        @io.truncate(0)
-        @io.rewind
-      end
-
-      def create_ruby_namespace_heiarchy(namespace)
-        loop do
-          namespace, _match, _tail = namespace.rpartition(".")
-          break if namespace.empty?
-          eval_dependencies(namespace)
-        end
-      end
-
-      def inject_optionable
-        return if descriptor.package.empty? && !ENV.key?('PB_ALLOW_DEFAULT_PACKAGE_NAME')
-        puts "::Protobuf::Optionable.inject(self) { ::CSGoogle::Protobuf::FileOptions }"
-      end
-    end
-  end
-end

data/lib/protobuf/generators/group_generator.rb

@@ -1,122 +0,0 @@
-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
-  module Generators
-    class GroupGenerator
-      include ::Protobuf::Generators::Printable
-
-      attr_reader :groups, :indent_level
-      attr_writer :order
-
-      def initialize(indent_level = 0)
-        @groups = Hash.new { |h, k| h[k] = [] }
-        @headers = {}
-        @comments = {}
-        @handlers = {}
-        @indent_level = indent_level
-        @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)
-        end
-      end
-
-      def add_comment(type, message)
-        @comments[type] = message
-      end
-
-      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
-
-      def add_extension_fields(field_descriptors)
-        field_descriptors.each do |field_descriptor|
-          @groups[:extension_field] << FieldGenerator.new(field_descriptor, nil, indent_level)
-        end
-      end
-
-      def add_extension_ranges(extension_ranges, &item_handler)
-        @groups[:extension_range] = extension_ranges
-        @handlers[:extension_range] = item_handler
-      end
-
-      def add_header(type, message)
-        @headers[type] = message
-      end
-
-      def add_message_declarations(descriptors)
-        descriptors.each do |descriptor|
-          # elide synthetic map entry messages (we handle map fields differently)
-          next if descriptor.options.try(:map_entry?) { false }
-          @groups[:message_declaration] << MessageGenerator.new(descriptor, indent_level, :declaration => true)
-        end
-      end
-
-      def add_message_fields(field_descriptors, msg_descriptor)
-        field_descriptors.each do |field_descriptor|
-          @groups[:field] << FieldGenerator.new(field_descriptor, msg_descriptor, indent_level)
-        end
-      end
-
-      def add_messages(descriptors, options = {})
-        descriptors.each do |descriptor|
-          # elide synthetic map entry message (we handle map fields differently)
-          next if descriptor.options.try(:map_entry?) { false }
-          @groups[:message] << MessageGenerator.new(descriptor, indent_level, options)
-        end
-      end
-
-      def add_services(service_descriptors)
-        service_descriptors.each do |service_descriptor|
-          @groups[:service] << ServiceGenerator.new(service_descriptor, indent_level)
-        end
-      end
-
-      def compile
-        @order.each do |type|
-          items = @groups[type]
-          next if items.empty?
-
-          item_handler = @handlers[type]
-
-          item_header = @headers[type]
-          header(item_header) if item_header
-
-          item_comment = @comments[type]
-          comment(item_comment) if item_comment
-
-          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
-
-      def to_s
-        compile
-        print_contents
-      end
-
-    end
-  end
-end

data/lib/protobuf/generators/message_generator.rb

@@ -1,104 +0,0 @@
-require 'protobuf/generators/base'
-require 'protobuf/generators/group_generator'
-
-module Protobuf
-  module Generators
-    class MessageGenerator < Base
-
-      def initialize(descriptor, indent_level, options = {})
-        super
-        @only_declarations = options.fetch(:declaration) { false }
-        @extension_fields = options.fetch(:extension_fields) { {} }
-      end
-
-      def compile
-        run_once(:compile) do
-          if @only_declarations
-            compile_declaration
-          else
-            compile_message
-          end
-        end
-      end
-
-      def compile_declaration
-        run_once(:compile_declaration) do
-          if printable?
-            print_class(descriptor.name, :message) do
-              group = GroupGenerator.new(current_indent)
-              group.add_enums(descriptor.enum_type, :namespace => type_namespace)
-              group.add_message_declarations(descriptor.nested_type)
-              print group.to_s
-            end
-          else
-            print_class(descriptor.name, :message)
-          end
-        end
-      end
-
-      def compile_message
-        run_once(:compile_message) do
-          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)
-              group.add_comment(:options, 'Message Options')
-              group.add_options(descriptor.options) if options?
-              group.add_message_fields(descriptor.field, descriptor)
-              self.class.validate_tags(fully_qualified_type_namespace, descriptor.field.map(&:number))
-
-              group.add_comment(:extension_range, 'Extension Fields')
-              group.add_extension_ranges(descriptor.extension_range) do |extension_range|
-                "extensions #{extension_range.start}...#{extension_range.end}"
-              end
-
-              group.add_extension_fields(message_extension_fields)
-
-              group.order = [:message, :options, :field, :extension_range, :extension_field]
-              print group.to_s
-            end
-          end
-        end
-      end
-
-      private
-
-      def extensions?
-        !message_extension_fields.empty?
-      end
-
-      def fields?
-        descriptor.field.count > 0
-      end
-
-      def options?
-        descriptor.options
-      end
-
-      def nested_enums?
-        descriptor.enum_type.count > 0
-      end
-
-      def nested_messages?
-        descriptor.nested_type.count > 0
-      end
-
-      def nested_types?
-        nested_enums? || nested_messages?
-      end
-
-      def printable?
-        if @only_declarations
-          nested_types?
-        else
-          fields? || nested_messages? || extensions? || options?
-        end
-      end
-
-      def message_extension_fields
-        @extension_fields.fetch(fully_qualified_type_namespace) { [] }
-      end
-
-    end
-  end
-end

data/lib/protobuf/generators/option_generator.rb

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

@@ -1,160 +0,0 @@
-module Protobuf
-  module Generators
-    module Printable
-
-      PARENT_CLASS_MESSAGE = "::Protobuf::Message".freeze
-      PARENT_CLASS_ENUM    = "::Protobuf::Enum".freeze
-      PARENT_CLASS_SERVICE = "::Protobuf::Rpc::Service".freeze
-
-      # Initialize the printer.
-      # Must be called by any class/module that includes the Printable module.
-      #
-      def init_printer(indent_level)
-        @io = ::StringIO.new
-        self.current_indent = indent_level.to_i
-      end
-
-      protected
-
-      attr_accessor :current_indent
-
-      private
-
-      # Print a one-line comment.
-      #
-      def comment(message)
-        puts "# #{message}"
-      end
-
-      # Print a "header" comment.
-      #
-      #   header("Lorem ipsum dolor")
-      #   ##
-      #   # Lorem ipsum dolor
-      #   #
-      def header(message)
-        puts
-        puts "##"
-        puts "# #{message}"
-        puts "#"
-      end
-
-      # Increase the indent level. An outdent will only occur if given a block
-      # (after the block is finished).
-      #
-      def indent
-        self.current_indent += 1
-        yield
-        outdent
-      end
-
-      # Take a string and upcase the first character of each namespace.
-      # Due to the nature of varying standards about how class/modules are named
-      # (e.g. CamelCase, Underscore_Case, SCREAMING_SNAKE_CASE), we only want
-      # to capitalize the first character to ensure ruby will treat the value
-      # as a constant. Otherwise we do not attempt to change the
-      # token's definition.
-      #
-      #   modulize("foo.bar.Baz") -> "::Foo::Bar::Baz"
-      #   modulize("foo.bar.baz") -> "::Foo::Bar::Baz"
-      #   modulize("foo.bar.BAZ") -> "::Foo::Bar::BAZ"
-      #
-      def modulize(name)
-        name = name.gsub(/\./, '::')
-        name = name.gsub(/(^(?:::)?[a-z]|::[a-z])/, &:upcase)
-        name
-      end
-
-      # Decrease the indent level. Cannot be negative.
-      #
-      def outdent
-        self.current_indent -= 1 unless current_indent.zero?
-      end
-
-      # Return the parent class for a given type.
-      # Valid types are :message, :enum, and :service, otherwise an error
-      # will be thrown.
-      #
-      def parent_class(type)
-        case type
-        when :message then
-          PARENT_CLASS_MESSAGE
-        when :enum then
-          PARENT_CLASS_ENUM
-        when :service then
-          PARENT_CLASS_SERVICE
-        else
-          fail "Unknown parent class type #{type}: #{caller[0..5].join("\n")}"
-        end
-      end
-
-      # Print a class or module block, indicated by type.
-      # If a class, can be given a parent class to inherit from.
-      # 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)
-        name = modulize(name)
-        block_def = "#{type} #{name}"
-        block_def += " < #{parent_class(parent_klass)}" if parent_klass
-
-        if block_given?
-          puts block_def
-          indent { yield }
-          puts "end"
-          puts
-        else
-          block_def += "; end"
-          puts block_def
-        end
-      end
-
-      # Use print_block to print a class, with optional parent class
-      # to inherit from. Accepts a block for use with print_block.
-      #
-      def print_class(name, parent_klass, &block)
-        print_block(name, parent_klass, :class, &block)
-      end
-
-      # Use print_block to print a module.
-      # Accepts a block for use with print_block.
-      #
-      def print_module(name, &block)
-        print_block(name, nil, :module, &block)
-      end
-
-      # Print a file require.
-      #
-      #   print_require('foo/bar/baz') -> "require 'foo/bar/baz'"
-      #
-      def print_require(file, relative = false)
-        puts "require#{'_relative' if relative} '#{file}'"
-      end
-
-      # Puts the given message prefixed by the indent level.
-      # If no message is given print a newline.
-      #
-      def puts(message = nil)
-        if message
-          @io.puts(("  " * current_indent) + message)
-        else
-          @io.puts
-        end
-      end
-
-      # Print the given message raw, no indent.
-      #
-      def print(contents)
-        @io.print(contents)
-      end
-
-      # Returns the contents of the underlying StringIO object.
-      #
-      def print_contents
-        @io.rewind
-        @io.read
-      end
-
-    end
-  end
-end