enquo-core 0.7.0.2.ga69badc-x86_64-linux → 0.7.0.5.gb281772-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4819bbffcca9224b004d37bbaade05f9818d43ecd4aab9e6784cc29f8883e49c
-  data.tar.gz: aab6ee7d723f79abab9ae4f0ae60f75edcbd1f85a8b0688c8e48ca5bad2f4d84
+  metadata.gz: 14ba0b5311572306dba037583849820e7ab4d4edd646132bc74e42ee9172b2d4
+  data.tar.gz: 2339129bb9c3b3ea25f38b8c4941f369141cb1083172a0f5a6f2677df40464b5
 SHA512:
-  metadata.gz: 4033201413b2e0be51537b8c74aa4a0454dc8320ef42e0c31031b58c20295b37e3e114c7d0cada5886524efb143cb4cad30cf1ae41134bd1d385427af6c57a29
-  data.tar.gz: 4669ddc119802bb9281c5df02e07b356224d633c3c4b0fecc4d8533fc6b6fff13cc223eab308306397d2dd0227afe17b89c0d07484f374f0f754dde818df198f
+  metadata.gz: 07a4fcbecc6206a05e84e7c67d0b902f6067cb268fb20378d52541484e10d2f23aca786689a850e7c9c8a3323513387d3e6b42ddd5050800c0176d51bcb3056c
+  data.tar.gz: 86b8cd729576c63e94a1d0b5ca51e592f016c378d5b3cdbf8e40f5737b01e72f3bdacc6fd841640ab654af1add4fbd909008971a657a240bf97e0e4209c11943

data/ext/enquo/Cargo.lock

@@ -56,26 +56,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "ansi_term"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi",
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -90,25 +70,21 @@ checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
 
 [[package]]
 name = "bindgen"
-version = "0.59.2"
+version = "0.60.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bd2a9a458e8f4304c52c43ebb0cfbd520289f8379a52e329a38afda99bf8eb8"
+checksum = "062dddbc1ba4aca46de6338e2bf87771414c335f7b2f2036e8f3e9befebf88e6"
 dependencies = [
  "bitflags",
  "cexpr",
  "clang-sys",
- "clap",
- "env_logger",
  "lazy_static",
  "lazycell",
- "log",
  "peeking_take_while",
  "proc-macro2",
  "quote",
  "regex",
  "rustc-hash",
  "shlex",
- "which",
 ]
 
 [[package]]
@@ -214,21 +190,6 @@ dependencies = [
  "libloading",
 ]
 
-[[package]]
-name = "clap"
-version = "2.34.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
-dependencies = [
- "ansi_term",
- "atty",
- "bitflags",
- "strsim 0.8.0",
- "textwrap",
- "unicode-width",
- "vec_map",
-]
-
 [[package]]
 name = "cmac"
 version = "0.7.1"
@@ -366,7 +327,7 @@ dependencies = [
  "ident_case",
  "proc-macro2",
  "quote",
- "strsim 0.10.0",
+ "strsim",
  "syn",
 ]
 
@@ -401,20 +362,14 @@ dependencies = [
  "subtle",
 ]
 
-[[package]]
-name = "either"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
-
 [[package]]
 name = "enquo"
 version = "0.0.0"
 dependencies = [
  "enquo-core",
+ "hex",
  "lazy_static",
- "rb-sys",
- "rutie",
+ "magnus",
  "serde_json",
 ]
 
@@ -435,19 +390,6 @@ dependencies = [
  "unicode-normalization",
 ]
 
-[[package]]
-name = "env_logger"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
-dependencies = [
- "atty",
- "humantime",
- "log",
- "regex",
- "termcolor",
-]
-
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -493,15 +435,6 @@ version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
-[[package]]
-name = "hermit-abi"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "hex"
 version = "0.4.3"
@@ -517,12 +450,6 @@ dependencies = [
  "digest",
 ]
 
-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
 [[package]]
 name = "iana-time-zone"
 version = "0.1.54"
@@ -634,6 +561,28 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "magnus"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8dc14463c2552e753ef562961f486ca76f17a857c121db40e9f3ade3f35ab81"
+dependencies = [
+ "magnus-macros",
+ "rb-sys",
+ "rb-sys-env",
+]
+
+[[package]]
+name = "magnus-macros"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cc17af1d45442c011aa579d727ec6cff8a69aea8a6bbad26736e7112d749bfb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "memchr"
 version = "2.5.0"
@@ -750,12 +699,6 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
 
-[[package]]
-name = "pkg-config"
-version = "0.3.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1df8c4ec4b0627e53bdf214615ad287367e482558cf84b109250b37464dc03ae"
-
 [[package]]
 name = "polyval"
 version = "0.6.0"
@@ -776,18 +719,18 @@ checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.43"
+version = "1.0.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab"
+checksum = "2b63bdb0cd06f1f4dedf69b254734f9b45af66e4a031e42a7480257d9898b435"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.21"
+version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
+checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc"
 dependencies = [
  "proc-macro2",
 ]
@@ -824,15 +767,34 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.8.1"
+version = "0.9.72"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e36bdb8be5f395264fb4345a5f6c13dac307ed3be3bccf6305b57835981c605"
+dependencies = [
+ "rb-sys-build",
+]
+
+[[package]]
+name = "rb-sys-build"
+version = "0.9.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4db52af35291b64ce86f23f755b4576c20e3063b517269252b2f8cc883ca00e6"
+checksum = "b56f8993adac385ed6208f0dc62f99181eb0676dea50bac7bc3d36a86bb9429b"
 dependencies = [
  "bindgen",
- "libc",
- "pkg-config",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "shell-words",
+ "syn",
 ]
 
+[[package]]
+name = "rb-sys-env"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a35802679f07360454b418a5d1735c89716bde01d35b1560fc953c1415a0b3bb"
+
 [[package]]
 name = "regex"
 version = "1.6.0"
@@ -856,16 +818,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
-[[package]]
-name = "rutie"
-version = "0.8.4"
-source = "git+https://github.com/mpalmer/rutie?branch=fixes#b798b15ddfc3ed011de72702bd0124c91fd67c78"
-dependencies = [
- "lazy_static",
- "libc",
- "rb-sys",
-]
-
 [[package]]
 name = "ryu"
 version = "1.0.11"
@@ -958,16 +910,16 @@ dependencies = [
 ]
 
 [[package]]
-name = "shlex"
+name = "shell-words"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
+checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
 
 [[package]]
-name = "strsim"
-version = "0.8.0"
+name = "shlex"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
 
 [[package]]
 name = "strsim"
@@ -1013,15 +965,6 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "textwrap"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
-dependencies = [
- "unicode-width",
-]
-
 [[package]]
 name = "thiserror"
 version = "1.0.34"
@@ -1127,12 +1070,6 @@ dependencies = [
  "subtle",
 ]
 
-[[package]]
-name = "vec_map"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
-
 [[package]]
 name = "version_check"
 version = "0.9.4"
@@ -1199,17 +1136,6 @@ version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
 
-[[package]]
-name = "which"
-version = "4.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c831fbbee9e129a8cf93e7747a82da9d95ba8e16621cae60ec2cdc849bacb7b"
-dependencies = [
- "either",
- "libc",
- "once_cell",
-]
-
 [[package]]
 name = "winapi"
 version = "0.3.9"

data/ext/enquo/Cargo.toml

@@ -7,8 +7,8 @@ edition = "2021"
 enquo-core = { path = "../../../rust" }
 lazy_static = "1.0"
 serde_json = "1.0"
-rb-sys = "0.8"
-rutie = { git = "https://github.com/mpalmer/rutie", branch = "fixes" }
+magnus = "0.5"
+hex = "0.4"
 
 [lib]
 crate-type = ["cdylib"]

data/ext/enquo/src/field.rs

@@ -0,0 +1,342 @@
+use enquo_core::{Boolean, Date, Error, Text, I64};
+use magnus::{
+    class, eval, exception, function, method,
+    prelude::*,
+    scan_args::{get_kwargs, scan_args},
+    RClass, RModule, RString, TryConvert,
+};
+use std::ops::Deref;
+
+use crate::maybe_raise;
+
+#[magnus::wrap(class = "Enquo::Field")]
+pub struct Field(pub enquo_core::Field);
+
+impl Deref for Field {
+    type Target = enquo_core::Field;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+struct EncryptOpts<T>
+where
+    T: TryConvert,
+{
+    input: T,
+    context: Vec<u8>,
+    unsafe_ok: bool,
+    no_query: bool,
+    order_prefix_length: Option<u8>,
+}
+
+fn strict_bool(value: Option<magnus::Value>, e: &str) -> Result<Option<bool>, magnus::Error> {
+    match value {
+        None => Ok(None),
+        Some(v) => {
+            if v.is_kind_of(class::true_class()) {
+                Ok(Some(true))
+            } else if v.is_kind_of(class::false_class()) {
+                Ok(Some(false))
+            } else {
+                Err(magnus::Error::new(
+                    exception::type_error(),
+                    format!("{e} (got an instance of {})", v.class().inspect()),
+                ))
+            }
+        }
+    }
+}
+
+fn strict_int<T: TryConvert>(
+    value: Option<magnus::Value>,
+    e: &str,
+) -> Result<Option<T>, magnus::Error> {
+    match value {
+        None => Ok(None),
+        Some(v) => {
+            if v.is_kind_of(class::integer()) {
+                Ok(Some(v.try_convert::<T>()?))
+            } else {
+                Err(magnus::Error::new(
+                    exception::type_error(),
+                    format!("{e} (got an instance of {})", v.class().inspect()),
+                ))
+            }
+        }
+    }
+}
+
+fn parse_encrypt_args<T>(args: &[magnus::Value]) -> Result<EncryptOpts<T>, magnus::Error>
+where
+    T: TryConvert,
+{
+    let args = scan_args::<_, (), (), (), _, ()>(args)?;
+    let (input, context_str): (T, RString) = args.required;
+
+    let kwargs = get_kwargs::<_, (), _, ()>(
+        args.keywords,
+        &[],
+        &["unsafe", "no_query", "order_prefix_length"],
+    )?;
+
+    let (unsafe_ok_val, no_query_val, order_prefix_length_val): (
+        Option<magnus::Value>,
+        Option<magnus::Value>,
+        Option<magnus::Value>,
+    ) = kwargs.optional;
+
+    let unsafe_ok = strict_bool(unsafe_ok_val, "unsafe can only accept booleans")?.unwrap_or(false);
+    let no_query = strict_bool(no_query_val, "no_query can only accept booleans")?.unwrap_or(false);
+    let order_prefix_length = strict_int(
+        order_prefix_length_val,
+        "order_prefix_length must be an Integer",
+    )?;
+
+    Ok(EncryptOpts::<T> {
+        input,
+        // Safe because we immediately copy away the value
+        context: unsafe { context_str.as_slice().to_vec() },
+        unsafe_ok,
+        no_query,
+        order_prefix_length,
+    })
+}
+
+impl Field {
+    fn key_id(&self) -> Result<String, magnus::Error> {
+        maybe_raise(self.0.key_id().map(hex::encode), None)
+    }
+
+    fn encrypt_boolean(&self, args: &[magnus::Value]) -> Result<String, magnus::Error> {
+        let opts = parse_encrypt_args::<magnus::Value>(args)?;
+
+        let b = strict_bool(
+            Some(opts.input),
+            "Enquo::Field#encrypt_boolean can only encrypt booleans",
+        )?
+        .expect("CAN'T HAPPEN: got None from strict_bool(Some(opts.input)) !!!");
+
+        let mut res = maybe_raise(
+            if opts.unsafe_ok {
+                Boolean::new_with_unsafe_parts(b, &opts.context, self)
+            } else {
+                Boolean::new(b, &opts.context, self)
+            },
+            None,
+        )?;
+
+        if opts.no_query {
+            maybe_raise(res.make_unqueryable(), None)?;
+        }
+
+        maybe_raise(
+            serde_json::to_string(&res),
+            Some("failed to encode ciphertext"),
+        )
+    }
+
+    fn decrypt_boolean(&self, ciphertext: String, context: String) -> Result<bool, magnus::Error> {
+        let ct: Boolean = maybe_raise(
+            serde_json::from_str(&ciphertext),
+            Some("failed to decode ciphertext"),
+        )?;
+
+        maybe_raise(ct.decrypt(context.as_bytes(), self), None)
+    }
+
+    fn encrypt_i64(&self, args: &[magnus::Value]) -> Result<String, magnus::Error> {
+        let opts = parse_encrypt_args::<magnus::Value>(args)?;
+
+        // Yes, I am aware that Magnus will turn anything that responds to
+        // `#to_int` into an i64, but that includes instances of Float, and...
+        // well, nope.
+        let i: i64 = if opts.input.is_kind_of(class::integer()) {
+            opts.input.try_convert()
+        } else {
+            Err(magnus::Error::new(
+                exception::type_error(),
+                format!(
+                    "Enquo::Field#encrypt_i64 can only encrypt Integers (got an instance of {})",
+                    opts.input.class().inspect()
+                ),
+            ))
+        }?;
+
+        let mut res = maybe_raise(
+            if opts.unsafe_ok {
+                I64::new_with_unsafe_parts(i, &opts.context, self)
+            } else {
+                I64::new(i, &opts.context, self)
+            },
+            None,
+        )?;
+
+        if opts.no_query {
+            maybe_raise(res.make_unqueryable(), None)?;
+        }
+
+        maybe_raise(
+            serde_json::to_string(&res),
+            Some("failed to encode ciphertext"),
+        )
+    }
+
+    fn decrypt_i64(&self, ciphertext: String, context: String) -> Result<i64, magnus::Error> {
+        let ct: I64 = maybe_raise(
+            serde_json::from_str(&ciphertext),
+            Some("failed to decode ciphertext"),
+        )?;
+
+        maybe_raise(ct.decrypt(context.as_bytes(), self), None)
+    }
+
+    fn encrypt_date(&self, args: &[magnus::Value]) -> Result<String, magnus::Error> {
+        let opts = parse_encrypt_args::<magnus::Value>(args)?;
+
+        // Safe as we're not storing the result of classname
+        if opts.input.class().inspect() != "Date" {
+            return Err(magnus::Error::new(
+                exception::type_error(),
+                format!(
+                    "Enquo::Field#encrypt_date can only encrypt Date objects (got instance of {})",
+                    opts.input.class().inspect()
+                ),
+            ));
+        }
+
+        let y: i16 = opts.input.funcall("year", ())?;
+        let m: u8 = opts.input.funcall("month", ())?;
+        let d: u8 = opts.input.funcall("day", ())?;
+
+        let mut res = maybe_raise(
+            if opts.unsafe_ok {
+                Date::new_with_unsafe_parts((y, m, d), &opts.context, self)
+            } else {
+                Date::new((y, m, d), &opts.context, self)
+            },
+            None,
+        )?;
+
+        if opts.no_query {
+            maybe_raise(res.make_unqueryable(), None)?;
+        }
+
+        maybe_raise(
+            serde_json::to_string(&res),
+            Some("failed to encode ciphertext"),
+        )
+    }
+
+    fn decrypt_date(
+        &self,
+        ciphertext: String,
+        context: String,
+    ) -> Result<magnus::Value, magnus::Error> {
+        let ct: Date = maybe_raise(
+            serde_json::from_str(&ciphertext),
+            Some("failed to decode ciphertext"),
+        )?;
+
+        let (y, m, d) = maybe_raise(ct.decrypt(context.as_bytes(), self), None)?;
+
+        let date_class = maybe_raise(
+            RClass::from_value(eval("::Date")?).ok_or_else(|| {
+                Error::OperationError("failed to get RClass from Date value".to_string())
+            }),
+            None,
+        )?;
+
+        date_class.new_instance((y, m, d))
+    }
+
+    fn encrypt_text(&self, args: &[magnus::Value]) -> Result<String, magnus::Error> {
+        let opts = parse_encrypt_args::<magnus::Value>(args)?;
+
+        // Yes, I am aware that Magnus will turn anything that responds to
+        // `#to_s` into a String if we ask it to, but we want to be far more strict,
+        // and only allow actual Ruby String objects to be passed in.
+        let t: String = if opts.input.is_kind_of(class::string()) {
+            opts.input.try_convert::<RString>()?.to_string()
+        } else {
+            Err(magnus::Error::new(
+                exception::type_error(),
+                format!(
+                    "Enquo::Field#encrypt_text can only encrypt Strings (got an instance of {})",
+                    opts.input.class().inspect()
+                ),
+            ))
+        }?;
+
+        let mut res = maybe_raise(
+            if opts.unsafe_ok {
+                Text::new_with_unsafe_parts(&t, &opts.context, self, opts.order_prefix_length)
+            } else if opts.order_prefix_length.is_some() {
+                return Err(magnus::Error::new(exception::arg_error(), "Cannot specify an order_prefix_length unless reduced_security_operations is set"));
+            } else {
+                Text::new(&t, &opts.context, self)
+            },
+            None,
+        )?;
+
+        if opts.no_query {
+            maybe_raise(res.make_unqueryable(), None)?;
+        }
+
+        maybe_raise(
+            serde_json::to_string(&res),
+            Some("failed to encode ciphertext"),
+        )
+    }
+
+    fn decrypt_text(&self, ciphertext: String, context: String) -> Result<String, magnus::Error> {
+        let ct: Text = maybe_raise(
+            serde_json::from_str(&ciphertext),
+            Some("failed to decode ciphertext"),
+        )?;
+
+        maybe_raise(ct.decrypt(context.as_bytes(), self), None)
+    }
+
+    fn encrypt_text_length_query(&self, len: u32) -> Result<String, magnus::Error> {
+        let value_set = maybe_raise(Text::query_length(len, self), None)?;
+        maybe_raise(
+            serde_json::to_string(&value_set),
+            Some("failed to encode value set"),
+        )
+    }
+}
+
+pub fn init(base: &RModule) -> Result<(), magnus::Error> {
+    let class = base.define_class("Field", class::object())?;
+
+    class.define_singleton_method(
+        "new",
+        function!(
+            || -> Result<(), _> {
+                Err(magnus::Error::new(
+                    exception::no_method_error(),
+                    "Enquo::Field.new should not be called directly; use Enquo::Root#field instead"
+                        .to_string(),
+                ))
+            },
+            0
+        ),
+    )?;
+    class.define_method("key_id", method!(Field::key_id, 0))?;
+    class.define_method("encrypt_boolean", method!(Field::encrypt_boolean, -1))?;
+    class.define_method("decrypt_boolean", method!(Field::decrypt_boolean, 2))?;
+    class.define_method("encrypt_date", method!(Field::encrypt_date, -1))?;
+    class.define_method("decrypt_date", method!(Field::decrypt_date, 2))?;
+    class.define_method("encrypt_i64", method!(Field::encrypt_i64, -1))?;
+    class.define_method("decrypt_i64", method!(Field::decrypt_i64, 2))?;
+    class.define_method("encrypt_text", method!(Field::encrypt_text, -1))?;
+    class.define_method("decrypt_text", method!(Field::decrypt_text, 2))?;
+    class.define_method(
+        "encrypt_text_length_query",
+        method!(Field::encrypt_text_length_query, 1),
+    )?;
+
+    Ok(())
+}