protobug-compiler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c3c9d32d7ba7357c9bda140e4b67634871c4ea151c0a35684f9a6dd9030f53a
+  data.tar.gz: 58b29936acaffa8906497d83488d4f9bf2a46d3ff4418f6680905c688ed84209
+SHA512:
+  metadata.gz: 33ad398f7e589f6cfb6b1a67473dd28d5c81d3bf5714b7f4cbc31a0fb2524dfa953babbea5853c2772b5dcb2bce9849fee35ccb089b4743f205cdb7455932af4
+  data.tar.gz: 034d83ffaa55fb291437704742fe62185584e18c451b2346fbacb5f830105afe10297226f063b2ac8e7a25d9d8788fb2f4c9837622a528211933bf9c390971a8

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# protobug-compiler Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2024-03-06
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Samuel Giddins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/exe/protoc-gen-protobug

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "protobug_compiler_protos"
+require "protobug/compiler"
+
+compiler_registry = Protobug::Registry.new do |registry|
+  Google::Protobuf::Compiler.register_plugin_protos(registry)
+end
+
+request = Google::Protobuf::Compiler::CodeGeneratorRequest.decode($stdin, registry: compiler_registry)
+SimpleCov.command_name "protoc-gen-protobug:#{Digest::SHA256.hexdigest(request.to_json)}" if defined?(SimpleCov)
+
+response = Protobug::Compiler.compile!(request)
+
+$stdout.print response.class.encode(response)

data/lib/protobug/compiler/builder.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "forwardable"
+require "prettier_print"
+
+module Protobug
+  class Compiler
+    module Builder
+      def self.build_file
+        builder = File.new
+        if block_given?
+          yield builder
+          builder.render
+        else
+          builder
+        end
+      end
+
+      class Statement
+        attr_reader :items
+
+        def initialize
+          @items = []
+        end
+
+        def comment(text)
+          append Comment.new(text)
+        end
+
+        def empty
+          append Token.new(type: :empty, content: "")
+        end
+
+        def identifier(name)
+          append Token.new(type: :identifier, content: name)
+        end
+
+        def literal(content)
+          append Token.new(type: :literal, content: content)
+        end
+
+        def block(&blk)
+          append Group.new(
+            name: "block", items: [], close: "end", multi: true, indent: 2
+          ).tap(&blk)
+        end
+
+        def dot(name)
+          append(Token.new(type: :delimiter, content: ".")).identifier(name)
+        end
+
+        def op(operator)
+          append Token.new(type: :operator, content: operator)
+        end
+
+        def render(q) # rubocop:disable Naming/MethodParameterName
+          first = true
+          prev = nil
+          q.group do
+            items.each do |item|
+              next if item.empty?
+
+              if !first && !item.compact? && !prev&.compact?
+                if (item.is_a?(Token) && item.type == :operator) || (prev.is_a?(Token) && prev.type == :operator) ||
+                   item.is_a?(Comment)
+                  q.text " "
+                elsif !(item.is_a?(Group) && item.name == :call) && !(item.is_a?(Group) && item.multi)
+                  q.fill_breakable " "
+                end
+              end
+              first = false unless item.compact? || prev&.compact?
+              prev = item
+
+              item.render(q)
+            end
+          end
+        end
+
+        def append(item)
+          items << item
+          self
+        end
+
+        def empty?
+          items.none? { |item| !item.empty? }
+        end
+
+        def compact? = false
+      end
+
+      Group = Struct.new(:name, :items, :open, :close, :separator, :multi, :indent,
+                         keyword_init: true) do
+        include Builder
+
+        def comment(text)
+          append Statement.new.comment(text)
+        end
+
+        def empty
+          append Statement.new.empty
+        end
+
+        def block(&blk)
+          append Statement.new.block(&blk)
+        end
+
+        def identifier(name)
+          append Statement.new.identifier(name)
+        end
+
+        def literal(content)
+          append Statement.new.literal(content)
+        end
+
+        def op(operator)
+          append Statement.new.op(operator)
+        end
+
+        def render(q) # rubocop:disable Naming/MethodParameterName
+          if name == "block" && empty?
+            q.breakable "; "
+            q.text "end"
+          end
+
+          q.group do
+            q.text open if open
+            q.nest(indent || 0) do
+              write_items(q)
+            end
+            return unless close
+
+            multi ? q.breakable_force : q.breakable_empty
+            q.text close
+          end
+        end
+
+        def append(item)
+          items << item
+          item
+        end
+
+        def empty?
+          return false if name != :call && (open || close)
+
+          items.none? { |item| !item.empty? }
+        end
+
+        def compact? = false
+
+        private
+
+        def write_items(q) # rubocop:disable Naming/MethodParameterName
+          multi ? q.breakable_force : q.breakable_empty
+          q.seplist(items.reject(&:empty?), lambda {
+                                              if separator == "\n" || multi
+                                                q.breakable_force
+                                              elsif separator
+                                                q.text separator.rstrip
+                                                if separator.end_with?(" ")
+                                                  q.breakable
+                                                else
+                                                  q.breakable_empty
+                                                end
+                                              end
+                                            }, :each) do |item|
+            item.render(q)
+          end
+        end
+      end
+
+      class File < DelegateClass(Group)
+        def initialize
+          @headers = []
+          super(Group.new(name: "file", items: [], multi: true))
+        end
+
+        def header_comment(text)
+          @headers << text
+        end
+
+        def render
+          q = PrettierPrint.new(+"")
+          @headers.each_with_index do |header, idx|
+            q.breakable_force if idx.positive?
+            Comment.new(header).render(q)
+            q.breakable_force
+          end
+          super(q)
+          q.trim
+          q.breakable_force
+          q.flush
+          q.output
+        end
+      end
+
+      Comment = Struct.new(:comment) do
+        def render(q) # rubocop:disable Naming/MethodParameterName
+          if comment.start_with?("#")
+            q.text(comment)
+          else
+            prefixed = comment.start_with?(" ")
+
+            q.group do
+              q.break_parent
+              q.seplist(
+                comment.chomp.gsub(/^/m, prefixed ? "#" : "# ").tap do |s|
+                  s.gsub!(/^#\s*$/m, "#")
+                end.each_line(chomp: true),
+                -> { q.breakable_empty }
+              ) do |line|
+                q.text line
+              end
+            end
+          end
+        end
+
+        def empty? = false
+        def compact? = false
+      end
+
+      Token = Struct.new(:type, :content,
+                         keyword_init: true) do
+        def render(q) # rubocop:disable Naming/MethodParameterName
+          case type
+          when :empty, :keyword, :identifier, :delimiter, :operator
+            q.text content
+          when :literal
+            case content
+            when Integer
+              int_part = Integer(content)
+              formatted_int = int_part.abs.to_s.reverse.gsub(/...(?=.)/, '\&_').reverse
+              formatted_int.insert(0, "-") if int_part.negative?
+              q.text formatted_int
+            else
+              q.text content.inspect
+            end
+          else
+            raise "Unknown token type: #{type}"
+          end
+        end
+
+        def empty? = false
+
+        COMPACT_OPERATORS = %w[** .. ...].freeze # rubocop:disable Lint/ConstantDefinitionInBlock
+
+        def compact?
+          case type
+          when :operator
+            COMPACT_OPERATORS.include?(content)
+          when :delimiter
+            content == "."
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "builder_gen"

data/lib/protobug/compiler/builder_gen.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Protobug
+  class Compiler
+    module Builder
+      class Statement
+        def _class
+          append Token.new(type: :keyword, content: "class")
+        end
+
+        def _def
+          append Token.new(type: :keyword, content: "def")
+        end
+
+        def _module
+          append Token.new(type: :keyword, content: "module")
+        end
+
+        def parens(item, &blk)
+          append Group.new(
+            name: :parens,
+            items: [item],
+            open: "(",
+            close: ")",
+            indent: 2
+          ).tap(&blk)
+        end
+
+        def list(*items, &blk)
+          append Group.new(
+            name: :list,
+            items: items,
+            separator: ",",
+            indent: 2
+          ).tap(&blk)
+        end
+
+        def index(*items, &blk)
+          append Group.new(
+            name: :index,
+            items: items,
+            open: "[",
+            close: "]",
+            separator: ","
+          ).tap(&blk)
+        end
+
+        def call(*args, &blk)
+          append Group.new(
+            name: :call,
+            items: args,
+            open: "(",
+            close: ")",
+            separator: ", ",
+            indent: 2
+          ).tap(&blk)
+        end
+      end
+
+      class Group
+        def _class
+          append Statement.new._class
+        end
+
+        def _def
+          append Statement.new._def
+        end
+
+        def _module
+          append Statement.new._module
+        end
+      end
+    end
+  end
+end

data/lib/protobug/compiler.rb

@@ -0,0 +1,500 @@
+# frozen_string_literal: true
+
+require "protobug_compiler_protos"
+
+require_relative "compiler/builder"
+
+module Protobug
+  class Compiler
+    def self.compile!(request)
+      response = Google::Protobuf::Compiler::CodeGeneratorResponse.new
+      begin
+        new(request, response).compile!
+      rescue StandardError => e
+        response.error = e.full_message
+      end
+      response
+    end
+
+    def initialize(request, response)
+      @request = request
+      @response = response
+    end
+
+    attr_reader :request, :response, :files
+
+    class Files
+      def initialize
+        @descs_by_name = {}
+        @files_by_path = {}
+        @num_files = 0
+      end
+
+      def register_file(file)
+        @files_by_path[file.name] = register_decl(FileDescriptorProto.new(file, nil, path: []))
+      end
+
+      def fetch(name)
+        @files_by_path.fetch(name)
+      end
+
+      def fetch_type(name)
+        @descs_by_name.fetch(name)
+      end
+
+      def register_decl(decl)
+        raise ArgumentError, "parent must be a Descriptor" if decl.parent && !decl.parent.is_a?(Descriptor)
+
+        unless decl.is_a?(FileDescriptorProto)
+          raise "already registered: #{decl.full_name}" if @descs_by_name[decl.full_name]
+
+          @descs_by_name[decl.full_name] = decl
+        end
+
+        decl.each_declaration do |d|
+          register_decl(d)
+        end
+        decl
+      end
+    end
+
+    module Descriptor
+      attr_reader :descriptor, :parent, :file, :source_loc
+
+      def initialize(descriptor, parent, path:)
+        unless descriptor.is_a?(self.class.descriptor_class)
+          raise ArgumentError,
+                "#{descriptor.class} (#{descriptor}) is not #{self.class.descriptor_class}"
+        end
+
+        raise ArgumentError, "parent must be a Descriptor" if parent && !parent.is_a?(Descriptor)
+
+        @descriptor = descriptor
+        @parent = parent
+        @file = parent&.file || self
+        @path = path
+
+        super(descriptor)
+
+        @source_loc = if parent
+                        file.source_code_info.location.find do |loc|
+                          loc.path == path
+                        end
+                      else
+                        source_code_info.location[1]
+                      end
+      end
+
+      def full_name
+        if parent
+          "#{parent.full_name}.#{name}"
+        else
+          descriptor.package
+        end
+      end
+
+      def to_constant
+        if parent
+          "#{parent.to_constant}::#{name}"
+        else
+          return file.options.ruby_package if file.options&.ruby_package?
+
+          parts = descriptor.package.split(".")
+          parts.map! do |part|
+            part.split("_").map(&:capitalize).join
+          end
+          parts.join("::")
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          methods = []
+
+          fields_by_name.each do |name, field|
+            unless field.is_a?(Field::MessageField) &&
+                   /\Agoogle\.protobuf\.([^.]*Descriptor[^.]*)\z/ =~ field.message_type
+              next
+            end
+            raise "expected #{self}.#{name} to be repeated" unless field.repeated?
+
+            message_name = Regexp.last_match(1)
+
+            methods << name
+
+            define_method(name) do
+              field_type = Compiler.const_get(message_name)
+              super().map.with_index { |d, idx| field_type.new(d, self, path: @path + [field.number, idx]) }
+            end
+          end
+
+          define_method(:each_declaration) do |&blk|
+            return enum_for(__method__) unless blk # rubocop:disable Lint/ToEnumArguments
+
+            decls = methods.flat_map { send(_1) }
+            decls.sort_by! { |d| d.source_loc&.span || [] }
+            decls.each(&blk)
+            nil
+          end
+        end
+      end
+
+      module ClassMethods
+        def descriptor_class
+          Google::Protobuf.const_get(name.split("::").last)
+        end
+
+        def fields_by_number = descriptor_class.fields_by_number
+        def fields_by_name = descriptor_class.fields_by_name
+      end
+    end
+
+    class FileDescriptorProto < DelegateClass(Google::Protobuf::FileDescriptorProto)
+      include Descriptor
+
+      def file_name
+        ruby_package = options.ruby_package if options&.ruby_package?
+        prefix = if ruby_package
+                   ruby_package.split("::").map!(&:downcase).join("/")
+                 else
+                   package.split(".").map!(&:downcase).join("/")
+                 end
+        name.gsub(%r{^.*?([^/]+)\.proto$}, "#{prefix}/\\1_pb.rb")
+      end
+
+      def loc_by_path(path)
+        source_code_info.location.find { |loc| loc.path == path }
+      end
+
+      attr_accessor :file_to_generate
+    end
+
+    class DescriptorProto < DelegateClass(Google::Protobuf::DescriptorProto)
+      include Descriptor
+    end
+
+    class FieldDescriptorProto < DelegateClass(Google::Protobuf::FieldDescriptorProto)
+      include Descriptor
+    end
+
+    class EnumDescriptorProto < DelegateClass(Google::Protobuf::EnumDescriptorProto)
+      include Descriptor
+    end
+
+    class EnumValueDescriptorProto < DelegateClass(Google::Protobuf::EnumValueDescriptorProto)
+      include Descriptor
+    end
+
+    class ServiceDescriptorProto < DelegateClass(Google::Protobuf::ServiceDescriptorProto)
+      include Descriptor
+    end
+
+    class OneofDescriptorProto < DelegateClass(Google::Protobuf::OneofDescriptorProto)
+      include Descriptor
+    end
+
+    def compile!
+      response.supported_features |=
+        Google::Protobuf::Compiler::CodeGeneratorResponse::Feature::FEATURE_PROTO3_OPTIONAL.value
+      @files = Files.new
+
+      request.proto_file.each do |file|
+        files.register_file(file)
+      end
+
+      request.file_to_generate.each do |name|
+        files.fetch(name).file_to_generate = true
+      end
+
+      request.file_to_generate.each do |name| # rubocop:disable Style/CombinableLoops
+        file = files.fetch(name)
+        file_out = Google::Protobuf::Compiler::CodeGeneratorResponse::File.new
+        file_out.name = file.file_name
+        file_out.content = file_contents(files, file)
+        response.add_file(file_out)
+      end
+    end
+
+    def emit_decls(descriptor, group)
+      source_loc = descriptor.source_loc
+      return unless source_loc
+
+      source_loc.leading_detached_comments&.each do |c|
+        group.comment(c)
+        group.empty
+      end
+
+      group.comment(source_loc.leading_comments) if source_loc.leading_comments?
+
+      case descriptor
+      when DescriptorProto
+        group._class.identifier(descriptor.name).block do |g|
+          g.identifier("extend").identifier("Protobug::Message")
+          g.empty
+          g.identifier("self").dot("full_name").op("=").literal(descriptor.full_name)
+
+          requires_empty = true
+          descriptor.each_declaration do |decl|
+            g.empty if requires_empty
+            requires_empty = emit_decls(decl, g) &&
+                             !decl.is_a?(FieldDescriptorProto) && !decl.is_a?(OneofDescriptorProto)
+          end
+
+          if descriptor.reserved_range.any? || descriptor.reserved_name.any?
+            g.empty
+            descriptor.file.loc_by_path(descriptor.source_loc.path +
+                                        [DescriptorProto.fields_by_name.fetch("reserved_range").number])&.tap do |loc|
+              g.comment(loc.leading_comments) if loc.leading_comments?
+            end
+            descriptor.reserved_range.each_with_index do |range, idx|
+              descriptor.file.loc_by_path(descriptor.source_loc.path + [
+                DescriptorProto.fields_by_name.fetch("reserved_range").number, idx
+              ]).tap do |loc|
+                g.comment(loc.leading_comments) if loc.leading_comments?
+              end
+              g.identifier("reserved_range").call do |c|
+                c.literal(range.start).op("...").literal(range.end)
+              end
+            end
+            descriptor.reserved_name.each do |name|
+              g.identifier("reserved_name").call do |c|
+                c.literal(name)
+              end
+            end
+          end
+        end
+      when EnumDescriptorProto
+        group._class.identifier(descriptor.name).block do |g|
+          g.identifier("extend").identifier("Protobug::Enum")
+          g.empty
+          g.identifier("self").dot("full_name").op("=")
+           .literal(descriptor.full_name)
+          g.empty
+
+          descriptor.each_declaration do |decl|
+            emit_decls(decl, g)
+          end
+
+          if descriptor.reserved_range.any? || descriptor.reserved_name.any?
+            g.empty
+            descriptor.reserved_range.each do |range|
+              g.identifier("reserved_range").call do |c|
+                c.literal(range.start).op("..").literal(range.end - 1)
+              end
+            end
+            descriptor.reserved_name.each do |name|
+              g.identifier("reserved_name").call do |c|
+                c.literal(name)
+              end
+            end
+          end
+        end
+      when EnumValueDescriptorProto
+        const_name = descriptor.name.start_with?("k") ? "K_#{descriptor.name[1..]}" : descriptor.name
+        const_name = "K_#{const_name}" unless const_name.match?(/\A[A-Z]/)
+        group.identifier(const_name).op("=").identifier("new").call do |c|
+          c.literal(descriptor.name)
+          c.literal(descriptor.number)
+        end.dot("freeze")
+      when FieldDescriptorProto
+        if descriptor.extendee?
+          containing_type = files.fetch_type(
+            if descriptor.extendee.start_with?(".")
+              descriptor.extendee[1..]
+            else
+              "#{descriptor.parent.full_name}.#{descriptor.extendee}"
+            end
+          )
+          group.comment("extension: #{containing_type.full_name}\n  #{descriptor.name} #{descriptor.number}")
+          return # rubocop:disable Lint/NonLocalExitFromIterator
+        end
+
+        type = descriptor.type.name.downcase.delete_prefix("type_").to_sym
+
+        if descriptor.type_name?
+          referenced_type = files.fetch_type(descriptor.type_name.delete_prefix("."))
+          type = :map unless referenced_type.source_loc
+        end
+
+        group.identifier(
+          case descriptor.label
+          when Google::Protobuf::FieldDescriptorProto::Label::LABEL_OPTIONAL
+            "optional"
+          when Google::Protobuf::FieldDescriptorProto::Label::LABEL_REPEATED
+            if type == :map
+              "map"
+            else
+              "repeated"
+            end
+          when Google::Protobuf::FieldDescriptorProto::Label::LABEL_REQUIRED
+            "required"
+          else
+            raise "Unknown label: #{descriptor.label}"
+          end
+        ).call do |c|
+          c.literal(descriptor.number)
+          c.literal(descriptor.name)
+          c.identifier("type:").literal(type) unless type == :map
+
+          if type == :map
+            c.identifier("key_type:")
+             .literal(referenced_type.field[0].type.name.downcase.delete_prefix("type_").to_sym)
+            value_type = referenced_type.field[1].type.name.downcase.delete_prefix("type_").to_sym
+            c.identifier("value_type:")
+             .literal(value_type)
+            if referenced_type.field[1].type_name?
+              c.identifier("#{value_type}_type:")
+               .literal(referenced_type.field[1].type_name.delete_prefix("."))
+            end
+          elsif descriptor.type_name?
+            c.identifier("#{type}_type:").literal(descriptor.type_name.delete_prefix("."))
+          end
+
+          packed = descriptor.options&.packed
+          # TODO: exclude other types that cannot be packed
+          if !descriptor.options&.packed? && !%i[message bytes string map].include?(type)
+            packed = descriptor.label == Google::Protobuf::FieldDescriptorProto::Label::LABEL_REPEATED &&
+                     descriptor.file.syntax == "proto3"
+          end
+          c.identifier("packed:").literal(packed) if packed
+          if descriptor.json_name? && descriptor.json_name != descriptor.name
+            c.identifier("json_name:").literal(descriptor.json_name)
+          end
+          if descriptor.oneof_index?
+            oneof = descriptor.parent.oneof_decl[descriptor.oneof_index]
+            synthetic = descriptor.proto3_optional && (descriptor.parent.field.count do |f|
+              f.oneof_index? && f.oneof_index == descriptor.oneof_index
+            end == 1)
+            c.identifier("oneof:").literal(oneof.name.to_sym) unless synthetic
+          end
+          if descriptor.label == Google::Protobuf::FieldDescriptorProto::Label::LABEL_OPTIONAL &&
+             descriptor.file.syntax == "proto3" && !descriptor.proto3_optional
+            c.identifier("proto3_optional:").literal(false)
+          end
+        end
+      when OneofDescriptorProto
+        group.empty if source_loc.leading_comments?
+        # no-op
+      else
+        raise "Unknown descriptor type: #{descriptor.class}"
+      end.tap do |s|
+        s.comment(source_loc.trailing_comments) if source_loc.trailing_comments?
+      end
+    end
+
+    def file_contents(files, file)
+      Builder.build_file do |f|
+        f.header_comment "frozen_string_literal: true"
+        f.header_comment "Code generated by protoc-gen-protobug. DO NOT EDIT."
+
+        f.comment "source: #{file.name}"
+        f.comment "syntax: #{file.syntax? ? file.syntax : "proto2"}"
+        f.comment "package: #{file.package}"
+        f.comment "options:"
+        if file.options
+          file.options.class.fields_by_name.each_key do |name|
+            next unless file.options.send(:"#{name}?")
+
+            value = case value = file.options.send(name)
+                    when Enum::InstanceMethods
+                      value.name
+                    when Symbol
+                      raise "Unknown symbol: #{value} for #{name} in #{file.options.inspect}"
+                    else
+                      value.inspect
+                    end
+
+            f.comment "   #{name}: #{value}"
+          end
+        end
+
+        file.source_loc.leading_detached_comments.each do |c|
+          f.empty
+          f.comment c
+        end
+
+        f.empty
+        f.identifier("require").literal("protobug")
+
+        local, external = file.dependency.map do |dep|
+          files.fetch(dep)
+        end.partition(&:file_to_generate)
+        if external.any?
+          f.empty
+          external.each do |dep|
+            f.identifier("require").literal(dep.file_name.delete_suffix(".rb"))
+          end
+        end
+        if local.any?
+          f.empty
+          local.each do |dep|
+            relative_path = Pathname(dep.file_name.delete_suffix(".rb"))
+                            .relative_path_from(Pathname(file.file_name).dirname)
+                            .to_path
+            f.identifier("require_relative").literal(relative_path)
+          end
+        end
+
+        f.empty
+
+        g = f
+        file.to_constant.split("::").each do |part|
+          g._module.identifier(part).block { |g_| g = g_ }
+        end
+
+        first = true
+        file.each_declaration do |decl|
+          g.empty unless first
+          emit_decls(decl, g)
+          first = false
+        end
+
+        g.empty unless first
+        g._def.identifier("self")
+         .dot("register_#{File.basename file.name.delete_suffix(".proto")}_protos")
+         .call do |c|
+          c.identifier("registry")
+        end.block do |defn|
+          file.dependency.each do |dep|
+            defn.identifier(files.fetch(dep).to_constant)
+                .dot("register_#{File.basename dep.delete_suffix(".proto")}_protos")
+                .call do |c|
+              c.identifier("registry")
+            end
+          end
+          emit_register(defn, file)
+        end
+      end
+    end
+
+    def emit_register(defn, descriptor)
+      case descriptor
+      when DescriptorProto, EnumDescriptorProto
+        return unless descriptor.source_loc
+
+        defn.identifier("registry").dot("register").call do |c|
+          c.identifier(descriptor.to_constant)
+        end
+      when FieldDescriptorProto
+        return unless descriptor.extendee?
+
+        containing_type = files.fetch_type(
+          if descriptor.extendee.start_with?(".")
+            descriptor.extendee[1..]
+          else
+            "#{descriptor.parent.full_name}.#{descriptor.extendee}"
+          end
+        )
+        defn.comment("extension: #{containing_type.full_name}\n  #{descriptor.type} #{descriptor.number}")
+      when FileDescriptorProto, EnumValueDescriptorProto, ServiceDescriptorProto, OneofDescriptorProto
+        # no-op
+      else
+        raise "Unknown descriptor type: #{descriptor.class}"
+      end
+      descriptor.each_declaration do |decl|
+        emit_register(defn, decl)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: protobug-compiler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Giddins
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: delegate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: forwardable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: prettier_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: protobug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: protobug_compiler_protos
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+description: 
+email:
+- segiddins@segiddins.me
+executables:
+- protoc-gen-protobug
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- exe/protoc-gen-protobug
+- lib/protobug/compiler.rb
+- lib/protobug/compiler/builder.rb
+- lib/protobug/compiler/builder_gen.rb
+homepage: https://github.com/segiddins/protobug
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/segiddins/protobug
+  source_code_uri: https://github.com/segiddins/protobug
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key: 
+specification_version: 4
+summary: An protobuf compiler for protobug
+test_files: []