protod 0.1.0

data/lib/protod/proto/builder.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class Protod
+  module Proto
+    class Builder
+      def initialize(root_package)
+        @root_package = root_package
+        @receivers    = {}
+      end
+
+      def push_receiver(ruby_ident)
+        @receivers[ruby_ident.to_s] = true
+      end
+
+      def receiver_pushed?(ruby_ident)
+        @receivers.key?(ruby_ident.to_s)
+      end
+
+      def build
+        return if @root_package.built?
+
+        handler = Protod::Rpc::Handler.build_in(@root_package)
+
+        @receivers.keys.each do |receiver|
+          package = Protod.find_or_register_package("#{@root_package.full_ident}.#{receiver.underscore.gsub('/', '.')}")
+
+          request_field  = Protod::Proto::Field.build_from(Protod::Rpc::Request.find_by(receiver), ident: receiver)
+          response_field = Protod::Proto::Field.build_from(Protod::Rpc::Response.find_by(receiver), ident: receiver)
+
+          handler.register_receiver(request_field, response_field)
+
+          request_message  = package.bind(request_field.interpreter)
+          response_message = package.bind(response_field.interpreter)
+
+          bindable_interpreters_under(request_message, response_message).each do |i|
+            root_message_name = i.const.ruby_ident.singleton ? 'Singleton' : 'Instance'
+
+            package
+              .find_or_push(root_message_name, by: :ident, into: :messages)
+              .find_or_push(i.const.ruby_ident.method_name, by: :ident, into: :messages)
+              .bind(i)
+          end
+        end
+
+        models_package = Protod.find_or_register_package("#{@root_package.full_ident}.models")
+
+        while (interpreters = bindable_interpreters_under(*@root_package.all_packages)).present?
+          interpreters.each { models_package.bind(_1) }
+        end
+
+        # For supporting an Array/Hash instance at the fields whiches type is google.protobuf.Any,
+        # make the proto definition for Array emerge even if it's not requried.
+        any_interpreter = Protod::Interpreter.find_by('RBS::Types::Bases::Any')
+        if @root_package.all_packages.flat_map(&:collect_fields).any? { _1.interpreter == any_interpreter }
+          i = Protod::Interpreter.find_by('Array')
+
+          models_package.bind(i) if i.bindable?
+
+          models_package.imports.push(Protod::Interpreter.find_by('Hash').proto_path)
+        end
+      end
+
+      private
+
+      def bindable_interpreters_under(*parts)
+        parts.flat_map(&:collect_fields).filter_map(&:interpreter).uniq.select(&:bindable?)
+      end
+    end
+  end
+end

data/lib/protod/proto/features.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Protod
+  module Proto
+    class << self
+      # https://github.com/protocolbuffers/protobuf/blob/v3.12.0/docs/field_presence.md
+      def omits_field?(pb, name)
+        return false unless pb.respond_to?("has_#{name}?")
+        return false if pb.public_send("has_#{name}?")
+        true
+      end
+    end
+
+    class Ident < ::String
+      class << self
+        def build_from(const_name)
+          return if const_name.blank?
+
+          new(const_name)
+        end
+      end
+
+      attr_reader :const_name
+
+      def initialize(const_name)
+        @const_name = Protod::RubyIdent.absolute_of(const_name)
+
+        super(const_name.gsub('::', '__').delete_prefix('__'))
+      end
+    end
+  end
+end

data/lib/protod/proto/field.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+class Protod
+  module Proto
+    class Field < Part
+      attribute :interpreter
+      attribute :as_keyword, :boolean, default: false
+      attribute :as_rest, :boolean, default: false
+      attribute :required, :boolean, default: true  # whether to be not able to omit in Ruby
+      attribute :optional, :boolean, default: false # whether to be optional in proto
+      attribute :repeated, :boolean, default: false
+
+      class << self
+        def build_from(const_or_name, **attributes)
+          i = Protod::Interpreter.find_by(const_or_name, with_register_from_ancestor: true)
+
+          raise NotImplementedError, "Not found the interpreter for #{const_or_name}. You can define a interpreter using Protod::Interpreter.register_for" unless i
+
+          new(interpreter: i, **attributes)
+        end
+
+        def build_from_rbs(type, on:, **attributes)
+          case type
+          when RBS::Types::Optional
+            build_from_rbs(type.type, on: on, **attributes.merge(optional: attributes[:repeated] ? false : true))
+          when RBS::Types::Union
+            real_type = type.types.find { _1.name.kind == :class && Protod.rbs_environment.class_decls.key?(_1.name) }
+
+            raise ArgumentError, "Not found declared class in union type on #{on}" unless real_type
+
+            build_from_rbs(real_type, on: on, **attributes)
+          when RBS::Types::Alias
+            alias_decl = Protod.rbs_environment.type_alias_decls[type.name]
+
+            raise ArgumentError, "Not found alias declaration of #{type.name.name} on #{on}" unless alias_decl
+
+            build_from_rbs(alias_decl.decl.type, on: on, **attributes)
+          when RBS::Types::ClassInstance
+            case
+            when should_repeated_with(type.name.to_s.safe_constantize)
+              build_from_rbs(type.args.first, on: on, **attributes.merge(optional: false, repeated: true))
+            when type.args.size > 0
+              raise NotImplementedError, "Unsupported rbs type : Record or Tuple on #{on}"
+            else
+              build_from(type.name.to_s, **attributes)
+            end
+          when RBS::Types::Bases::Base
+            build_from(type.class.name, **attributes)
+          else
+            binding.pry
+            raise NotImplementedError, "Unsupported rbs type : #{type.class.name} on #{on}"
+          end
+        end
+
+        def should_repeated_with(const)
+          const&.ancestors&.include?(::Array)
+        end
+      end
+
+      def void?
+        interpreter ? interpreter.proto_ident.blank? : false
+      end
+
+      def to_proto
+        raise ArgumentError, "Not set interpreter" unless interpreter
+
+        type_part = if interpreter.package && interpreter.package == ancestor_as(Protod::Proto::Package)
+                      interpreter.proto_full_ident.delete_prefix("#{interpreter.package.full_ident}.")
+                    else
+                      interpreter.proto_full_ident
+                    end
+
+        [
+          format_proto(''),
+          [
+            # optional ? 'optional' : nil,
+            repeated ? 'repeated' : nil,
+            type_part,
+            ident,
+            '=',
+            index
+          ].compact.join(' '),
+          ';'
+        ].join
+      end
+    end
+  end
+end

data/lib/protod/proto/message.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+class Protod
+  module Proto
+    class Message < Part
+      include Findable
+      include FieldCollectable
+      include FieldNumeringable
+      include InterpreterBindable
+
+      attribute :messages, default: -> { [] }
+      attribute :fields, default: -> { [] }
+
+      findable_callback_for(:message, key: [:ident, :ruby_ident]) do |key, value|
+        @message_map ? @message_map.fetch(key)[value] : messages.find { _1.public_send(key) == value }
+      end
+
+      findable_callback_for(:field, :oneof, key: :ident) do |key, value|
+        @field_map ? @field_map.fetch(key)[value] : fields.find { _1.public_send(key) == value }
+      end
+
+      def has?(part, in_the:)
+        case in_the
+        when :fields
+          idents = fields.flat_map do |f|
+            case f
+            when Protod::Proto::Field
+              [f.ident]
+            when Protod::Proto::Oneof
+              [f.ident, *f.fields.map(&:ident)]
+            else
+              raise ArgumentError, "Unacceptable field : #{f.ident} of #{f.class.name}"
+            end
+          end
+
+          part.ident.in?(idents)
+        else
+          super
+        end
+      end
+
+      def ruby_ident
+        ident.const_name
+      end
+
+      def full_ident
+        [parent&.full_ident, ident].compact.join('.').presence
+      end
+
+      def pb_const
+        raise NotImplementedError, "Can't call pb_const for #{ident} : not set parent yet" unless parent
+
+        Google::Protobuf::DescriptorPool.generated_pool.lookup(full_ident).msgclass
+      end
+
+      def freeze
+        messages.each { _1.depth = depth + 1 }
+        fields.each { _1.depth = depth + 1 }
+
+        messages.each.with_index(1) { |m, i| m.index = i }
+        numbering_fields_with(1)
+
+        @message_map = self.class.findable_keys_for(:message).index_with { |k| messages.index_by(&k.to_sym) }
+        @field_map   = self.class.findable_keys_for(:field).index_with { |k| fields.index_by(&k.to_sym) }
+
+        super
+      end
+
+      def to_proto
+        message_part = messages.map { _1.to_proto }.join("\n\n").presence
+
+        field_part = fields.filter_map do |f|
+          case f
+          when Protod::Proto::Field
+            next if f.void?
+
+            f.to_proto
+          when Protod::Proto::Oneof
+            f.to_proto
+          else
+            raise NotImplementedError, "Sorry, this is bug forgetting to implement for #{f.class.name}"
+          end
+        end.join("\n").presence
+
+        body = [message_part, field_part].compact.join("\n\n").presence
+        body = "\n#{body}\n" if body
+
+        [
+          format_proto("message %s {%s", ident, body),
+          format_proto("}")
+        ].join
+      end
+    end
+  end
+end

data/lib/protod/proto/oneof.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Protod
+  module Proto
+    class Oneof < Part
+      include Findable
+      include FieldNumeringable
+
+      attribute :fields, default: -> { [] }
+
+      findable_callback_for(:field, :oneof, key: :ident) do |key, value|
+        @field_map ? @field_map.fetch(key)[value] : fields.find { _1.public_send(key) == value }
+      end
+
+      def freeze
+        fields.each { _1.depth = depth + 1 }
+
+        @field_map = self.class.findable_keys_for(:field).index_with { |k| fields.index_by(&k.to_sym) }
+
+        super
+      end
+
+      def to_proto
+        field_part = fields.filter_map do |f|
+          case f
+          when Protod::Proto::Field
+            next if f.void?
+
+            f.to_proto
+          when Protod::Proto::Oneof
+            f.to_proto
+          else
+            raise NotImplementedError, "Sorry, this is bug forgetting to implement for #{f.class.name}"
+          end
+        end.join("\n").presence
+
+        field_part = "\n#{field_part}\n" if field_part
+
+        [
+          format_proto("oneof %s {%s", ident, field_part),
+          format_proto("}")
+        ].join
+      end
+    end
+  end
+end

data/lib/protod/proto/package.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+class Protod
+  module Proto
+    class Package < Part
+      include Findable
+      include FieldCollectable
+      include InterpreterBindable
+
+      attribute :url
+      attribute :branch
+      attribute :for_ruby, :string
+      attribute :for_java, :string
+      attribute :packages, default: -> { [] }
+      attribute :services, default: -> { [] }
+      attribute :messages, default: -> { [] }
+      attribute :imports, default: -> { [] }
+
+      findable_callback_for(:package, key: :full_ident) do |key, value|
+        @package_map ? @package_map.fetch(key)[value] : all_packages.find { _1.public_send(key) == value }
+      end
+
+      findable_callback_for(:service, key: [:ident, :ruby_ident]) do |key, value|
+        @service_map ? @service_map.fetch(key)[value] : services.find { _1.public_send(key) == value }
+      end
+
+      findable_callback_for(:message, key: [:ident, :ruby_ident]) do |key, value|
+        @message_map ? @message_map.fetch(key)[value] : messages.find { _1.public_send(key) == value }
+      end
+
+      class << self
+        def clear!
+          @packages = nil
+        end
+
+        def roots
+          @packages ||= []
+        end
+
+        def find_or_register_package(full_ident, **attributes)
+          full_ident.split('.').inject(nil) do |parent, ident|
+            current_packages = parent ? parent.packages : roots
+
+            current_packages.find { _1.ident == ident } || new.tap do
+              _1.assign_attributes(
+                parent: parent,
+                ident: ident,
+                for_ruby: parent&.for_ruby && "#{parent.for_ruby}::#{ident.camelize}",
+                for_java: parent&.for_java && "#{parent.for_java}.#{ident}"
+              )
+
+              current_packages.push(_1)
+            end
+          end.tap do
+            _1.assign_attributes(**attributes.compact) if attributes.compact.present?
+          end
+        end
+      end
+
+      def proto_path
+        full_ident.gsub('.', '/').then { "#{_1}.proto" }
+      end
+
+      def full_ident
+        [parent&.full_ident, ident].compact.join('.').presence if ident
+      end
+
+      def pb_const
+        for_ruby&.constantize || full_ident.split('.').map(&:camelize).join('::').constantize
+      end
+
+      def all_packages
+        packages.flat_map(&:all_packages).tap { _1.unshift(self) }
+      end
+
+      def empty?
+        services.empty? && messages.empty?
+      end
+
+      def external?
+        url.present?
+      end
+
+      def freeze
+        services.each.with_index(1) { |s, i| s.index = i }
+        messages.each.with_index(1) { |m, i| m.index = i }
+
+        @package_map = self.class.findable_keys_for(:package).index_with { |k| all_packages.index_by(&k.to_sym) }
+        @service_map = self.class.findable_keys_for(:service).index_with { |k| services.index_by(&k.to_sym) }
+        @message_map = self.class.findable_keys_for(:message).index_with { |k| messages.index_by(&k.to_sym) }
+
+        super
+      end
+
+      def to_proto
+        syntax_part = format_proto("syntax = \"proto3\";")
+
+        package_part = format_proto("package %s;", full_ident)
+
+        option_part = [
+          for_ruby ? format_proto("option ruby_package = \"%s\";", for_ruby) : nil,
+          for_java ? format_proto("option java_package = \"%s\";", for_java) : nil,
+        ].compact.join("\n").presence
+
+        import_part = [
+          *collect_fields.filter_map(&:interpreter).uniq.filter_map(&:proto_path).uniq.reject { _1 == proto_path },
+          *imports
+        ].uniq.sort.map { format_proto('import "%s";', _1) }.join("\n").presence
+
+        message_part = messages.map { _1.to_proto }.join("\n\n").presence
+        service_part = services.map { _1.to_proto }.join("\n\n").presence
+
+        [
+          [syntax_part, package_part, option_part, import_part, message_part, service_part].compact.join("\n\n"),
+          "\n"
+        ].join
+      end
+    end
+  end
+end

data/lib/protod/proto/part.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+class Protod
+  module Proto
+    class Part
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :parent
+      attribute :comment, :string
+      attribute :ident
+      attribute :depth, :integer, default: 0
+      attribute :index, :integer, default: 1
+
+      def ident=(value)
+        super(Protod::Proto::Ident.build_from(value.to_s))
+
+        raise ArgumentError, "Invalid grpc ident : #{value}. see https://protobuf.dev/reference/protobuf/proto3-spec/#identifiers" unless ident&.match(/\A[a-zA-Z][a-zA-Z0-9_]*\z/)
+      end
+
+      def root
+        parent ? parent.root : self
+      end
+
+      def ancestor_as(part_const)
+        parent.is_a?(part_const) ? parent : parent&.ancestor_as(part_const)
+      end
+
+      def push(part, into:, ignore: false)
+        already_pushed = has?(part, in_the: into)
+
+        raise ArgumentError, "Can't push already present #{part.ident} in #{ident}" if already_pushed && ignore.!
+        raise ArgumentError, "Can't push already bound to #{part.parent.ident} in #{ident}" if part.parent
+
+        part.assign_attributes(parent: self)
+
+        public_send(into).push(part) unless already_pushed
+
+        part
+      end
+
+      def has?(part, in_the:)
+        public_send(in_the).any? { _1.ident == part.ident }
+      end
+
+      def to_proto
+        raise NotImplementedError, "Not defined #{self.class.name}##{__method__}"
+      end
+
+      def freeze
+        super.tap do
+          (attributes.keys - %w[parent]).each do |attribute_name|
+            value = attributes.fetch(attribute_name)
+
+            value.freeze
+
+            value.each(&:freeze) if value.is_a?(::Array)
+          end
+        end
+      end
+
+      alias_method :built?, :frozen?
+
+      private
+
+      def format_proto(fmt, *args)
+        format("%s#{fmt}", '  ' * depth, *args)
+      end
+    end
+
+    module Findable
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def findable_callback_for(*part_class_names, key:, &body)
+          part_class_names.each do |part_class_name|
+            k = "Protod::Proto::#{part_class_name.to_s.classify}"
+
+            self._findable_keys_for ||= {}
+            self._findable_body_for ||= {}
+
+            self._findable_keys_for[k] = ::Array.wrap(key).map(&:to_s)
+            self._findable_body_for[k] = body
+          end
+        end
+
+        def findable_keys_for(part_class_name)
+          k = "Protod::Proto::#{part_class_name.to_s.classify}"
+
+          _findable_keys_for[k] || []
+        end
+      end
+
+      included do
+        class_attribute :_findable_keys_for
+        class_attribute :_findable_body_for
+
+        def find(part, by:, as: nil)
+          by    = by.to_s
+          value = case part
+                  when ::String
+                    part
+                  when ::Symbol
+                    part.to_s
+                  else
+                    part.public_send(by)
+                  end
+          part  = as ? as.safe_constantize&.allocate : part
+          keys  = _findable_keys_for.fetch(part.class.name, nil)
+          body  = _findable_body_for.fetch(part.class.name, nil)
+
+          raise ArgumentError, "Unsupported as : #{as}" if keys.blank? && as
+          raise ArgumentError, "Unsupported part : #{part.class.name}" if keys.blank?
+          raise ArgumentError, "Unsupported by : #{by}. #{keys.join(', ')} are available" unless by.in?(keys)
+          raise NotImplementedError, "Sorry, this is bug forgetting to implement for #{part.class.name} at #{self.class.name}" unless body
+
+          instance_exec(by, value, &body)
+        end
+
+        def find_or_push(part, into:, by:, as: nil, &body)
+          new_part = if part.is_a?(::String)
+                       c = as ? as.safe_constantize : "Protod::Proto::#{into.to_s.classify}".constantize
+
+                       raise ArgumentError, "Unsupported as : #{as}" unless c
+
+                       c.new(by.to_sym => part)
+                     else
+                       part
+                     end
+
+          as = part.is_a?(::String) ? new_part.class.name : nil
+
+          find(part, by: by, as: as) || push(new_part, into: into).tap { body&.call(_1) }
+        end
+      end
+    end
+
+    module FieldCollectable
+      def collect_fields
+        collector = ->(part) do
+          case part
+          when Protod::Proto::Package
+            part.messages.flat_map { collector.call(_1) }
+          when Protod::Proto::Message
+            [
+              *part.fields.flat_map { collector.call(_1) },
+              *part.messages.flat_map { collector.call(_1) },
+            ]
+          when Protod::Proto::Oneof
+            part.fields.flat_map { collector.call(_1) }
+          when Protod::Proto::Field
+            [part]
+          else
+            []
+          end
+        end
+
+        collector.call(self)
+      end
+    end
+
+    module FieldNumeringable
+      def numbering_fields_with(start_index)
+        index = start_index
+
+        fields.each do |f|
+          case f
+          when Protod::Proto::Field
+            f.index = index
+
+            index = f.index + 1
+          when Protod::Proto::Oneof
+            index = f.numbering_fields_with(index)
+          else
+            raise NotImplementedError, "Sorry, this is bug forgetting to implement for #{f.class.name}"
+          end
+        end
+
+        index
+      end
+    end
+
+    module InterpreterBindable
+      def bind(interpreter)
+        raise ArgumentError, "Not bindable interpreter #{interpreter.proto_full_ident} trying bound to #{ident}" unless interpreter.bindable?
+        interpreter.set_parent(self)
+        push(interpreter.proto_message, into: :messages, ignore: true)
+      end
+    end
+  end
+end

data/lib/protod/proto/procedure.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Protod
+  module Proto
+    class Procedure < Part
+      attribute :singleton, :boolean, default: false
+      attribute :has_request, :boolean, default: true
+      attribute :has_response, :boolean, default: true
+      attribute :streaming_request, :boolean, default: false
+      attribute :streaming_response, :boolean, default: false
+
+      def ident=(value)
+        super(value.to_s.camelize)
+      end
+
+      def ruby_ident
+        raise ArgumentError, "Not set parent" unless parent
+
+        Protod::RubyIdent.new(const_name: parent.ruby_ident, method_name: ruby_method_name, singleton: singleton)
+      end
+
+      def ruby_method_name
+        ident.underscore
+      end
+
+      def request_ident
+        "#{ident}Request"
+      end
+
+      def response_ident
+        "#{ident}Response"
+      end
+
+      def to_proto
+        request_part  = format("%s%s", streaming_request ? 'stream ' : '', has_request ? request_ident : '')
+        response_part = format("%s%s", streaming_response ? 'stream ' : '', has_response ? response_ident : '')
+
+        format_proto("rpc %s (%s) returns (%s);", ident, request_part, response_part)
+      end
+    end
+  end
+end