enquo-core 0.3.0.1.g08acb85-aarch64-linux → 0.5.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70433c7409454ce78ecce0e272edfd482f5d8e96767dd32b54aa1d68f4974e01
-  data.tar.gz: c13a49c68a5ba440f2888a5159d7f2a5941e73b2d06be3f5837d1a0374c4a778
+  metadata.gz: 0b30675da9cddc9e757446df84024bb0be24512d484732460fdae3316a3808ee
+  data.tar.gz: 400b52836e010030474a09d3bca8b1ffac54f38f6ea3be906b94792286bb1354
 SHA512:
-  metadata.gz: b3f6c08827e00614e59804698c5f5f9363173e43dfcc041e3badccf25d88fc3d1ab04daa76365aa1d85ce3de5c8a8cc83eb46027ca101067b0436416ce908e99
-  data.tar.gz: e5e2c1004bb8385b135e4fc6d6874d4c83f81d3c1351a0592c96c969718f1ba1d2d70901c36c2abb912a156ec32799d70a26cbad96234ceeee9129e065f83feb
+  metadata.gz: d87e366269feed4f22733c9cba25e26034a99a9d8bd25b8287b851b219921165c5dede5ecaa8b5b737632e629fd52a386a2a6f90edc7a78022bb4907d48f2970
+  data.tar.gz: c8eb5ca4f435e7c448085bfdcc63688ddb87429681f183beaaf3761cdb476dd76544c2e9622d7395663fc5ccdbf44a63a793284ddb49aaf5af0c2d02fe2095ee

data/ext/enquo/src/lib.rs

@@ -1,17 +1,19 @@
 #[macro_use]
 extern crate rutie;
 
-use enquo_core::{Date, Field, Root, I64};
+use enquo_core::{key_provider, Date, Field, Root, I64};
 use rutie::{AnyObject, Class, Integer, Module, Object, RString, Symbol, VerifiedObject, VM};
 
 class!(EnquoRoot);
 class!(EnquoRootKeyStatic);
 class!(EnquoField);
 
-type StaticRootKey = Vec<u8>;
-
 wrappable_struct!(Root<'static>, RootWrapper, ROOT_WRAPPER);
-wrappable_struct!(StaticRootKey, StaticRootKeyWrapper, STATIC_ROOT_KEY_WRAPPER);
+wrappable_struct!(
+    key_provider::Static,
+    StaticRootKeyWrapper,
+    STATIC_ROOT_KEY_WRAPPER
+);
 wrappable_struct!(Field, FieldWrapper, FIELD_WRAPPER);
 
 fn maybe_raise<T, E: std::error::Error>(r: Result<T, E>, s: &str) -> T {
@@ -24,27 +26,24 @@ fn maybe_raise<T, E: std::error::Error>(r: Result<T, E>, s: &str) -> T {
     .unwrap()
 }
 
-methods!(
+unsafe_methods!(
     EnquoRoot,
     rbself,
     fn enquo_root_new_from_static_root_key(root_key_obj: EnquoRootKeyStatic) -> EnquoRoot {
-        let root_key = root_key_obj.unwrap();
-        // Not so needless after all, Clippy...
-        #[allow(clippy::needless_borrow)]
-        let rk = root_key.get_data(&*STATIC_ROOT_KEY_WRAPPER);
+        let rk = root_key_obj.get_data(&*STATIC_ROOT_KEY_WRAPPER);
         let root = maybe_raise(Root::new(rk), "Failed to create Enquo::Root");
 
         let klass = Module::from_existing("Enquo").get_nested_class("Root");
         klass.wrap_data(root, &*ROOT_WRAPPER)
     },
-    fn enquo_root_field(relation: RString, name: RString) -> EnquoField {
+    fn enquo_root_field(relation_obj: RString, name_obj: RString) -> EnquoField {
+        let relation = relation_obj.to_vec_u8_unchecked();
+        let name = name_obj.to_vec_u8_unchecked();
+
         let root = rbself.get_data(&*ROOT_WRAPPER);
 
         let field = maybe_raise(
-            root.field(
-                &relation.unwrap().to_vec_u8_unchecked(),
-                &name.unwrap().to_vec_u8_unchecked(),
-            ),
+            root.field(&relation, &name),
             "Failed to create Enquo::Field",
         );
 
@@ -53,12 +52,13 @@ methods!(
     }
 );
 
-methods!(
+unsafe_methods!(
     EnquoRootKeyStatic,
     _rbself,
-    fn enquo_root_key_static_new(root_key: RString) -> EnquoRootKeyStatic {
-        #[allow(clippy::redundant_clone)]
-        let k = root_key.unwrap().to_vec_u8_unchecked().to_owned();
+    fn enquo_root_key_static_new(root_key_obj: RString) -> EnquoRootKeyStatic {
+        let root_key = root_key_obj.to_vec_u8_unchecked();
+
+        let k = key_provider::Static::new(&root_key);
         let klass = Module::from_existing("Enquo")
             .get_nested_class("RootKey")
             .get_nested_class("Static");
@@ -81,85 +81,90 @@ impl VerifiedObject for EnquoRootKeyStatic {
 
 // rustfmt fucks this so it doesn't compile
 #[rustfmt::skip]
-methods!(
+unsafe_methods!(
     EnquoField,
     rbself,
-    fn enquo_field_encrypt_i64(value: Integer, context: RString, mode: Symbol) -> RString {
-        let i = value.unwrap().to_i64();
+    fn enquo_field_encrypt_i64(i_obj: Integer, context_obj: RString, mode_obj: Symbol) -> RString {
+        let i = i_obj.to_i64();
+        let context = context_obj.to_vec_u8_unchecked();
+        let mode = mode_obj.to_str();
+
         let field = rbself.get_data(&*FIELD_WRAPPER);
-        let r_mode = mode.unwrap();
-        let s_mode = r_mode.to_str();
 
         let mut res = maybe_raise(
-            if s_mode == "unsafe" {
-                I64::new_with_unsafe_parts(i, &context.unwrap().to_vec_u8_unchecked(), field)
+            if mode == "unsafe" {
+                I64::new_with_unsafe_parts(i, &context, field)
             } else {
-                I64::new(i, &context.unwrap().to_vec_u8_unchecked(), field)
+                I64::new(i, &context, field)
             },
             "Failed to create encrypted i64",
         );
-        if s_mode == "no_query" {
+        if mode == "no_query" {
             res.drop_ore_ciphertext();
         }
 
-        RString::new_utf8(&serde_json::to_string(&res).unwrap())
+        RString::new_utf8(&maybe_raise(serde_json::to_string(&res), "Failed to JSONify ciphertext"))
     },
-    fn enquo_field_decrypt_i64(ciphertext: RString, context: RString) -> Integer {
-        let ct_r = ciphertext.unwrap();
-        let ct = ct_r.to_str_unchecked();
+    fn enquo_field_decrypt_i64(ciphertext_obj: RString, context_obj: RString) -> Integer {
+        let ct = ciphertext_obj.to_str_unchecked();
+        let context = context_obj.to_vec_u8_unchecked();
+
+        let field = rbself.get_data(&*FIELD_WRAPPER);
+
         let e_value: I64 =
             maybe_raise(serde_json::from_str(ct), "Failed to deserialize ciphertext");
 
-        let field = rbself.get_data(&*FIELD_WRAPPER);
 
         let value = maybe_raise(
-            e_value.decrypt(&context.unwrap().to_vec_u8_unchecked(), field),
+            e_value.decrypt(&context, field),
             "Failed to decrypt i64 value",
         );
         Integer::from(value)
     },
     fn enquo_field_encrypt_date(
-        y_r: Integer,
-        m_r: Integer,
-        d_r: Integer,
-        context: RString,
-        mode: Symbol
+        y_obj: Integer,
+        m_obj: Integer,
+        d_obj: Integer,
+        context_obj: RString,
+        mode_obj: Symbol
     ) -> RString {
-        let y = y_r.unwrap().to_i32() as i16;
-        let m = m_r.unwrap().to_i32() as u8;
-        let d = d_r.unwrap().to_i32() as u8;
+        let y = y_obj.to_i32() as i16;
+        let m = m_obj.to_i32() as u8;
+        let d = d_obj.to_i32() as u8;
+        let context = context_obj.to_vec_u8_unchecked();
+        let mode = mode_obj.to_str();
+
         let field = rbself.get_data(&*FIELD_WRAPPER);
-        let r_mode = mode.unwrap();
-        let s_mode = r_mode.to_str();
 
         let mut res = maybe_raise(
-            if s_mode == "unsafe" {
+            if mode == "unsafe" {
                 Date::new_with_unsafe_parts(
                     (y, m, d),
-                    &context.unwrap().to_vec_u8_unchecked(),
+                    &context,
                     field,
                 )
             } else {
-                Date::new((y, m, d), &context.unwrap().to_vec_u8_unchecked(), field)
+                Date::new((y, m, d), &context, field)
             },
             "Failed to create encrypted date",
         );
-        if s_mode == "no_query" {
+        if mode == "no_query" {
             res.drop_ore_ciphertexts();
         }
 
-        RString::new_utf8(&serde_json::to_string(&res).unwrap())
+        RString::new_utf8(&maybe_raise(serde_json::to_string(&res), "Failed to JSONify ciphertext"))
     },
-    fn enquo_field_decrypt_date(ciphertext: RString, context: RString) -> AnyObject {
-        let ct_r = ciphertext.unwrap();
-        let ct = ct_r.to_str_unchecked();
-        let e_value: Date =
-            maybe_raise(serde_json::from_str(ct), "Failed to deserialize ciphertext");
+    fn enquo_field_decrypt_date(ciphertext_obj: RString, context_obj: RString) -> AnyObject {
+        let ct = ciphertext_obj.to_str_unchecked();
+        let context = context_obj.to_vec_u8_unchecked();
 
         let field = rbself.get_data(&*FIELD_WRAPPER);
 
+        let e_value: Date =
+            maybe_raise(serde_json::from_str(ct), "Failed to deserialize ciphertext");
+
         let (y, m, d) = maybe_raise(
-            e_value.decrypt(&context.unwrap().to_vec_u8_unchecked(), field),
+            e_value.decrypt(&context, field),
             "Failed to decrypt date value",
         );
         let klass = Class::from_existing("Date");

data/lib/enquo/root.rb

@@ -6,6 +6,10 @@ module Enquo
 				_new_from_static_root_key(key)
 			else
 				raise ArgumentError, "key must be a root key provider object (got a #{key.class})"
+			end.tap do |k|
+				# DIRTY HACK ALERT: take a reference to the key so it doesn't get GC'd
+				# If someone can come up with a better way to acheive this, I'm all ears
+				k.instance_variable_set(:@_key, key)
 			end
 		end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enquo-core
 version: !ruby/object:Gem::Version
-  version: 0.3.0.1.g08acb85
+  version: 0.5.0
 platform: aarch64-linux
 authors:
 - Matt Palmer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-04 00:00:00.000000000 Z
+date: 2022-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -193,9 +193,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.2.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.3.22
 signing_key: