protobuf-core 3.5.0

data/lib/protobuf/generators/file_generator.rb

@@ -0,0 +1,132 @@
+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 = ::Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(:name => file_name)
+        @extension_fields = Hash.new { |h, k| h[k] = [] }
+        @known_messages = []
+        @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
+            group = GroupGenerator.new(current_indent)
+            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_header(:enum, 'Enum Classes')
+            group.add_header(:message_declaration, 'Message Classes')
+            group.add_header(:message, 'Message Fields')
+            group.add_header(:extended_message, 'Extended Message Fields')
+            print group.to_s
+          end
+
+        end
+      end
+
+      def unknown_extensions
+        @unknown_extensions ||= @extension_fields.reject do |k, _|
+          @known_messages.include?(k)
+        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)
+        # Record all the message descriptor name's we encounter (should be the whole tree).
+        if descriptor.is_a?(::Google::Protobuf::DescriptorProto)
+          if fully_qualified_token?(descriptor.name)
+            @known_messages << descriptor.name
+          else
+            fully_qualified_namespace = ".#{namespaces.join('.')}"
+            @known_messages << fully_qualified_namespace
+          end
+        end
+
+        descriptor.extension.each do |field_descriptor|
+          @extension_fields[field_descriptor.extendee] << field_descriptor
+        end
+
+        [:message_type, :nested_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/message")
+        puts
+      end
+
+      def print_import_requires
+        return if descriptor.dependency.empty?
+
+        header "Imports"
+
+        descriptor.dependency.each do |dependency|
+          print_require(convert_filename(dependency))
+        end
+
+        puts
+      end
+
+      def print_package(&block)
+        namespaces = descriptor.package.split('.')
+        namespaces.reverse.reduce(block) do |previous, namespace|
+          -> { print_module(namespace, &previous) }
+        end.call
+      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
+
+    end
+  end
+end

data/lib/protobuf/generators/group_generator.rb

@@ -0,0 +1,105 @@
+require 'protobuf/generators/enum_generator'
+require 'protobuf/generators/extension_generator'
+require 'protobuf/generators/field_generator'
+require 'protobuf/generators/message_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, :message, :extended_message, :service]
+        init_printer(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)
+        extended_messages.each do |message_type, field_descriptors|
+          @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, 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|
+          @groups[:message_declaration] << MessageGenerator.new(descriptor, indent_level, :declaration => true)
+        end
+      end
+
+      def add_message_fields(field_descriptors)
+        field_descriptors.each do |field_descriptor|
+          @groups[:field] << FieldGenerator.new(field_descriptor, indent_level)
+        end
+      end
+
+      def add_messages(descriptors, options = {})
+        descriptors.each do |descriptor|
+          @groups[:message] << MessageGenerator.new(descriptor, indent_level, options)
+        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
+        end
+      end
+
+      def to_s
+        compile
+        print_contents
+      end
+
+    end
+  end
+end

data/lib/protobuf/generators/message_generator.rb

@@ -0,0 +1,98 @@
+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_message_fields(descriptor.field)
+              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, :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 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?
+        end
+      end
+
+      def message_extension_fields
+        @extension_fields.fetch(fully_qualified_type_namespace) { [] }
+      end
+
+    end
+  end
+end

data/lib/protobuf/generators/printable.rb

@@ -0,0 +1,160 @@
+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])/) { |match| match.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, &block)
+        name = modulize(name)
+        block_def = "#{type} #{name}"
+        block_def += " < #{parent_class(parent_klass)}" if parent_klass
+
+        if block_given?
+          puts block_def
+          indent { block.call }
+          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)
+        puts "require '#{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