protod 0.1.0

data/lib/protod/proto/service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Protod
+  module Proto
+    class Service < Part
+      include Findable
+
+      attribute :procedures, default: -> { [] }
+
+      findable_callback_for(:procedure, key: %i[ident ruby_ident ruby_method_name]) do |key, value|
+        @procedure_map ? @procedure_map.fetch(key)[value] : procedures.find { _1.public_send(key) == value }
+      end
+
+      def ruby_ident
+        ident.const_name
+      end
+
+      def pb_const
+        parent.pb_const.const_get(ident).const_get('Service')
+      end
+
+      def freeze
+        procedures.each { _1.depth = depth + 1 }
+        procedures.each.with_index(1) { |p, i| p.index = i }
+
+        @procedure_map = self.class.findable_keys_for(:procedure).index_with { |k| procedures.index_by(&k.to_sym) }
+
+        super
+      end
+
+      def to_proto
+        procedure_part = procedures.map { _1.to_proto }.join("\n").presence
+        procedure_part = "\n#{procedure_part}\n" if procedure_part
+
+        [
+          format_proto("service %s {%s", ident, procedure_part),
+          format_proto("}")
+        ].join
+      end
+    end
+  end
+end

data/lib/protod/protocol_buffers.rb

@@ -0,0 +1,46 @@
+Protod.setup!
+
+pb_dir = File.absolute_path(Protod.configuration.pb_root_dir)
+
+$LOAD_PATH.unshift(pb_dir) unless $LOAD_PATH.include?(pb_dir)
+
+Protod::Proto::Package.roots.flat_map(&:all_packages)
+  .reject(&:external?)
+  .reject { _1.services.blank? }
+  .each do |package|
+  dirs = package.full_ident.split('.')
+  file = dirs.pop
+
+  require Pathname.new(pb_dir).join(*dirs, "#{file}_services_pb")
+end
+
+require 'google/protobuf/well_known_types'
+
+class Protod
+  module ProtocolBuffers
+    module GoogleProtobufStructStringified
+      def from_hash(hash)
+        super(hash.stringify_keys)
+      end
+    end
+
+    module GoogleProtobufValueStringified
+      def from_ruby(value)
+        case value
+        when ::Symbol
+          self.string_value = value.to_s
+        else
+          super(value)
+        end
+      end
+    end
+  end
+end
+
+class Google::Protobuf::Struct
+  class << self
+    prepend Protod::ProtocolBuffers::GoogleProtobufStructStringified
+  end
+end
+
+Google::Protobuf::Value.prepend Protod::ProtocolBuffers::GoogleProtobufValueStringified

data/lib/protod/rake_task.rb

@@ -0,0 +1,91 @@
+require 'rake'
+require 'rake/tasklib'
+
+class Protod
+  class RakeTask < Rake::TaskLib
+    class Builder
+      attr_accessor :name
+
+      def initialize(&body)
+        body&.call(self)
+      end
+
+      def build
+        Protod::RakeTask.new(**{ name: name }.compact)
+      end
+    end
+
+    def initialize(name: :protod)
+      super()
+
+      @name = name
+
+      define_generate_proto_task
+      define_generate_pb_task
+      define_run_gruf
+    end
+
+    def define_generate_proto_task
+      desc 'Generate proto files'
+      task("#{@name}:generate:proto": :environment) do
+        Protod.setup!
+
+        root = Pathname.new(Protod.configuration.proto_root_dir)
+
+        Protod::Proto::Package.roots.flat_map { _1.all_packages.reject(&:external?).reject(&:empty?) }.each do |package|
+          path = root.join(*package.full_ident.split('.').tap { _1.last << '.proto' })
+
+          FileUtils.mkdir_p(path.parent) unless File.exist?(path.parent)
+
+          puts "Start to generate #{path} ..."
+          File.write(path, package.to_proto)
+        end
+      end
+    end
+
+    def define_generate_pb_task
+      desc 'Generate protocol buffers files'
+      task("#{@name}:generate:pb": :environment) do
+        Protod.setup!
+
+        proto_dir = Pathname.new(Protod.configuration.proto_root_dir)
+        pb_dir    = File.absolute_path(Pathname.new(Protod.configuration.pb_root_dir))
+
+        FileUtils.mkdir_p(pb_dir) unless File.exist?(pb_dir)
+
+        Dir.mktmpdir do |dir|
+          dir = Pathname(dir)
+
+          Protod::Proto::Package.roots.flat_map(&:all_packages).filter { _1.url.present? }.each.with_index(1) do |package, i|
+            args    = [package.url, dir.join("_ext#{i}_#{package.url.split('/').last}")]
+            options = { depth: 1, branch: package.branch }.compact
+
+            option_part = options.map { |k, v| "--#{k} #{v}" }.join(' ')
+            arg_part    = args.map { Shellwords.shellescape(_1) }.join(' ')
+            cmd         = "git clone #{option_part} #{arg_part}"
+
+            puts "#{cmd}"
+            system(cmd) or raise "Failed to generate pb!"
+          end
+
+          include_option = Dir.glob("#{dir}/*").map { "-I#{_1}" }.join(' ')
+          cmd            = "bundle exec grpc_tools_ruby_protoc #{include_option} -I#{proto_dir} --ruby_out=#{pb_dir} --grpc_out=#{pb_dir} `find #{proto_dir} -type f -name '*.proto'`"
+
+          puts "#{cmd}"
+          system(cmd) or raise "Failed to generate pb!"
+        end
+
+        puts "Finished to generate pb."
+      end
+    end
+
+    def define_run_gruf
+      desc 'Run gruf'
+      task("#{@name}:gruf": :environment) do
+        require 'protod/protocol_buffers'
+
+        ::Gruf::Cli::Executor.new.run
+      end
+    end
+  end
+end

data/lib/protod/rpc/handler.rb

@@ -0,0 +1,114 @@
+class Protod
+  module Rpc
+    class Handler
+      SERVICE_NAME   = 'Handler'
+      PROCEDURE_NAME = 'handle'
+      ONEOF_NAME     = 'receiver'
+
+      class << self
+        def build_in(package)
+          package
+            .find_or_push(SERVICE_NAME, by: :ident, into: :services)
+            .find_or_push(Protod::Proto::Procedure.new(ident: PROCEDURE_NAME, streaming_request: true, streaming_response: true), by: :ident, into: :procedures)
+            .tap do |procedure|
+            package
+              .find_or_push(procedure.request_ident, by: :ident, into: :messages)
+              .find_or_push(Protod::Proto::Oneof.new(ident: ONEOF_NAME), by: :ident, into: :fields)
+
+            package
+              .find_or_push(procedure.response_ident, by: :ident, into: :messages)
+              .find_or_push(Protod::Proto::Oneof.new(ident: ONEOF_NAME), by: :ident, into: :fields)
+          end
+
+          new(package)
+        end
+
+        def find_package
+          Protod::Proto::Package.roots.flat_map(&:all_packages).find do
+            _1.find(SERVICE_NAME, by: :ident, as: 'Protod::Proto::Service')
+              &.find(Protod::Proto::Procedure.new(ident: PROCEDURE_NAME), by: :ident)
+          end
+        end
+
+        def find_service_in(package)
+          package.find(Protod::Rpc::Handler::SERVICE_NAME, by: :ident, as: 'Protod::Proto::Service')
+        end
+      end
+
+      def initialize(package, logger: ::Logger.new(nil))
+        @package = package
+        @logger  = logger
+
+        @procedure = @package
+                       .find(SERVICE_NAME, by: :ident, as: 'Protod::Proto::Service')
+                       .find(Protod::Proto::Procedure.new(ident: PROCEDURE_NAME), by: :ident)
+
+        @request_receiver_fields  = request_proto_message.find(ONEOF_NAME, by: :ident, as: 'Protod::Proto::Oneof')
+        @response_receiver_fields = response_proto_message.find(ONEOF_NAME, by: :ident, as: 'Protod::Proto::Oneof')
+
+        @loaded_objects = {}
+      end
+
+      def request_proto_message
+        @package.find(@procedure.request_ident, by: :ident, as: 'Protod::Proto::Message')
+      end
+
+      def response_proto_message
+        @package.find(@procedure.response_ident, by: :ident, as: 'Protod::Proto::Message')
+      end
+
+      def register_receiver(request_field, response_field)
+        @request_receiver_fields.find_or_push(request_field, by: :ident, into: :fields)
+        @response_receiver_fields.find_or_push(response_field, by: :ident, into: :fields)
+      end
+
+      def handle(req_pb)
+        receiver_name = req_pb.public_send(ONEOF_NAME)
+
+        return unless receiver_name
+
+        req_packet = @request_receiver_fields.find(receiver_name, by: :ident, as: 'Protod::Proto::Field').then do |f|
+          raise InvalidArgument, "Not found acceptable receiver : #{receiver_name}" unless f
+
+          f.interpreter.to_rb_from(req_pb.public_send(receiver_name))
+        end
+
+        receiver = if req_packet.receiver_id
+                     @loaded_objects[req_packet.receiver_id.to_s] or raise InvalidArgument, "Invalid object_id in request for #{receiver_name}"
+                   else
+                     req_packet.receiver
+                   end
+
+        raise InvalidArgument, "Not found receiver in request for #{receiver_name}" unless receiver
+        raise InvalidArgument, "Not found #{req_packet.procedure} in receiver public methods for #{receiver_name}" unless receiver.respond_to?(req_packet.procedure)
+
+        @logger.debug("protod/handle call #{receiver_name}##{req_packet.procedure} : #{req_packet.args} #{req_packet.kwargs}")
+        rb = receiver.public_send(req_packet.procedure, *req_packet.args, **req_packet.kwargs)
+
+        memorize_object_id_of(rb)
+
+        res_pb = @response_receiver_fields.find(receiver_name, by: :ident, as: 'Protod::Proto::Field').then do |f|
+          f.interpreter.to_pb_from(ResponsePacket.new(procedure: req_packet.procedure, object: rb))
+        end
+
+        response_pb_const.new(receiver_name.to_sym => res_pb)
+      end
+
+      private
+
+      def response_pb_const
+        @response_pb_const ||= @package.find(@procedure.response_ident, by: :ident, as: 'Protod::Proto::Message').pb_const
+      end
+
+      def memorize_object_id_of(value)
+        @loaded_objects[value.object_id.to_s] = value
+        value.each { memorize_object_id_of(_1) } if Protod::Proto::Field.should_repeated_with(value.class)
+      end
+
+      class InvalidArgument < StandardError; end
+
+      RequestPacket  = Struct.new(:receiver_id, :receiver, :procedure, :args, :kwargs, keyword_init: true)
+      ResponsePacket = Struct.new(:procedure, :object, keyword_init: true)
+    end
+  end
+end

data/lib/protod/rpc/request.rb

@@ -0,0 +1,68 @@
+class Protod
+  module Rpc
+    class Request
+      class << self
+        def register_for(*ruby_idents, with:, force: true, ignore: false, &body)
+          ruby_idents.map { Protod::RubyIdent.absolute_of(_1) }.each do |ruby_ident|
+            next if map.key?(ruby_ident) && ignore
+
+            raise ArgumentError, "Request already regsitered for #{ruby_ident}" if map.key?(ruby_ident) && !force
+
+            map[ruby_ident] = Class.new(with, &body).tap do |const|
+              const.ruby_ident = Protod::RubyIdent.build_from(ruby_ident)
+            end
+          end
+        end
+
+        def find_by(ruby_ident)
+          map[Protod::RubyIdent.absolute_of(ruby_ident)]
+        end
+
+        def keys
+          map.keys
+        end
+
+        def clear!
+          @map = nil
+        end
+
+        private
+
+        def map
+          @map ||= {}
+        end
+      end
+
+      class Base
+        class_attribute :ruby_ident
+      end
+
+      class Receiver
+        ONEOF_NAME = 'procedure'
+
+        class << self
+          def register_for(*ruby_idents, with: Base, **options, &body)
+            Protod::Rpc::Request.register_for(*ruby_idents, **options.merge(with: with), &body)
+          end
+        end
+
+        class Base < Protod::Rpc::Request::Base
+          class_attribute :procedures
+
+          def self.push_procedure(*names, singleton: false)
+            ruby_idents = names.map { Protod::RubyIdent.new(const_name: ruby_ident, method_name: _1, singleton: singleton) }
+
+            Protod::Rpc::Request.register_for(*ruby_idents, with: Protod::Rpc::Request::Base, force: false, ignore: true)
+
+            self.procedures ||= []
+            self.procedures.push(*ruby_idents)
+          end
+
+          def self.procedure_pushed?(name, singleton: false)
+            procedures&.include?(Protod::RubyIdent.new(const_name: ruby_ident, method_name: name, singleton: singleton)) || false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protod/rpc/response.rb

@@ -0,0 +1,68 @@
+class Protod
+  module Rpc
+    class Response
+      class << self
+        def register_for(*ruby_idents, with:, force: true, ignore: false, &body)
+          ruby_idents.map { Protod::RubyIdent.absolute_of(_1) }.each do |ruby_ident|
+            next if map.key?(ruby_ident) && ignore
+
+            raise ArgumentError, "Response already regsitered for #{ruby_ident}" if map.key?(ruby_ident) && !force
+
+            map[ruby_ident] = Class.new(with, &body).tap do |const|
+              const.ruby_ident = Protod::RubyIdent.build_from(ruby_ident)
+            end
+          end
+        end
+
+        def find_by(ruby_ident)
+          map[Protod::RubyIdent.absolute_of(ruby_ident)]
+        end
+
+        def keys
+          map.keys
+        end
+
+        def clear!
+          @map = nil
+        end
+
+        private
+
+        def map
+          @map ||= {}
+        end
+      end
+
+      class Base
+        class_attribute :ruby_ident
+      end
+
+      class Receiver
+        ONEOF_NAME = 'procedure'
+
+        class << self
+          def register_for(*ruby_idents, with: Base, **options, &body)
+            Protod::Rpc::Response.register_for(*ruby_idents, **options.merge(with: with), &body)
+          end
+        end
+
+        class Base < Protod::Rpc::Response::Base
+          class_attribute :procedures
+
+          def self.push_procedure(*names, singleton: false)
+            ruby_idents = names.map { Protod::RubyIdent.new(const_name: ruby_ident, method_name: _1, singleton: singleton) }
+
+            Protod::Rpc::Response.register_for(*ruby_idents.map(&:to_s), with: Protod::Rpc::Response::Base, force: false, ignore: true)
+
+            self.procedures ||= []
+            self.procedures.push(*ruby_idents)
+          end
+
+          def self.procedure_pushed?(name, singleton: false)
+            procedures&.include?(Protod::RubyIdent.new(const_name: ruby_ident, method_name: name, singleton: singleton)) || false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protod/ruby_ident.rb

@@ -0,0 +1,49 @@
+class Protod
+  class RubyIdent
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    attribute :const_name, :string
+    attribute :method_name, :string
+    attribute :singleton, :boolean, default: false
+
+    class << self
+      def build_from(string)
+        return if string.blank?
+
+        string = string.gsub('__', '::')
+
+        const_name, method_name, singleton = case
+                                             when string.include?('.') 
+                                               [*string.split('.'), true]
+                                             when string.include?('#')
+                                               [*string.split('#'), false]
+                                             else
+                                               [string, nil, false]
+                                             end
+
+        return unless const_name.safe_constantize
+
+        new(const_name: const_name, method_name: method_name, singleton: singleton)
+      end
+
+      def absolute_of(ruby_ident)
+        return if ruby_ident.blank?
+
+        "::#{ruby_ident.to_s.delete_prefix('::')}"
+      end
+    end
+
+    def const_name
+      self.class.absolute_of(super)
+    end
+
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    def to_s
+      [const_name, method_name].compact.join(singleton ? '.' : '#')
+    end
+  end
+end

data/lib/protod/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Protod
+  VERSION = "0.1.0"
+end

data/lib/protod.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'rbs'
+require 'active_support/all'
+require 'active_model'
+
+require_relative "protod/version"
+require_relative 'protod/configuration'
+require_relative 'protod/ruby_ident'
+require_relative 'protod/proto/features'
+require_relative 'protod/proto/part'
+require_relative 'protod/proto/package'
+require_relative 'protod/proto/service'
+require_relative 'protod/proto/procedure'
+require_relative 'protod/proto/message'
+require_relative 'protod/proto/field'
+require_relative 'protod/proto/oneof'
+require_relative 'protod/proto/builder'
+require_relative 'protod/interpreter'
+require_relative 'protod/interpreter/builtin'
+require_relative 'protod/interpreter/active_record'
+require_relative 'protod/interpreter/rpc'
+require_relative 'protod/rpc/request'
+require_relative 'protod/rpc/response'
+require_relative 'protod/rpc/handler'
+
+class Protod
+  class << self
+    def configure(&body)
+      if @configuration
+        body.call(@configuration)
+      else
+        @configures ||= []
+        @configures.push(body)
+      end
+    end
+
+    def configuration
+      @configuration ||= Protod::Configuration.new.tap do |c|
+        # Interpreters will be needed by Protod::Configuration#register_interpreter_for
+        Protod::Interpreter::Builtin.setup!
+        Protod::Interpreter::ActiveRecord.setup!
+        Protod::Interpreter::Rpc.setup!
+
+        @configures&.each { _1.call(c) }
+      end
+    end
+
+    def clear!
+      @configures = nil
+      @configuration = nil
+      Protod::Proto::Package.clear!
+      Protod::Rpc::Request.clear!
+      Protod::Rpc::Response.clear!
+      Protod::Interpreter.clear!
+    end
+
+    def setup!
+      Protod.configuration.builders.each(&:build)
+      Protod::Proto::Package.roots.each(&:freeze)
+      Protod::Interpreter.setup_reverse_lookup!
+    end
+
+    concerning :GlobalUtilities do
+      delegate :find_or_register_package, to: Protod::Proto::Package
+      delegate :rbs_environment, :rbs_definition_builder, to: :configuration
+
+      def rbs_method_type_for(ruby_ident)
+        method_types = rbs_definition_for(ruby_ident.const_name, singleton: ruby_ident.singleton).methods[ruby_ident.method_name.to_sym]&.method_types
+
+        raise NotImplementedError, "Not found rbs for #{ruby_ident}" unless method_types
+
+        m = method_types.find { _1.block.nil? || _1.block.required.! } || method_types.first
+
+        raise ArgumentError, "Unsupported receiving block method : #{ruby_ident}" if m.block&.required
+
+        m
+      end
+
+      def rbs_definition_for(const_name, singleton:)
+        const_names = const_name.delete_prefix('::').split('::')
+        name        = const_names.pop.to_sym
+        namespace   = const_names.empty? ? RBS::Namespace.root : RBS::Namespace.new(path: const_names.map(&:to_sym), absolute: true)
+
+        rbs_type_name = RBS::TypeName.new(name: name, namespace: namespace)
+
+        raise NotImplementedError, "Not found rbs for #{const_name}" unless rbs_environment.class_decls.key?(rbs_type_name)
+
+        if singleton
+          rbs_definition_builder.build_singleton(rbs_type_name)
+        else
+          rbs_definition_builder.build_instance(rbs_type_name)
+        end
+      end
+    end
+  end
+
+  module Types
+    Binary          = Object.new
+    UnsignedInteger = Object.new
+    Json            = Object.new
+  end
+end

data/sig/protod.rbs

@@ -0,0 +1,4 @@
+module Protod
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end