Add first "known type" implementation

Rakefile

@@ -8,11 +8,25 @@ rb_files = proto_files.pathmap("#{BASE_DIR}/lib/proto/test/fixtures/%n_pb.rb")
 BENCHMARK_UPSTREAM_PB = "bench/lib/upstream/benchmark_pb.rb"
 BENCHMARK_PROTOBOEUF_PB = "bench/lib/protoboeuf/benchmark_pb.rb"
 
+well_known_types = Rake::FileList[File.join(BASE_DIR, "lib/protoboeuf/protobuf/*.proto")]
+
 # Clobber/clean rules
 rb_files.each { |x| CLOBBER.append x }
 CLOBBER.append BENCHMARK_UPSTREAM_PB
 CLOBBER.append BENCHMARK_PROTOBOEUF_PB
 
+rule ".rb" => "%X.proto" do |t|
+  require_relative "lib/protoboeuf/codegen"
+  require_relative "lib/protoboeuf/parser"
+
+  unit = ProtoBoeuf.parse_file t.source
+
+  puts "writing #{t.name}"
+  File.binwrite t.name, unit.to_ruby
+end
+
+task :well_known_types => well_known_types.pathmap("%X.rb")
+
 # Makefile-like rule to generate "_pb.rb"
 rule "_pb.rb" => "test/fixtures/%{_pb,}n.proto" do |task|
   mkdir_p "lib/proto"
@@ -55,7 +69,7 @@ end
 desc "Regenerate protobuf files"
 task :gen_proto => rb_files
 
-task :test => :gen_proto
+task :test => [:gen_proto, :well_known_types]
 task :default => :test
 
 task :bench => [BENCHMARK_UPSTREAM_PB, BENCHMARK_PROTOBOEUF_PB] do

lib/protoboeuf/codegen.rb

@@ -55,6 +55,7 @@ def initialize(message, toplevel_enums)
         @optional_field_bit_lut = []
         @fields = @message.fields
         @enum_field_types = toplevel_enums.merge(message.enums.group_by(&:name))
+        @requires = Set.new
 
         field_types = message.fields.group_by { |field|
           if field.field?
@@ -74,7 +75,12 @@ def initialize(message, toplevel_enums)
       end
 
       def result
-        "class #{message.name}\n" + class_body + "end\n"
+        body = "class #{message.name}\n" + class_body + "end\n"
+        if @requires.empty?
+          body
+        else
+          @requires.map { |r| "require #{r.dump}" }.join("\n") + "\n\n" + body
+        end
       end
 
       private
@@ -653,6 +659,11 @@ def decode_repeated(field)
       end
 
       def pull_message(type, dest, operator)
+        if type == "google.protobuf.UInt64Value"
+          @requires << "protoboeuf/protobuf/uint64value"
+          type = "ProtoBoeuf::Protobuf::UInt64Value"
+        end
+
         "        ## PULL_MESSAGE\n" +
           pull_uint64("msg_len", "=") + "\n" +
           "        #{dest} #{operator} #{type}.allocate.decode_from(buff, index, index += msg_len)\n" +
@@ -772,7 +783,7 @@ def to_ruby
 
       tail = "\n" + packages.map { unindent.call + "end" }.join("\n")
 
-      head + body + tail
+      (head + body + tail).gsub(/[ ]*(?=$)/, '')
     end
   end
 end

lib/protoboeuf/parser.rb

@@ -50,6 +50,10 @@ class Unit < Struct.new(:package, :options, :imports, :messages, :enums)
     def accept(viz)
       viz.visit_unit self
     end
+
+    def to_ruby
+      ProtoBoeuf::CodeGen.new(self).to_ruby
+    end
   end
 
   class Option < Struct.new(:name, :value, :pos)

lib/protoboeuf/protobuf/uint64value.proto

@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+package proto_boeuf.protobuf;
+
+message UInt64Value {
+  uint64 value = 1;
+}

lib/protoboeuf/protobuf/uint64value.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module ProtoBoeuf
+  module Protobuf
+
+    class UInt64Value
+      def self.decode(buff)
+        buff = buff.dup
+        buff.force_encoding("UTF-8")
+        allocate.decode_from(buff, 0, buff.bytesize)
+      end
+
+      # required field readers
+      attr_accessor :value
+
+      # enum readers
+
+      # enum writers
+
+      def initialize(value: 0)
+        @value = value
+      end
+
+      def decode_from(buff, index, len)
+
+          @value = 0
+
+                tag = buff.getbyte(index)
+            index += 1
+
+
+        while true
+          if tag == 0x8
+                    ## PULL_UINT64
+            @value =       if (byte0 = buff.getbyte(index)) < 0x80
+            index += 1
+            byte0
+          else
+            if (byte1 = buff.getbyte(index + 1)) < 0x80
+              index += 2
+              (byte1 << 7) | (byte0 & 0x7F)
+            else
+              if (byte2 = buff.getbyte(index + 2)) < 0x80
+                index += 3
+                (byte2 << 14) |
+                        ((byte1 & 0x7F) << 7) |
+                        (byte0 & 0x7F)
+              else
+                if (byte3 = buff.getbyte(index + 3)) < 0x80
+                  index += 4
+                  (byte3 << 21) |
+                          ((byte2 & 0x7F) << 14) |
+                          ((byte1 & 0x7F) << 7) |
+                          (byte0 & 0x7F)
+                else
+                  if (byte4 = buff.getbyte(index + 4)) < 0x80
+                    index += 5
+                    (byte4 << 28) |
+                            ((byte3 & 0x7F) << 21) |
+                            ((byte2 & 0x7F) << 14) |
+                            ((byte1 & 0x7F) << 7) |
+                            (byte0 & 0x7F)
+                  else
+                    if (byte5 = buff.getbyte(index + 5)) < 0x80
+                      index += 6
+                      (byte5 << 35) |
+                              ((byte4 & 0x7F) << 28) |
+                              ((byte3 & 0x7F) << 21) |
+                              ((byte2 & 0x7F) << 14) |
+                              ((byte1 & 0x7F) << 7) |
+                              (byte0 & 0x7F)
+                    else
+                      if (byte6 = buff.getbyte(index + 6)) < 0x80
+                        index += 7
+                        (byte6 << 42) |
+                                ((byte5 & 0x7F) << 35) |
+                                ((byte4 & 0x7F) << 28) |
+                                ((byte3 & 0x7F) << 21) |
+                                ((byte2 & 0x7F) << 14) |
+                                ((byte1 & 0x7F) << 7) |
+                                (byte0 & 0x7F)
+                      else
+                        if (byte7 = buff.getbyte(index + 7)) < 0x80
+                          index += 8
+                          (byte7 << 49) |
+                                  ((byte6 & 0x7F) << 42) |
+                                  ((byte5 & 0x7F) << 35) |
+                                  ((byte4 & 0x7F) << 28) |
+                                  ((byte3 & 0x7F) << 21) |
+                                  ((byte2 & 0x7F) << 14) |
+                                  ((byte1 & 0x7F) << 7) |
+                                  (byte0 & 0x7F)
+                        else
+                          if (byte8 = buff.getbyte(index + 8)) < 0x80
+                            index += 9
+                            (byte8 << 56) |
+                                    ((byte7 & 0x7F) << 49) |
+                                    ((byte6 & 0x7F) << 42) |
+                                    ((byte5 & 0x7F) << 35) |
+                                    ((byte4 & 0x7F) << 28) |
+                                    ((byte3 & 0x7F) << 21) |
+                                    ((byte2 & 0x7F) << 14) |
+                                    ((byte1 & 0x7F) << 7) |
+                                    (byte0 & 0x7F)
+                          else
+                            if (byte9 = buff.getbyte(index + 9)) < 0x80
+                              index += 10
+
+                              (byte9 << 63) |
+                                      ((byte8 & 0x7F) << 56) |
+                                      ((byte7 & 0x7F) << 49) |
+                                      ((byte6 & 0x7F) << 42) |
+                                      ((byte5 & 0x7F) << 35) |
+                                      ((byte4 & 0x7F) << 28) |
+                                      ((byte3 & 0x7F) << 21) |
+                                      ((byte2 & 0x7F) << 14) |
+                                      ((byte1 & 0x7F) << 7) |
+                                      (byte0 & 0x7F)
+                            else
+                              raise "integer decoding error"
+                            end
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+            ## END PULL_UINT64
+
+
+            return self if index >= len
+                    tag = buff.getbyte(index)
+            index += 1
+
+          end
+
+          return self if index >= len
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

test/fixtures/test.proto

@@ -210,3 +210,7 @@ message HasSubEnum {
 
   Thing a = 1;
 }
+
+message HasKnownValue {
+  google.protobuf.UInt64Value id = 1;
+}

test/helper.rb

@@ -1,3 +1,5 @@
+ENV["MT_NO_PLUGINS"] = "1"
+
 require "minitest/autorun"
 require "minitest/color"
 require "proto/test/fixtures/test_pb"

test/message_test.rb

@@ -471,4 +471,14 @@ def test_subenum_methods
 
     assert_equal expected.a, actual.a
   end
+
+  def test_translate_known_types_in_proto
+    data = ::HasKnownValue.encode(::HasKnownValue.new.tap { |x|
+      x.id = Google::Protobuf::UInt64Value.new(value: 123456)
+    })
+
+    instance = HasKnownValue.decode(data)
+    assert_kind_of ::ProtoBoeuf::Protobuf::UInt64Value, instance.id
+    assert_equal 123456, instance.id.value
+  end
 end