self_msgproto 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cab7cc6b6f6a48df982c1ee3d9b170e85cfd55178f79bdab9e6ced5676f52199
-  data.tar.gz: 88f152ebe1b13969258c96be8d1fb98036a51509957e236bdf2ece2a15c18389
+  metadata.gz: 48e361d23d4dcd09aca2e053666f340703bc99c345991700203acc0a7135cc4f
+  data.tar.gz: 8c8320a08ee30316c4d82d64b8b480bc4afba8758ae596f3de374d3f4dde8965
 SHA512:
-  metadata.gz: 7903916cb4d14f524c312b582b92b19d18094a582df509ae8e2cb3df8621d2b852dae659d6faf306b6402a4335c96faed5309495e997ee80cb93095baedc1255
-  data.tar.gz: 84fa5070a8d235c1e42ca4b8a93407861288b3ccb62ac307dadebb62482055afbdeca52907aaa3bae85341d29a04bc397e1f5de82694715ddc48deb78d50a370
+  metadata.gz: acab917323d1f4f8c3c614230f6e9b22b476d6a1931fd1b53fb1b0e1700ab2462b32e01d888397b231ab3dc30e32ebfffc2dd80149a0e58a07fb4cca4f5de985
+  data.tar.gz: 19fd66580d5afad7ef089b3dfd4f6dd32c5dde613d51e24ca0072312e7fc75979273b7d17022edbfdcee2e942dd9fcf2530a5ef69519ee6e8fde07aed26dc0b5

data/ext/self_msgproto/message.cpp

@@ -35,41 +35,50 @@ VALUE message_initialize(int argc, VALUE *argv, VALUE self)
 
         auto id = msg->id()->c_str();
         auto mtype = msg->msgtype();
-        auto stype = msg->subtype();
         auto sender = msg->sender()->c_str();
         auto recipient = msg->recipient()->c_str();
         auto ciphertext = msg->ciphertext();
         auto metadata = msg->metadata();
+        auto message_type = msg->message_type();
+        auto priority = msg->priority();
 
         auto offset = metadata->offset();
         auto timestamp = metadata->timestamp();
 
-        VALUE idstr = rb_str_new(id, std::strlen(id));
-        rb_ivar_set(self, rb_intern("@id"), idstr);
+        VALUE id_str = rb_str_new(id, std::strlen(id));
+        rb_ivar_set(self, rb_intern("@id"), id_str);
 
-        VALUE mtypeint = rb_int2inum(mtype);
-        rb_ivar_set(self, rb_intern("@type"), mtypeint);
+        VALUE mtype_int = rb_int2inum(mtype);
+        rb_ivar_set(self, rb_intern("@type"), mtype_int);
 
-        VALUE stypeint = rb_int2inum(stype);
-        rb_ivar_set(self, rb_intern("@subtype"), stypeint);
+        VALUE offset_int = rb_int2inum(offset);
+        rb_ivar_set(self, rb_intern("@offset"), offset_int);
 
-        VALUE offsetint = rb_int2inum(offset);
-        rb_ivar_set(self, rb_intern("@offset"), offsetint);
+        VALUE priority_int = rb_int2inum(priority);
+        rb_ivar_set(self, rb_intern("@priority"), priority_int);
 
-        VALUE timestampint = rb_int2inum(timestamp);
-        rb_ivar_set(self, rb_intern("@timestamp"), timestampint);
+        VALUE timestamp_int = rb_int2inum(timestamp);
+        rb_ivar_set(self, rb_intern("@timestamp"), timestamp_int);
 
-        VALUE senderstr = rb_str_new(sender, std::strlen(sender));
-        rb_ivar_set(self, rb_intern("@sender"), senderstr);
+        VALUE sender_str = rb_str_new(sender, std::strlen(sender));
+        rb_ivar_set(self, rb_intern("@sender"), sender_str);
 
-        VALUE recipientstr = rb_str_new(recipient, std::strlen(recipient));
-        rb_ivar_set(self, rb_intern("@recipient"), recipientstr);
+        VALUE recipient_str = rb_str_new(recipient, std::strlen(recipient));
+        rb_ivar_set(self, rb_intern("@recipient"), recipient_str);
 
-        const u_char *ciphertextdata = ciphertext->data();
-        long ciphertextsize = ciphertext->size();
+        if (message_type != NULL) {
+            const u_char *message_type_data = message_type->data();
+            long message_type_size = message_type->size();
 
-        VALUE ciphertextstr = rb_str_new((const char *)ciphertextdata, ciphertextsize);
-        rb_ivar_set(self, rb_intern("@ciphertext"), ciphertextstr);
+            VALUE message_type_str = rb_str_new((const char *)message_type_data, message_type_size);
+            rb_ivar_set(self, rb_intern("@message_type"), message_type_str);
+        }
+
+        const u_char *ciphertext_data = ciphertext->data();
+        long ciphertext_size = ciphertext->size();
+
+        VALUE ciphertext_str = rb_str_new((const char *)ciphertext_data, ciphertext_size);
+        rb_ivar_set(self, rb_intern("@ciphertext"), ciphertext_str);
     }
 
     return self;
@@ -77,25 +86,43 @@ VALUE message_initialize(int argc, VALUE *argv, VALUE self)
 
 VALUE message_to_fb(VALUE self) 
 {
-    VALUE idv = rb_ivar_get(self, rb_intern("@id"));
-    char *idstr = RSTRING_PTR(idv);
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message_type;
+    u_char *message_type_str;
+    long message_type_len;
+
+    VALUE id_v = rb_ivar_get(self, rb_intern("@id"));
+    char *id_str = RSTRING_PTR(id_v);
+
+    VALUE sender_v = rb_ivar_get(self, rb_intern("@sender"));
+    char *sender_str = RSTRING_PTR(sender_v);
+
+    VALUE recipient_v = rb_ivar_get(self, rb_intern("@recipient"));
+    char *recipient_str = RSTRING_PTR(recipient_v);
 
-    VALUE senderv = rb_ivar_get(self, rb_intern("@sender"));
-    char *senderstr = RSTRING_PTR(senderv);
+    VALUE priority_v = rb_ivar_get(self, rb_intern("@priority"));
+    uint32_t priority = NUM2ULL(priority_v);
 
-    VALUE recipientv = rb_ivar_get(self, rb_intern("@recipient"));
-    char *recipientstr = RSTRING_PTR(recipientv);
+    VALUE message_type_v = rb_ivar_get(self, rb_intern("@message_type"));
 
-    VALUE ciphertextv = rb_ivar_get(self, rb_intern("@ciphertext"));
-    u_char *ciphertextstr = (u_char *)RSTRING_PTR(ciphertextv);
-    long ciphertextlen = RSTRING_LEN(ciphertextv);
+    if (message_type_v != Qnil) {
+        u_char *message_type_str = (u_char *)RSTRING_PTR(message_type_v);
+        long message_type_len = RSTRING_LEN(message_type_v);
+    }
+
+    VALUE ciphertext_v = rb_ivar_get(self, rb_intern("@ciphertext"));
+    u_char *ciphertext_str = (u_char *)RSTRING_PTR(ciphertext_v);
+    long ciphertext_len = RSTRING_LEN(ciphertext_v);
 
     flatbuffers::FlatBufferBuilder builder(1024);
 
-    auto id = builder.CreateString(idstr);
-    auto sender = builder.CreateString(senderstr);
-    auto recipient = builder.CreateString(recipientstr);
-    auto ciphertext = builder.CreateVector(ciphertextstr, ciphertextlen);
+    auto id = builder.CreateString(id_str);
+    auto sender = builder.CreateString(sender_str);
+    auto recipient = builder.CreateString(recipient_str);
+    auto ciphertext = builder.CreateVector(ciphertext_str, ciphertext_len);
+
+    if (message_type_v != Qnil) {
+        message_type = builder.CreateVector(message_type_str, message_type_len);
+    }
 
     SelfMessaging::Metadata metadata(0, 0);
 
@@ -107,6 +134,11 @@ VALUE message_to_fb(VALUE self)
     msg_builder.add_recipient(recipient);
     msg_builder.add_ciphertext(ciphertext);
     msg_builder.add_metadata(&metadata);
+    msg_builder.add_priority(priority);
+
+    if (message_type_v != Qnil) {
+        msg_builder.add_message_type(message_type);
+    }
 
     auto msg = msg_builder.Finish();
     builder.Finish(msg);

data/ext/self_msgproto/msgproto/message_generated.h

@@ -32,15 +32,9 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Metadata FLATBUFFERS_FINAL_CLASS {
   int64_t timestamp() const {
     return flatbuffers::EndianScalar(timestamp_);
   }
-  void mutate_timestamp(int64_t _timestamp) {
-    flatbuffers::WriteScalar(&timestamp_, _timestamp);
-  }
   int64_t offset() const {
     return flatbuffers::EndianScalar(offset_);
   }
-  void mutate_offset(int64_t _offset) {
-    flatbuffers::WriteScalar(&offset_, _offset);
-  }
 };
 FLATBUFFERS_STRUCT_END(Metadata, 16);
 
@@ -53,49 +47,44 @@ struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_SENDER = 10,
     VT_RECIPIENT = 12,
     VT_METADATA = 14,
-    VT_CIPHERTEXT = 16
+    VT_CIPHERTEXT = 16,
+    VT_PRIORITY = 20,
+    VT_MESSAGE_TYPE = 22,
+    VT_COLLAPSE_KEY = 24,
+    VT_NOTIFICATION_PAYLOAD = 26
   };
   const flatbuffers::String *id() const {
     return GetPointer<const flatbuffers::String *>(VT_ID);
   }
-  flatbuffers::String *mutable_id() {
-    return GetPointer<flatbuffers::String *>(VT_ID);
-  }
   SelfMessaging::MsgType msgtype() const {
     return static_cast<SelfMessaging::MsgType>(GetField<int8_t>(VT_MSGTYPE, 0));
   }
-  bool mutate_msgtype(SelfMessaging::MsgType _msgtype) {
-    return SetField<int8_t>(VT_MSGTYPE, static_cast<int8_t>(_msgtype), 0);
-  }
   SelfMessaging::MsgSubType subtype() const {
     return static_cast<SelfMessaging::MsgSubType>(GetField<uint16_t>(VT_SUBTYPE, 0));
   }
-  bool mutate_subtype(SelfMessaging::MsgSubType _subtype) {
-    return SetField<uint16_t>(VT_SUBTYPE, static_cast<uint16_t>(_subtype), 0);
-  }
   const flatbuffers::String *sender() const {
     return GetPointer<const flatbuffers::String *>(VT_SENDER);
   }
-  flatbuffers::String *mutable_sender() {
-    return GetPointer<flatbuffers::String *>(VT_SENDER);
-  }
   const flatbuffers::String *recipient() const {
     return GetPointer<const flatbuffers::String *>(VT_RECIPIENT);
   }
-  flatbuffers::String *mutable_recipient() {
-    return GetPointer<flatbuffers::String *>(VT_RECIPIENT);
-  }
   const SelfMessaging::Metadata *metadata() const {
     return GetStruct<const SelfMessaging::Metadata *>(VT_METADATA);
   }
-  SelfMessaging::Metadata *mutable_metadata() {
-    return GetStruct<SelfMessaging::Metadata *>(VT_METADATA);
-  }
   const flatbuffers::Vector<uint8_t> *ciphertext() const {
     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CIPHERTEXT);
   }
-  flatbuffers::Vector<uint8_t> *mutable_ciphertext() {
-    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_CIPHERTEXT);
+  uint32_t priority() const {
+    return GetField<uint32_t>(VT_PRIORITY, 0);
+  }
+  const flatbuffers::Vector<uint8_t> *message_type() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE_TYPE);
+  }
+  const flatbuffers::Vector<uint8_t> *collapse_key() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_COLLAPSE_KEY);
+  }
+  const flatbuffers::Vector<uint8_t> *notification_payload() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_NOTIFICATION_PAYLOAD);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
@@ -110,6 +99,13 @@ struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyFieldRequired<SelfMessaging::Metadata>(verifier, VT_METADATA) &&
            VerifyOffset(verifier, VT_CIPHERTEXT) &&
            verifier.VerifyVector(ciphertext()) &&
+           VerifyField<uint32_t>(verifier, VT_PRIORITY) &&
+           VerifyOffset(verifier, VT_MESSAGE_TYPE) &&
+           verifier.VerifyVector(message_type()) &&
+           VerifyOffset(verifier, VT_COLLAPSE_KEY) &&
+           verifier.VerifyVector(collapse_key()) &&
+           VerifyOffset(verifier, VT_NOTIFICATION_PAYLOAD) &&
+           verifier.VerifyVector(notification_payload()) &&
            verifier.EndTable();
   }
 };
@@ -139,6 +135,18 @@ struct MessageBuilder {
   void add_ciphertext(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> ciphertext) {
     fbb_.AddOffset(Message::VT_CIPHERTEXT, ciphertext);
   }
+  void add_priority(uint32_t priority) {
+    fbb_.AddElement<uint32_t>(Message::VT_PRIORITY, priority, 0);
+  }
+  void add_message_type(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message_type) {
+    fbb_.AddOffset(Message::VT_MESSAGE_TYPE, message_type);
+  }
+  void add_collapse_key(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> collapse_key) {
+    fbb_.AddOffset(Message::VT_COLLAPSE_KEY, collapse_key);
+  }
+  void add_notification_payload(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> notification_payload) {
+    fbb_.AddOffset(Message::VT_NOTIFICATION_PAYLOAD, notification_payload);
+  }
   explicit MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -159,8 +167,16 @@ inline flatbuffers::Offset<Message> CreateMessage(
     flatbuffers::Offset<flatbuffers::String> sender = 0,
     flatbuffers::Offset<flatbuffers::String> recipient = 0,
     const SelfMessaging::Metadata *metadata = 0,
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> ciphertext = 0) {
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> ciphertext = 0,
+    uint32_t priority = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message_type = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> collapse_key = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> notification_payload = 0) {
   MessageBuilder builder_(_fbb);
+  builder_.add_notification_payload(notification_payload);
+  builder_.add_collapse_key(collapse_key);
+  builder_.add_message_type(message_type);
+  builder_.add_priority(priority);
   builder_.add_ciphertext(ciphertext);
   builder_.add_metadata(metadata);
   builder_.add_recipient(recipient);
@@ -179,11 +195,18 @@ inline flatbuffers::Offset<Message> CreateMessageDirect(
     const char *sender = nullptr,
     const char *recipient = nullptr,
     const SelfMessaging::Metadata *metadata = 0,
-    const std::vector<uint8_t> *ciphertext = nullptr) {
+    const std::vector<uint8_t> *ciphertext = nullptr,
+    uint32_t priority = 0,
+    const std::vector<uint8_t> *message_type = nullptr,
+    const std::vector<uint8_t> *collapse_key = nullptr,
+    const std::vector<uint8_t> *notification_payload = nullptr) {
   auto id__ = id ? _fbb.CreateString(id) : 0;
   auto sender__ = sender ? _fbb.CreateString(sender) : 0;
   auto recipient__ = recipient ? _fbb.CreateString(recipient) : 0;
   auto ciphertext__ = ciphertext ? _fbb.CreateVector<uint8_t>(*ciphertext) : 0;
+  auto message_type__ = message_type ? _fbb.CreateVector<uint8_t>(*message_type) : 0;
+  auto collapse_key__ = collapse_key ? _fbb.CreateVector<uint8_t>(*collapse_key) : 0;
+  auto notification_payload__ = notification_payload ? _fbb.CreateVector<uint8_t>(*notification_payload) : 0;
   return SelfMessaging::CreateMessage(
       _fbb,
       id__,
@@ -192,7 +215,11 @@ inline flatbuffers::Offset<Message> CreateMessageDirect(
       sender__,
       recipient__,
       metadata,
-      ciphertext__);
+      ciphertext__,
+      priority,
+      message_type__,
+      collapse_key__,
+      notification_payload__);
 }
 
 inline const SelfMessaging::Message *GetMessage(const void *buf) {
@@ -203,10 +230,6 @@ inline const SelfMessaging::Message *GetSizePrefixedMessage(const void *buf) {
   return flatbuffers::GetSizePrefixedRoot<SelfMessaging::Message>(buf);
 }
 
-inline Message *GetMutableMessage(void *buf) {
-  return flatbuffers::GetMutableRoot<Message>(buf);
-}
-
 inline bool VerifyMessageBuffer(
     flatbuffers::Verifier &verifier) {
   return verifier.VerifyBuffer<SelfMessaging::Message>(nullptr);

data/lib/self_msgproto/message.rb

@@ -3,7 +3,7 @@
 module SelfMsg
 
   class Message
-    attr_accessor :id, :type, :subtype, :sender, :recipient, :ciphertext
+    attr_accessor :id, :type, :sender, :recipient, :ciphertext, :message_type, :priority
     attr_reader :timestamp, :offset
   end
 

data/lib/self_msgproto/version.rb

@@ -2,6 +2,6 @@
 
 module SelfMsg
 
-  VERSION="0.0.8"
+  VERSION="0.0.9"
 
 end

data/test/unit/test_message.rb

@@ -7,16 +7,18 @@ class TestMessage < Minitest::Test
   include SelfMsg
 
   def test_new_message
-    d = Base64.decode64('GAAAAAAAEgAkACAAAAAAABwAGAAIAAQAEgAAACAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAABwAAAAkAAAABAAAAHRlc3QHAAAAYWxpY2U6MQAGAAAAdGVzdDoxAAAkAAAAOWEwZjZjNjktMmI2ZS00YjA2LTg3MWUtMGM1YmFhOTJiYzk2AAAAAA')
+    d = Base64.decode64('HAAAABgALAAoAAAAAAAkACAADAAcAAAACAAEABgAAAAoAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAGAAAACAAAAAoAAAAAAAAAAQAAAB0ZXN0BwAAAGFsaWNlOjEABgAAAHRlc3Q6MQAAJAAAADlhMGY2YzY5LTJiNmUtNGIwNi04NzFlLTBjNWJhYTkyYmM5NgAAAAA')
     m = SelfMsg::Message.new(data: d)
+
     p m.id
     p m.type
-    p m.subtype
     p m.offset
     p m.timestamp
     p m.sender
     p m.recipient
     p m.ciphertext
+    p m.message_type
+    p m.priority
 
     p m.to_fb
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: self_msgproto
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Tom Bevan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-16 00:00:00.000000000 Z
+date: 2022-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -133,14 +133,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.5
+rubygems_version: 3.3.5
 signing_key: 
 specification_version: 4
 summary: Bindings for Self's Flatbuffer messaging protocol
 test_files:
-- test/unit/test_header.rb
-- test/unit/test_auth.rb
+- test/spec/test_message.rb
 - test/unit/test_acl.rb
-- test/unit/test_notification.rb
+- test/unit/test_auth.rb
+- test/unit/test_header.rb
 - test/unit/test_message.rb
-- test/spec/test_message.rb
+- test/unit/test_notification.rb