add timestamp ext

Author: Asmod4n

build_config.rb

@@ -5,5 +5,6 @@
   conf.cxx.flags << '-fno-omit-frame-pointer'
   conf.enable_debug
   conf.enable_test
+  conf.gembox 'default'
   conf.gem File.expand_path(File.dirname(__FILE__))
 end

mrbgem.rake

@@ -12,9 +12,12 @@ MRuby::Gem::Specification.new('mruby-simplemsgpack') do |spec|
   spec.add_dependency 'mruby-error'
   spec.add_dependency 'mruby-string-is-utf8'
   spec.add_dependency 'mruby-c-ext-helpers'
+  spec.add_dependency 'mruby-time'
   spec.add_conflict   'mruby-msgpack'
   spec.add_test_dependency 'mruby-string-ext'
   spec.add_test_dependency 'mruby-random'
+  spec.add_test_dependency 'mruby-pack'
+  spec.add_test_dependency 'mruby-io'
   spec.cxx.flags << '-std=c++17' if spec.cxx.flags && !spec.cxx.flags.include?('-std=c++17')
 
   include_dir = File.join(spec.build_dir, 'include')

src/mrb_msgpack.cpp

@@ -15,6 +15,7 @@
 #include <mruby/presym.h>
 #include <mruby/msgpack.h>
 #include <mruby/proc.h>
+#include <mruby/time.h>
 
 MRB_BEGIN_DECL
 #include <mruby/internal.h>
@@ -523,6 +524,56 @@ mrb_msgpack_pack_hash_value(mrb_state* mrb,
   );
 }
 
+static void
+mrb_msgpack_pack_time_ext(mrb_state* mrb, mrb_value time, msgpack::packer<mrb_msgpack_sbo_writer>& pk)
+{
+    // epoch seconds
+    mrb_int sec_i = mrb_integer(mrb_funcall_argv(mrb, time, MRB_SYM(to_i), 0, nullptr));
+    int64_t sec = (int64_t)sec_i;
+
+    // nanoseconds
+    mrb_int nsec_i = mrb_integer(mrb_funcall_argv(mrb, time, MRB_SYM(nsec), 0, nullptr));
+    int64_t nsec = (int64_t)nsec_i;
+
+    // 32‑bit format
+    if (nsec == 0 && sec >= 0 && sec < (1LL << 32)) {
+        char buf[4];
+        buf[0] = (sec >> 24) & 0xFF;
+        buf[1] = (sec >> 16) & 0xFF;
+        buf[2] = (sec >> 8)  & 0xFF;
+        buf[3] =  sec        & 0xFF;
+
+        pk.pack_ext(4, -1);
+        pk.pack_ext_body(buf, 4);
+        return;
+    }
+
+    // 64‑bit format
+    if (sec >= 0 && sec < (1LL << 34) && nsec >= 0 && nsec < 1000000000) {
+        uint64_t v = ((uint64_t)nsec << 34) | (uint64_t)sec;
+        char buf[8];
+        for (int i = 7; i >= 0; --i) { buf[i] = v & 0xFF; v >>= 8; }
+
+        pk.pack_ext(8, -1);
+        pk.pack_ext_body(buf, 8);
+        return;
+    }
+
+    // 96‑bit format
+    char buf[12];
+    buf[0] = (nsec >> 24) & 0xFF;
+    buf[1] = (nsec >> 16) & 0xFF;
+    buf[2] = (nsec >> 8)  & 0xFF;
+    buf[3] =  nsec        & 0xFF;
+
+    uint64_t s = (uint64_t)sec;
+    for (int i = 11; i >= 4; --i) { buf[i] = s & 0xFF; s >>= 8; }
+
+    pk.pack_ext(12, -1);
+    pk.pack_ext_body(buf, 12);
+}
+
+
 /* ------------------------------------------------------------------------
  * Core pack dispatcher
  * ------------------------------------------------------------------------ */
@@ -570,6 +621,11 @@ mrb_msgpack_pack_value(mrb_state* mrb,
     }  break;
 
     default: {
+      struct RClass *time_class = mrb_class_get_id(mrb, MRB_SYM(Time));
+      if(mrb_obj_is_kind_of(mrb, self, time_class)) {
+        mrb_msgpack_pack_time_ext(mrb, self, pk);
+        break;
+      }
       if (mrb_msgpack_pack_ext_value(mrb, self, pk)) break;
 
       mrb_value v;
@@ -719,6 +775,11 @@ mrb_msgpack_register_pack_type(mrb_state* mrb, mrb_value self)
               "cannot register ext packer for Symbols, use the new MessagePack.sym_strategy function.");
   }
 
+  struct RClass *time_class = mrb_class_get_id(mrb, MRB_SYM(Time));
+  if (mrb_class_ptr(mrb_class) == time_class) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "cannot register ext packer for Time, timestamp ext (-1) is reserved");
+  }
+
   ext_packers = ext_packers_hash(mrb);
   ext_config = mrb_hash_new_capa(mrb, 2);
 
@@ -769,6 +830,56 @@ mrb_msgpack_unpack_symbol_as_string(mrb_state* mrb, const msgpack::object& obj)
   );
 }
 
+static mrb_value
+mrb_msgpack_unpack_timestamp(mrb_state* mrb, const msgpack::object& obj)
+{
+  const char* p = obj.via.ext.data();
+  uint32_t size = obj.via.ext.size;
+
+  switch (size) {
+    case 4: {
+      uint32_t sec =
+        ((uint32_t)(uint8_t)p[0] << 24) |
+        ((uint32_t)(uint8_t)p[1] << 16) |
+        ((uint32_t)(uint8_t)p[2] << 8)  |
+        ((uint32_t)(uint8_t)p[3]);
+      return mrb_time_at(mrb, (time_t)sec, 0, MRB_TIMEZONE_UTC);
+    }
+
+    case 8: {
+      uint64_t v = 0;
+      for (int i = 0; i < 8; ++i) v = (v << 8) | (uint8_t)p[i];
+
+      // top 30 bits = nanoseconds
+      uint32_t nsec = (v >> 34) & 0x3fffffff;  // mask top 30 bits
+      uint64_t sec  = v & 0x3ffffffff;          // mask lower 34 bits
+
+      // nsec ist uint64_t aus 64-bit oder 32-bit Timestamp
+      mrb_int usec = (mrb_int)(nsec / 1000);  // Nanoseconds → Microseconds
+
+      return mrb_time_at(mrb, (time_t)sec, usec, MRB_TIMEZONE_UTC);
+    }
+
+    case 12: {
+      uint32_t nsec =
+        ((uint32_t)(uint8_t)p[0] << 24) |
+        ((uint32_t)(uint8_t)p[1] << 16) |
+        ((uint32_t)(uint8_t)p[2] << 8)  |
+        ((uint32_t)(uint8_t)p[3]);
+
+      uint64_t sec = 0;
+      for (int i = 4; i < 12; ++i) sec = (sec << 8) | (uint8_t)p[i];
+
+      return mrb_time_at(mrb, (time_t)sec, (time_t)(nsec / 1000), MRB_TIMEZONE_UTC); // divide by 1000 for microseconds
+
+    }
+
+    default:
+      mrb_raise(mrb, E_MSGPACK_ERROR, "invalid timestamp ext length");
+  }
+}
+
+
 /* ------------------------------------------------------------------------
  * Core unpack dispatch
  * ------------------------------------------------------------------------ */
@@ -811,6 +922,9 @@ mrb_unpack_msgpack_obj(mrb_state* mrb, const msgpack::object& obj)
       if (ext_type == ctx->ext_type && ctx->sym_unpacker != nullptr) {
         return ctx->sym_unpacker(mrb, obj);
       }
+      if (ext_type == -1) {
+        return mrb_msgpack_unpack_timestamp(mrb, obj);
+      }
       mrb_value unpacker = mrb_hash_get(
         mrb,
         ext_unpackers_hash(mrb),

test/msgpack.rb

@@ -588,3 +588,137 @@ class HotY; end
 
   assert_raise(IndexError) { lazy.at_pointer("/a/999") }
 end
+
+assert("MessagePack::TimestampExt roundtrip") do
+  # 32-bit format: nsec = 0, sec < 2^32
+  t32 = Time.at(1_234_567_890, 0)
+  packed = MessagePack.pack(t32)
+  unpacked = MessagePack.unpack(packed)
+  assert_equal t32.to_i, unpacked.to_i
+  assert_equal t32.nsec, unpacked.nsec
+
+  # 64-bit format: sec < 2^34, nsec < 1e9
+  t64 = Time.at((1 << 33) + 123, 456_789)
+  packed = MessagePack.pack(t64)
+  unpacked = MessagePack.unpack(packed)
+  assert_equal t64.to_i, unpacked.to_i
+  assert_equal t64.nsec, unpacked.nsec
+
+  # 96-bit format: sec >= 2^34
+  t96 = Time.at((1 << 40) + 5, 123_456)
+  packed = MessagePack.pack(t96)
+  unpacked = MessagePack.unpack(packed)
+  assert_equal t96.to_i, unpacked.to_i
+  assert_equal t96.nsec, unpacked.nsec
+
+  # negative times → always 96-bit
+  tneg = Time.at(-123456789, 987654)
+  packed = MessagePack.pack(tneg)
+  unpacked = MessagePack.unpack(packed)
+  assert_equal tneg.to_i, unpacked.to_i
+  assert_equal tneg.nsec, unpacked.nsec
+
+
+  # registering a packer for Time must raise
+  assert_raise(RangeError) do
+    MessagePack.register_pack_type(-1, Time) { |t| "nope" }
+  end
+end
+
+assert("MessagePack::TimestampExt: 32/64/96-bit formats") do
+  #
+  # 32‑bit timestamp (fixext 4)
+  # sec fits in uint32, nsec == 0
+  #
+  t32 = Time.at(1454932800, 0) # 2016-02-08 12:00:00 UTC
+  vec32 = MessagePack.pack(t32)
+  assert_equal 6, vec32.bytesize
+  assert_equal 0xd6, vec32.bytes[0]  # fixext 4
+  assert_equal 0xff, vec32.bytes[1]  # type -1
+  t32u = MessagePack.unpack(vec32)
+  assert_equal t32.to_i, t32u.to_i
+  assert_equal t32.nsec, t32u.nsec
+
+  #
+  # 64‑bit timestamp (fixext 8)
+  # sec < 2^34, nsec < 1e9, but nsec != 0
+  #
+  t64 = Time.at(1454932800, 123_456) # force 64-bit (nsec != 0)
+  vec64 = MessagePack.pack(t64)
+  assert_equal 10, vec64.bytesize
+  assert_equal 0xd7, vec64.bytes[0]  # fixext 8
+  assert_equal 0xff, vec64.bytes[1]  # type -1
+  t64u = MessagePack.unpack(vec64)
+  assert_equal t64.to_i, t64u.to_i
+  assert_equal t64.nsec, t64u.nsec
+
+  #
+  # 96‑bit timestamp (ext 12)
+  # sec >= 2^34 OR negative OR nsec >= 1e9
+  #
+  t96 = Time.at((1 << 40) + 5, 987_654) # sec forces 96-bit
+  vec96 = MessagePack.pack(t96)
+  assert_equal 15, vec96.bytesize
+  assert_equal 0xc7, vec96.bytes[0]  # ext 8/16/32 header
+  assert_equal 0x0c, vec96.bytes[1]  # 12 bytes body
+  assert_equal 0xff, vec96.bytes[2]  # type -1
+  t96u = MessagePack.unpack(vec96)
+  assert_equal t96.to_i, t96u.to_i
+  assert_equal t96.nsec, t96u.nsec
+end
+
+assert("MessagePack::TimestampExt vectors from file") do
+  path = File.join(File.dirname(__FILE__), "timestamp_vectors.bin")
+  data = File.read(path)
+
+  # Die Datei enthält:
+  #   ts32_body (4 bytes)
+  #   ts64_body (8 bytes)
+  #   ts96_body (12 bytes)
+  #
+  # Reihenfolge exakt wie im Python-Script
+
+  off = 0
+
+  # --- 32-bit Timestamp ---
+  body32 = data[off, 4]
+  off += 4
+
+  vec32 = [
+    0xD6,       # fixext 4
+    0xFF        # type -1
+  ].pack("C*") + body32
+
+  t32 = MessagePack.unpack(vec32)
+  assert_equal 1, t32.to_i
+  assert_equal 0, t32.nsec
+
+
+  # --- 64-bit Timestamp ---
+  body64 = data[off, 8]
+  off += 8
+
+  vec64 = [
+    0xD7,       # fixext 8
+    0xFF        # type -1
+  ].pack("C*") + body64
+
+  t64 = MessagePack.unpack(vec64)
+  assert_equal 1, t64.to_i
+  assert_equal 500_000_000, t64.nsec
+
+
+  # --- 96-bit Timestamp ---
+  body96 = data[off, 12]
+  off += 12
+
+  vec96 = [
+    0xC7,       # ext
+    0x0C,       # size = 12
+    0xFF        # type -1
+  ].pack("C*") + body96
+
+  t96 = MessagePack.unpack(vec96)
+  assert_equal(-1, t96.to_i)
+  assert_equal 999_999_000, t96.nsec
+end