protod 0.1.0

data/lib/protod/interpreter/builtin.rb

@@ -0,0 +1,328 @@
+# frozen_string_literal: true
+
+class Protod
+  class Interpreter
+    class Builtin
+      def self.setup!
+        google_protobuf = Protod.find_or_register_package('google.protobuf')
+        google_type     = Protod.find_or_register_package('google.type', url: 'https://github.com/googleapis/googleapis.git')
+
+        Interpreter.register_for('RBS::Types::Bases::Any', parent: google_protobuf, path: 'google/protobuf/any.proto', force: false, ignore: true) do
+          def proto_ident
+            'Any'
+          end
+
+          def to_pb_from(rb)
+            i = Protod::Interpreter.find_by(rb.class)
+
+            raise NotImplementedError, "Not found the interpreter for #{rb.class.name}. You can define a interpreter using Protod::Interpreter.register_for" unless i
+
+            value = if i.pb_const
+                      pb = i.to_pb_from(rb)
+
+                      pb.protod__object_id = rb.object_id.to_s if pb.respond_to?(:protod__object_id)
+
+                      i.pb_const.encode(pb)
+                    elsif i.proto_ident
+                      pb = i.to_pb_from(rb)
+
+                      case i.proto_ident
+                      when 'bool'
+                        # ref: https://github.com/ruby-protobuf/protobuf/blob/b866fc5667226d0582f328ab24c648e578c5a380/lib/protobuf/field/bool_field.rb#L46
+                        [pb ? 1 : 0].pack('C')
+                      when 'double'
+                        # ref: https://github.com/ruby-protobuf/protobuf/blob/b866fc5667226d0582f328ab24c648e578c5a380/lib/protobuf/field/double_field.rb#L16
+                        [pb].pack('E')
+                      when 'sint64', 'sint32'
+                        # ref: https://github.com/ruby-protobuf/protobuf/blob/b866fc5667226d0582f328ab24c648e578c5a380/lib/protobuf/field/signed_integer_field.rb#L20-L24
+                        if pb >= 0
+                          varint_encode(pb << 1)
+                        else
+                          varint_encode(~(pb << 1))
+                        end
+                      when 'uint64'
+                        # ref: https://github.com/ruby-protobuf/protobuf/blob/b866fc5667226d0582f328ab24c648e578c5a380/lib/protobuf/field/varint_field.rb#L68
+                        varint_encode(pb)
+                      when 'string', 'bytes'
+                        # ref: https://github.com/ruby-protobuf/protobuf/blob/b866fc5667226d0582f328ab24c648e578c5a380/lib/protobuf/field/string_field.rb#L37-L43
+                        v = "" + pb
+                        if i.proto_ident == 'string' && v.encoding != ::Encoding::UTF_8
+                          v.encode!(::Encoding::UTF_8, :invalid => :replace, :undef => :replace, :replace => "")
+                        end
+                        v.force_encoding(::Encoding::BINARY)
+                      else
+                        raise NotImplementedError, "Unsupported #{i.proto_ident} on #{__method__} for #{const.name}"
+                      end
+                    end
+
+            Google::Protobuf::Any.new(type_url: "/#{i.proto_full_ident}", value: value)
+          end
+
+          def to_rb_from(pb)
+            i = Protod::Interpreter.find_by_proto(pb.type_url.split('/').last)
+
+            raise NotImplementedError, "Not found the interpreter for #{pb.type_url}. You can define a interpreter using Protod::Interpreter.register_for" unless i
+
+            value = if i.pb_const
+                      i.pb_const.decode(pb.value)
+                    elsif i.proto_ident
+                      case i.proto_ident
+                      when 'bool'
+                        pb.value.unpack('C').first == 1
+                      when 'double'
+                        pb.value.unpack('E').first
+                      when 'sint64', 'sint32'
+                        v = varint_decode(StringIO.new(pb.value))
+
+                        (v & 1).zero? ? v >> 1 : ~v >> 1
+                      when 'uint64'
+                        varint_decode(StringIO.new(pb.value))
+                      when 'string', 'bytes'
+                        pb.value.dup.force_encoding(i.proto_ident == 'string' ? ::Encoding::UTF_8 : ::Encoding::BINARY)
+                      else
+                        raise NotImplementedError, "Unsupported #{i.proto_ident} on #{__method__} for #{const.name}"
+                      end
+                    end
+
+            i.to_rb_from(value)
+          end
+
+          private
+
+          # ref: https://github.com/ruby-protobuf/protobuf/blob/b866fc5667226d0582f328ab24c648e578c5a380/lib/protobuf/varint_pure.rb#L10-L29
+
+          def varint_encode(value)
+            bytes = []
+            until value < 128
+              bytes << (0x80 | (value & 0x7f))
+              value >>= 7
+            end
+            (bytes << value).pack('C*')
+          end
+
+          def varint_decode(stream)
+            value = index = 0
+            begin
+              byte = stream.readbyte
+              value |= (byte & 0x7f) << (7 * index)
+              index += 1
+            end while (byte & 0x80).nonzero?
+            value
+          end
+        end
+
+        Interpreter.register_for(*%w[RBS::Types::Bases::Void RBS::Types::Bases::Nil], force: false, ignore: true) do
+          def proto_ident
+            nil
+          end
+
+          def to_pb_from(rb)
+            nil
+          end
+
+          def to_rb_from(pb)
+            nil
+          end
+        end
+
+        Interpreter.register_for('TrueClass', 'FalseClass', 'RBS::Types::Bases::Bool', force: false, ignore: true) do
+          def proto_ident
+            'bool'
+          end
+
+          def to_pb_from(rb)
+            rb ? true : false
+          end
+
+          def to_rb_from(pb)
+            pb
+          end
+        end
+
+        Interpreter.register_for('Numeric', force: false, ignore: true) do
+          def proto_ident
+            'double'
+          end
+
+          def to_pb_from(rb)
+            rb.to_f
+          end
+
+          def to_rb_from(pb)
+            pb
+          end
+        end
+
+        Interpreter.register_for('Integer', force: false, ignore: true) do
+          def proto_ident
+            'sint64'
+          end
+
+          def to_pb_from(rb)
+            rb.to_i
+          end
+
+          def to_rb_from(pb)
+            pb
+          end
+        end
+
+        Interpreter.register_for('Fixnum', force: false, ignore: true) do
+          def proto_ident
+            'sint32'
+          end
+
+          def to_pb_from(rb)
+            rb.to_i
+          end
+
+          def to_rb_from(pb)
+            pb
+          end
+        end
+
+        Interpreter.register_for('String', force: false, ignore: true) do
+          def proto_ident
+            'string'
+          end
+
+          def to_pb_from(rb)
+            rb.to_s
+          end
+
+          def to_rb_from(pb)
+            pb
+          end
+        end
+
+        Interpreter.register_for('BigDecimal', parent: google_type, path: 'google/type/decimal.proto', force: false, ignore: true) do
+          def proto_ident
+            'Decimal'
+          end
+
+          def to_pb_from(rb)
+            Google::Type::Decimal.new(value: rb.to_s)
+          end
+
+          def to_rb_from(pb)
+            BigDecimal(pb.value)
+          end
+        end
+
+        Interpreter.register_for('Date', parent: google_type, path: 'google/type/date.proto', force: false, ignore: true) do
+          def proto_ident
+            'Date'
+          end
+
+          def to_pb_from(rb)
+            Google::Type::Date.new(year: rb.year, month: rb.month, day: rb.day)
+          end
+
+          def to_rb_from(pb)
+            ::Date.new(pb.year, pb.month, pb.day)
+          end
+        end
+
+        Interpreter.register_for('Time', 'DateTime', 'ActiveSupport::TimeWithZone', parent: google_protobuf, path: 'google/protobuf/timestamp.proto', force: false, ignore: true) do
+          def proto_ident
+            'Timestamp'
+          end
+
+          def to_pb_from(rb)
+            Google::Protobuf::Timestamp.new(seconds: rb.to_i, nanos: rb.nsec)
+          end
+
+          def to_rb_from(pb)
+            ::Time.zone.at(pb.seconds, pb.nanos, :nanosecond)
+          end
+        end
+
+        Interpreter.register_for('Protod::Types::Binary', force: false, ignore: true) do
+          def proto_ident
+            'bytes'
+          end
+
+          def to_pb_from(rb)
+            rb
+          end
+
+          def to_rb_from(pb)
+            pb
+          end
+        end
+
+        Interpreter.register_for('Protod::Types::UnsignedInteger', force: false, ignore: true) do
+          def proto_ident
+            'uint64'
+          end
+
+          def to_pb_from(rb)
+            rb.to_i
+          end
+
+          def to_rb_from(pb)
+            pb
+          end
+        end
+
+        Interpreter.register_for('Array', force: false, ignore: true) do
+          def proto_message
+            Protod::Proto::Message.new(
+              ident: proto_ident,
+              fields: [Protod::Proto::Field.build_from('RBS::Types::Bases::Any', ident: 'values', optional: true, repeated: true)]
+            )
+          end
+
+          def to_pb_from(rb)
+            i = Protod::Interpreter.find_by('RBS::Types::Bases::Any')
+
+            pb_const.new(values: rb.map { i.to_pb_from(_1) })
+          end
+
+          def to_rb_from(pb)
+            i = Protod::Interpreter.find_by('RBS::Types::Bases::Any')
+
+            pb.values.map { i.to_rb_from(_1) }
+          end
+        end
+
+        Interpreter.register_for('Hash', parent: google_protobuf, path: 'google/protobuf/struct.proto', force: false, ignore: true) do
+          def proto_ident
+            'Struct'
+          end
+
+          def to_pb_from(rb)
+            Google::Protobuf::Struct.from_hash(rb)
+          end
+
+          def to_rb_from(pb)
+            pb.to_h
+          end
+        end
+
+        Interpreter.register_for(*['Data', 'Struct'].select(&:safe_constantize), force: false, ignore: true) do
+          def proto_message
+            Protod::Proto::Message.new(
+              ident: proto_ident,
+              fields: const.memebers.map do |name|
+                Protod::Proto::Field.build_from('RBS::Types::Bases::Any', ident: name, optional: true)
+              end
+            )
+          end
+
+          def to_pb_from(rb)
+            attributes = const.members.map { [_1, rb.public_send(_1)] }.to_h
+
+            pb_const.new(**attributes)
+          end
+
+          def to_rb_from(pb)
+            attributes = const.members.map { [_1, pb.public_send(_1)] }.to_h
+
+            const.new(**attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protod/interpreter/rpc.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+class Protod
+  class Interpreter
+    class Rpc
+      def self.setup!
+        Interpreter.register_for('Protod::Rpc::Request::Base', force: false, ignore: true) do
+          def proto_ident
+            "Request"
+          end
+
+          def proto_message
+            m = Protod.rbs_method_type_for(const.ruby_ident)
+
+            fields = [
+              if const.ruby_ident.singleton
+                nil
+              else
+                Protod::Proto::Field.build_from(const.ruby_ident.const_name, ident: const.ruby_ident.const_name)
+              end,
+              *m.type.required_positionals.map do |arg|
+                raise ArgumentError, "Unsupported non-named argument : #{const.ruby_ident}" unless arg.name
+
+                Protod::Proto::Field.build_from_rbs(arg.type, on: const.ruby_ident, ident: arg.name)
+              end,
+              *m.type.optional_positionals.map do |arg|
+                raise ArgumentError, "Unsupported non-named argument : #{const.ruby_ident}" unless arg.name
+
+                Protod::Proto::Field.build_from_rbs(arg.type, on: const.ruby_ident, ident: arg.name, required: false, optional: true)
+              end,
+              m.type.rest_positionals&.then do |arg|
+                raise ArgumentError, "Unsupported non-named argument : #{const.ruby_ident}" unless arg.name
+
+                Protod::Proto::Field.build_from_rbs(arg.type, on: const.ruby_ident, ident: arg.name, as_rest: true, required: false, repeated: true)
+              end,
+              *m.type.required_keywords.map do |name, arg|
+                Protod::Proto::Field.build_from_rbs(arg.type, on: const.ruby_ident, ident: name, as_keyword: true)
+              end,
+              *m.type.optional_keywords.map do |name, arg|
+                Protod::Proto::Field.build_from_rbs(arg.type, on: const.ruby_ident, ident: name, as_keyword: true, required: false, optional: true)
+              end,
+              m.type.rest_keywords&.then do |arg|
+                # Not supporting for now because it's complicated and I can't understand the specification of ruby and rbs about this completely
+                raise ArgumentError, "Unsupported rest keywords argument : #{const.ruby_ident}"
+
+                raise ArgumentError, "Unsupported non-named argument : #{const.ruby_ident}" unless arg.name
+
+                Protod::Proto::Field.build_from_rbs(arg.type, on: const.ruby_ident, ident: arg.name, as_keyword: true, as_rest: true, required: false, optional: true)
+              end
+            ].compact
+
+            Protod::Proto::Message.new(ident: proto_ident, fields: fields)
+          end
+
+          def to_rb_from(pb)
+            args = []
+            kwargs = {}
+            receiver_id = nil
+
+            proto_message.fields.each.with_index do |f, i|
+              next if Protod::Proto.omits_field?(pb, f.ident) && f.required.!
+
+              f_pb = pb.public_send(f.ident)
+
+              receiver_id = f_pb.protod__object_id if i == 0 && f_pb.respond_to?(:protod__object_id)
+
+              arg = if f.repeated
+                      f_pb&.map { f.interpreter.to_rb_from(_1) }
+                    else
+                      f.interpreter.to_rb_from(f_pb)
+                    end
+
+              if f.as_keyword
+                kwargs[f.ident.to_sym] = arg
+              elsif f.as_rest
+                args = [*args, *arg]
+              else
+                args.push(arg)
+              end
+            end
+
+            receiver = if const.ruby_ident.singleton
+                         const.ruby_ident.const_name.constantize
+                       else
+                         args.shift
+                       end
+
+            Protod::Rpc::Handler::RequestPacket.new(receiver_id: receiver_id, receiver: receiver, args: args, kwargs: kwargs)
+          end
+        end
+
+        Interpreter.register_for('Protod::Rpc::Response::Base', force: false, ignore: true) do
+          def proto_ident
+            "Response"
+          end
+
+          def proto_message
+            m = Protod.rbs_method_type_for(const.ruby_ident)
+
+            fields = if m.type.return_type
+                       [Protod::Proto::Field.build_from_rbs(m.type.return_type, on: const.ruby_ident, ident: 'value')]
+                     else
+                       []
+                     end
+
+            Protod::Proto::Message.new(ident: proto_ident, fields: fields)
+          end
+
+          def to_pb_from(rb)
+            return unless rb
+
+            f = proto_message.find('value', by: :ident, as: 'Protod::Proto::Field')
+
+            return unless f
+
+            pb_maker = ->(v) do
+              f.interpreter.to_pb_from(v).tap do
+                _1.protod__object_id = v.object_id.to_s if _1.respond_to?(:protod__object_id)
+              end
+            end
+
+            pb = f.repeated ? rb.map { pb_maker.call(_1) } : pb_maker.call(rb)
+
+            pb_const.new(value: pb)
+          end
+        end
+
+        Interpreter.register_for('Protod::Rpc::Request::Receiver::Base', force: false, ignore: true) do
+          def proto_ident
+            "Request"
+          end
+
+          def proto_message
+            f = Protod::Proto::Oneof.new(ident: Protod::Rpc::Request::Receiver::ONEOF_NAME)
+
+            [
+              *proto_fields,
+              *const.ruby_ident.const_name.constantize.ancestors.drop(1).filter_map do |c|
+                r = Protod::Rpc::Request.find_by(c.name) if c.name
+                Interpreter.find_by(r) if r
+              end.flat_map(&:proto_fields)
+            ].each { f.find_or_push(_1, by: :ident, into: :fields) }
+
+            Protod::Proto::Message.new(ident: proto_ident, fields: [f])
+          end
+
+          def to_rb_from(pb)
+            procedure = pb.public_send(Protod::Rpc::Request::Receiver::ONEOF_NAME)
+
+            raise Protod::Rpc::Handler::InvalidArgument, "Not set procedure" unless procedure
+
+            f = proto_message
+                  .find(Protod::Rpc::Request::Receiver::ONEOF_NAME, by: :ident, as: 'Protod::Proto::Oneof')
+                  .find(procedure, by: :ident, as: 'Protod::Proto::Field')
+
+            raise Protod::Rpc::Handler::InvalidArgument, "Not found acceptable procedure : #{procedure}" unless f
+
+            f.interpreter.to_rb_from(pb.public_send(procedure)).tap { _1.procedure = procedure }
+          end
+
+          def proto_fields
+            const.procedures.map do |ruby_ident|
+              Protod::Proto::Field.build_from(Protod::Rpc::Request.find_by(ruby_ident), ident: ruby_ident.method_name)
+            end
+          end
+        end
+
+        Interpreter.register_for('Protod::Rpc::Response::Receiver::Base', force: false, ignore: true) do
+          def proto_ident
+            "Response"
+          end
+
+          def proto_message
+            f = Protod::Proto::Oneof.new(ident: Protod::Rpc::Response::Receiver::ONEOF_NAME)
+
+            [
+              *proto_fields,
+              *const.ruby_ident.const_name.constantize.ancestors.drop(1).filter_map do |c|
+                r = Protod::Rpc::Response.find_by(c.name) if c.name
+                Interpreter.find_by(r) if r
+              end.flat_map(&:proto_fields)
+            ].each { f.find_or_push(_1, by: :ident, into: :fields) }
+
+            Protod::Proto::Message.new(ident: proto_ident, fields: [f])
+          end
+
+          def to_pb_from(packet)
+            f = proto_message
+                  .find(Protod::Rpc::Response::Receiver::ONEOF_NAME, by: :ident, as: 'Protod::Proto::Oneof')
+                  .find(packet.procedure, by: :ident, as: 'Protod::Proto::Field')
+
+            pb = f.interpreter.to_pb_from(packet.object)
+
+            pb_const.new(packet.procedure.to_sym => pb)
+          end
+
+          def proto_fields
+            const.procedures.map do |ruby_ident|
+              Protod::Proto::Field.build_from(Protod::Rpc::Response.find_by(ruby_ident), ident: ruby_ident.method_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protod/interpreter.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+class Protod
+  class Interpreter
+    class << self
+      def register_for(*const_names, with: nil, parent: nil, path: nil, force: true, ignore: false, &body)
+        base = if with
+                 find_by(with)&.class or raise ArgumentError, "Not found the interpreter for #{with}"
+               else
+                 Base
+               end
+
+        Class.new(base, &body).tap do |interpreter_const|
+          const_names.each do
+            c = Protod::RubyIdent.absolute_of(_1).safe_constantize
+
+            raise ArgumentError, "Not found to constantize for #{_1}" unless c
+
+            next if map.key?(c) && ignore
+
+            raise ArgumentError, "Interpreter already regsitered for #{c.name}" if map.key?(c) && !force
+
+            map[c] = { const: interpreter_const, parent: parent, path: path }
+          end
+        end
+      end
+
+      def find_by(const_or_name, with_register_from_ancestor: false)
+        const_name  = const_or_name.is_a?(::String) ? Protod::RubyIdent.absolute_of(const_or_name) : nil
+        const       = const_or_name.is_a?(::String) ? const_or_name.safe_constantize : const_or_name
+        entryables  = const.respond_to?(:ancestors) ? const.ancestors : [const]
+        entry_const = entryables.compact.find { map.key?(_1) }
+        entry       = entry_const && map.fetch(entry_const)
+
+        return unless entry
+
+        unless entry.is_a?(Base)
+          entry = map[entry_const] = entry.fetch(:const).new(entry_const, **entry.except(:const)).tap do
+            _1.extend SkipNilAbility
+            _1.extend ProtoMessageCacheable
+          end
+        end
+
+        return entry unless with_register_from_ancestor
+
+        unless map[const].is_a?(Base)
+          map[const] = entry.class.new(const, parent: entry.parent, path: entry.path).tap do
+            _1.extend SkipNilAbility
+            _1.extend ProtoMessageCacheable
+          end
+        end
+
+        map.fetch(const)
+      end
+
+      def find_by_proto(full_ident)
+        raise NotImplementedError, "You need to call Protod::Interpreter.setup_reverse_lookup! before" unless @reverse_map
+
+        @reverse_map[full_ident]
+      end
+
+      def keys
+        map.keys
+      end
+
+      def reverse_keys
+        @reverse_map&.keys
+      end
+
+      def clear!
+        @map = nil
+        @reverse_map = nil
+      end
+
+      def setup_reverse_lookup!
+        @reverse_map = keys.map { find_by(_1) }.uniq.map { [_1.proto_full_ident, _1] }.to_h
+      end
+
+      private
+
+      def map
+        @map ||= {}
+      end
+    end
+
+    module SkipNilAbility
+      def to_pb_from(rb)
+        return if rb.nil?
+        super
+      end
+
+      def to_rb_from(pb)
+        return if pb.nil?
+        super
+      end
+    end
+
+    module ProtoMessageCacheable
+      def proto_message
+        if @_proto_message.nil?
+          @_proto_message = super&.tap do |m|
+            next if const.ancestors.any? { _1.in?([Protod::Rpc::Request::Base, Protod::Rpc::Response::Base]) }
+
+            m.fields.unshift(Protod::Proto::Field.build_from('::String', ident: 'protod__object_id', optional: true))
+          end
+
+          @_proto_message = false unless @_proto_message
+        end
+
+        @_proto_message ? @_proto_message : nil
+      end
+    end
+
+    class Base
+      attr_reader :const, :parent, :path
+
+      def initialize(const, parent: nil, path: nil)
+        @const  = const
+        @parent = parent
+        @path   = path
+      end
+
+      def ==(other)
+        const == other.const && parent == other.parent && path == other.path
+      end
+
+      def bindable?
+        return false unless proto_message
+        return false if bound?
+        true
+      end
+
+      def bound?
+        return false unless proto_message
+
+        parent.nil?.!
+      end
+
+      def set_parent(v)
+        raise ArgumentError, "Can't set parent #{v.full_ident} for #{proto_ident} as #{const.name} : already set #{parent.full_ident}" unless parent.nil?
+        @parent = v
+      end
+
+      def package
+        return parent if parent.is_a?(Protod::Proto::Package)
+
+        parent&.ancestor_as(Protod::Proto::Package)
+      end
+
+      def proto_path
+        @path || package&.proto_path
+      end
+
+      def proto_full_ident
+        [parent&.full_ident, proto_ident].compact.join('.').presence
+      end
+
+      def proto_ident
+        Protod::Proto::Ident.build_from(const.name)
+      end
+
+      def proto_message
+        nil
+      end
+
+      def pb_const
+        proto_message&.pb_const ||
+          Google::Protobuf::DescriptorPool.generated_pool.lookup(proto_full_ident)&.msgclass
+      end
+
+      def to_pb_from(rb)
+        raise NotImplementedError, "You need to implement #{__method__} for #{const.name}"
+      end
+
+      def to_rb_from(pb)
+        raise NotImplementedError, "You need to implement #{__method__} for #{const.name}"
+      end
+    end
+  end
+end