feat(rad): drop deprecated json library and use serde_json instead

Author: aesedepece

Cargo.lock

@@ -15,14 +15,14 @@ if_rust_version = "1.0.0"
 # the http crate is used to perform additional validations before passing arguments to the surf http client
 # the version of http must be kept in sync with the version used by surf
 http = "0.2.1"
-json = "0.12.1"
 log = "0.4.8"
 minidom = { git = "https://github.com/witnet/xmpp-rs", rev = "bc8a33ff5da95ee4039ad7ee3376c100d9e35c74" }
 num_enum = "0.4.2"
 ordered-float = "3.0"
 rand = "0.7.3"
 serde = "1.0.111"
-serde_cbor = "0.11.1"
+serde_cbor = "0.11.2"
+serde_json = "1.0.96"
 # the url crate is used to perform additional validations before passing arguments to the surf http client
 # the version of url must be kept in sync with the version used by surf in the `witnet_net` crate
 url = "2.1.1"

rad/Cargo.toml

@@ -5,6 +5,7 @@ use std::{
 };
 
 use serde_cbor::value::{from_value, Value};
+use serde_json::Value as JsonValue;
 
 use crate::{
     error::RadError,
@@ -21,9 +22,10 @@ const DEFAULT_DECIMAL_SEPARATOR: &str = ".";
 
 /// Parse `RadonTypes` from a JSON-encoded `RadonString`.
 pub fn parse_json(input: &RadonString) -> Result<RadonTypes, RadError> {
-    let json_value = json::parse(&input.value()).map_err(|err| RadError::JsonParse {
-        description: err.to_string(),
-    })?;
+    let json_value: JsonValue =
+        serde_json::from_str(&input.value()).map_err(|err| RadError::JsonParse {
+            description: err.to_string(),
+        })?;
 
     RadonTypes::try_from(json_value)
 }
@@ -532,7 +534,7 @@ mod tests {
         let output = parse_json_map(&invalid_json).unwrap_err();
 
         let expected_err = RadError::JsonParse {
-            description: "Unexpected character: } at (1:13)".to_string(),
+            description: "expected value at line 1 column 13".to_string(),
         };
         assert_eq!(output, expected_err);
 
@@ -580,7 +582,7 @@ mod tests {
         let output = parse_json_array(&invalid_json).unwrap_err();
 
         let expected_err = RadError::JsonParse {
-            description: "Unexpected character: } at (1:13)".to_string(),
+            description: "expected value at line 1 column 13".to_string(),
         };
         assert_eq!(output, expected_err);
 
@@ -1133,44 +1135,44 @@ mod tests {
 
     #[test]
     fn test_json_numbers_to_radon_numbers() {
-        use json::{number::Number, JsonValue};
+        use serde_json::{value::Number, Value as JsonValue};
 
-        let json = JsonValue::Number(Number::from(2.0));
+        let json = JsonValue::Number(Number::from_f64(2.0).unwrap());
         let resulting_radon = RadonTypes::try_from(json).unwrap();
         let expected_radon = RadonInteger::from(2).into();
         assert_eq!(resulting_radon, expected_radon);
 
-        let json = JsonValue::Number(Number::from(20.0));
+        let json = JsonValue::Number(Number::from_f64(20.0).unwrap());
         let resulting_radon = RadonTypes::try_from(json).unwrap();
         let expected_radon = RadonInteger::from(20).into();
         assert_eq!(resulting_radon, expected_radon);
 
-        let json = JsonValue::Number(Number::from(2_000.0));
+        let json = JsonValue::Number(Number::from_f64(2_000.0).unwrap());
         let resulting_radon = RadonTypes::try_from(json).unwrap();
         let expected_radon = RadonInteger::from(2_000).into();
         assert_eq!(resulting_radon, expected_radon);
 
-        let json = JsonValue::Number(Number::from(2_000_000.0));
+        let json = JsonValue::Number(Number::from_f64(2_000_000.0).unwrap());
         let resulting_radon = RadonTypes::try_from(json).unwrap();
         let expected_radon = RadonInteger::from(2_000_000).into();
         assert_eq!(resulting_radon, expected_radon);
 
-        let json = JsonValue::Number(Number::from(std::f64::consts::PI));
+        let json = JsonValue::Number(Number::from_f64(std::f64::consts::PI).unwrap());
         let resulting_radon = RadonTypes::try_from(json).unwrap();
         let expected_radon = RadonFloat::from(std::f64::consts::PI).into();
         assert_eq!(resulting_radon, expected_radon);
 
-        let json = JsonValue::Number(Number::from(1e100));
+        let json = JsonValue::Number(Number::from_f64(1e100).unwrap());
         let resulting_radon = RadonTypes::try_from(json).unwrap();
         let expected_radon = RadonFloat::from(1e100).into();
         assert_eq!(resulting_radon, expected_radon);
 
-        let json = JsonValue::Number(Number::from(4.0));
+        let json = JsonValue::Number(Number::from_f64(4.0).unwrap());
         let resulting_radon = RadonTypes::try_from(json).unwrap();
         let expected_radon = RadonInteger::from(4).into();
         assert_eq!(resulting_radon, expected_radon);
 
-        let json = JsonValue::Number(Number::from(4.1));
+        let json = JsonValue::Number(Number::from_f64(4.1).unwrap());
         let resulting_radon = RadonTypes::try_from(json).unwrap();
         let expected_radon = RadonFloat::from(4.1).into();
         assert_eq!(resulting_radon, expected_radon);
@@ -1183,16 +1185,12 @@ mod tests {
         // does not cause any overflows
 
         // Parse the number using json::parse because otherwise it is just converted to 0.0
-        let json = json::parse("0.1E-99999").unwrap();
-        // The exponent is too small to fit in a i16, so the json library saturates the value to
-        // i16::MIN:
-        let (sign, mantissa, exponent) = json.as_number().unwrap().as_parts();
-        assert_eq!((sign, mantissa, exponent), (true, 1, i16::MIN));
+        let number: serde_json::Number = serde_json::from_str("0.1E-99999").unwrap();
         // This number is rounded to exactly 0.0 when converted to f64
-        assert_eq!(json.as_f64().unwrap(), 0.0);
+        assert_eq!(number.as_f64().unwrap(), 0.0);
 
         // Convert to RadonTypes
-        let resulting_radon = RadonTypes::try_from(json).unwrap();
+        let resulting_radon = RadonTypes::try_from(JsonValue::Number(number)).unwrap();
 
         // This exponent is too small to fit in a f64, so expected_f64 is equal to 0.0
         let expected_f64 = 0.1E-99999;

rad/src/operators/string.rs

@@ -4,11 +4,10 @@ use std::{
     fmt, panic,
 };
 
-use json::JsonValue;
-
 use cbor::value::Value as CborValue;
 use serde::{Serialize, Serializer};
 use serde_cbor::{to_vec, Value};
+use serde_json::Value as JsonValue;
 use witnet_crypto::hash::calculate_sha256;
 use witnet_data_structures::{
     chain::{tapi::ActiveWips, Hash},
@@ -471,22 +470,31 @@ impl TryFrom<JsonValue> for RadonTypes {
                 from: "JsonValue::Null",
                 to: "RadonTypes",
             }),
-            JsonValue::Short(short) => Ok(RadonString::from(short.as_str()).into()),
-            JsonValue::String(string) => Ok(RadonString::from(string).into()),
+            JsonValue::Bool(boolean) => Ok(RadonBoolean::from(boolean).into()),
             JsonValue::Number(number) => {
-                let (positive, mantissa, exponent) = number.as_parts();
-                let floating = f64::from(number);
-                // Cast the float into an integer if it has no fractional part and its value will fit
-                // into the range of `i128` (38 is the biggest power of 10 that `i128` can safely hold)
-                if floating.fract() == 0.0 && exponent >= 0 && exponent.unsigned_abs() < 38 {
-                    let abs = i128::from(mantissa) * 10i128.pow(exponent.unsigned_abs().into());
-                    Ok(RadonInteger::from(if positive { abs } else { -abs }).into())
+                if number.is_i64() {
+                    Ok(RadonInteger::from(i128::from(number.as_i64().expect("i64"))).into())
+                } else if number.is_u64() {
+                    Ok(RadonInteger::from(i128::from(number.as_u64().expect("u64"))).into())
                 } else {
-                    // All other numbers will be treated as a float
-                    Ok(RadonFloat::from(floating).into())
+                    // Floats that can be safely represented as i128 are converted
+                    let floating = number.as_f64().expect("f64");
+                    if floating.is_normal() && floating.fract() == 0.0 && floating.log10() < 38.0 {
+                        Ok(RadonInteger::from(floating as i128).into())
+                    } else {
+                        Ok(RadonFloat::from(floating).into())
+                    }
                 }
             }
-            JsonValue::Boolean(boolean) => Ok(RadonBoolean::from(boolean).into()),
+            JsonValue::String(string) => Ok(RadonString::from(string).into()),
+            JsonValue::Array(array) => Ok(RadonArray::from(
+                array
+                    .into_iter()
+                    // Skip null values
+                    .filter_map(|value| RadonTypes::try_from(value).ok())
+                    .collect::<Vec<_>>(),
+            )
+            .into()),
             JsonValue::Object(object) => Ok(RadonMap::from(
                 object
                     .iter()
@@ -499,14 +507,6 @@ impl TryFrom<JsonValue> for RadonTypes {
                     .collect::<BTreeMap<_, _>>(),
             )
             .into()),
-            JsonValue::Array(array) => Ok(RadonArray::from(
-                array
-                    .into_iter()
-                    // Skip null values
-                    .filter_map(|value| RadonTypes::try_from(value).ok())
-                    .collect::<Vec<_>>(),
-            )
-            .into()),
         }
     }
 }
@@ -694,14 +694,6 @@ mod tests {
         assert_eq!(rad_decode_error_as_result, vec![malformed_reveal]);
     }
 
-    #[test]
-    fn test_json_short_to_radon_types() {
-        let text = "Short";
-        let json_value = JsonValue::Short(unsafe { json::short::Short::from_slice(text) });
-        let radon_types = RadonTypes::try_from(json_value).unwrap();
-        assert_eq!(radon_types, RadonString::from(text).into());
-    }
-
     #[test]
     fn test_json_string_to_radon_types() {
         let text = "This is a proper string because it contains more than 30 characters";
@@ -712,83 +704,68 @@ mod tests {
 
     #[test]
     fn test_json_number_to_radon_types() {
-        let json_value = JsonValue::Number(json::number::Number::from(u8::MAX));
+        let json_value = JsonValue::Number(serde_json::Number::from(u8::MAX));
         let radon_types = RadonTypes::try_from(json_value).unwrap();
         assert_eq!(radon_types, RadonInteger::from(i128::from(u8::MAX)).into());
 
-        let json_value = JsonValue::Number(json::number::Number::from(u16::MAX));
+        let json_value = JsonValue::Number(serde_json::Number::from(u16::MAX));
         let radon_types = RadonTypes::try_from(json_value).unwrap();
         assert_eq!(radon_types, RadonInteger::from(i128::from(u16::MAX)).into());
 
-        let json_value = JsonValue::Number(json::number::Number::from(u32::MAX));
+        let json_value = JsonValue::Number(serde_json::Number::from(u32::MAX));
         let radon_types = RadonTypes::try_from(json_value).unwrap();
         assert_eq!(radon_types, RadonInteger::from(i128::from(u32::MAX)).into());
 
         // Not using u64::MAX because of precision loss
-        let json_value = JsonValue::Number(json::number::Number::from(u64::MAX / 100));
+        let json_value = JsonValue::Number(serde_json::Number::from(u64::MAX / 100));
         let radon_types = RadonTypes::try_from(json_value).unwrap();
         assert_eq!(
             radon_types,
             RadonInteger::from(i128::from(u64::MAX / 100)).into()
         );
 
-        // `Number::from` won't take negative numbers, so these are using a workaround
-        let json_value = JsonValue::Number(-json::number::Number::from(i8::MAX));
+        let json_value = JsonValue::Number(serde_json::Number::from(i8::MIN));
         let radon_types = RadonTypes::try_from(json_value).unwrap();
-        assert_eq!(
-            radon_types,
-            RadonInteger::from(i128::from(i8::MIN + 1)).into()
-        );
+        assert_eq!(radon_types, RadonInteger::from(i128::from(i8::MIN)).into());
 
-        let json_value = JsonValue::Number(-json::number::Number::from(i16::MAX));
+        let json_value = JsonValue::Number(serde_json::Number::from(i16::MIN));
         let radon_types = RadonTypes::try_from(json_value).unwrap();
-        assert_eq!(
-            radon_types,
-            RadonInteger::from(i128::from(i16::MIN + 1)).into()
-        );
+        assert_eq!(radon_types, RadonInteger::from(i128::from(i16::MIN)).into());
 
-        let json_value = JsonValue::Number(-json::number::Number::from(i32::MAX));
+        let json_value = JsonValue::Number(serde_json::Number::from(i32::MIN));
         let radon_types = RadonTypes::try_from(json_value).unwrap();
-        assert_eq!(
-            radon_types,
-            RadonInteger::from(i128::from(i32::MIN + 1)).into()
-        );
+        assert_eq!(radon_types, RadonInteger::from(i128::from(i32::MIN)).into());
 
-        let json_value = JsonValue::Number(-json::number::Number::from(i64::MAX));
+        let json_value = JsonValue::Number(serde_json::Number::from(i64::MIN));
         let radon_types = RadonTypes::try_from(json_value).unwrap();
-        assert_eq!(
-            radon_types,
-            RadonInteger::from(i128::from(i64::MIN + 1)).into()
-        );
+        assert_eq!(radon_types, RadonInteger::from(i128::from(i64::MIN)).into());
 
-        let json_value = JsonValue::Number(json::number::Number::from(std::f64::consts::PI));
+        let json_value =
+            JsonValue::Number(serde_json::Number::from_f64(std::f64::consts::PI).unwrap());
         let radon_types = RadonTypes::try_from(json_value).unwrap();
         assert_eq!(radon_types, RadonFloat::from(std::f64::consts::PI).into());
 
-        let json_value = JsonValue::Number(-json::number::Number::from(std::f64::consts::PI));
+        let json_value =
+            JsonValue::Number(serde_json::Number::from_f64(-std::f64::consts::PI).unwrap());
         let radon_types = RadonTypes::try_from(json_value).unwrap();
         assert_eq!(radon_types, RadonFloat::from(-std::f64::consts::PI).into());
-
-        let json_value = JsonValue::Number(json::number::Number::from(f64::NAN));
-        let radon_types = RadonTypes::try_from(json_value).unwrap();
-        assert_eq!(radon_types, RadonFloat::from(f64::NAN).into());
     }
 
     #[test]
     fn test_json_boolean_to_radon_types() {
-        let json_value = JsonValue::Boolean(true);
+        let json_value = JsonValue::Bool(true);
         let radon_types = RadonTypes::try_from(json_value).unwrap();
         assert_eq!(radon_types, RadonBoolean::from(true).into());
 
-        let json_value = JsonValue::Boolean(false);
+        let json_value = JsonValue::Bool(false);
         let radon_types = RadonTypes::try_from(json_value).unwrap();
         assert_eq!(radon_types, RadonBoolean::from(false).into());
     }
 
     #[test]
     fn test_json_object_to_radon_types() {
-        let data = Vec::from([("foo", "bar"), ("fee", "beer")]);
-        let json_value = JsonValue::Object(json::object::Object::from_iter(data.iter().cloned()));
+        let data = Vec::from([("foo".into(), "bar".into()), ("fee".into(), "beer".into())]);
+        let json_value = JsonValue::Object(serde_json::Map::from_iter(data.iter().cloned()));
         let radon_types = RadonTypes::try_from(json_value).unwrap();
         assert_eq!(
             radon_types,
@@ -803,7 +780,7 @@ mod tests {
     #[test]
     fn test_json_array_to_radon_types() {
         let json_value = JsonValue::Array(Vec::from([
-            JsonValue::Boolean(true),
+            JsonValue::Bool(true),
             JsonValue::String("awesomeness".into()),
         ]));
         let radon_types = RadonTypes::try_from(json_value).unwrap();