Deprecates Int::as_i32 and created new functions as_i32_or_nothing, as_i32_or_fail, and Int::to_str plus added tests and some new comments

Author: vsubhuman

rust/src/metadata.rs

@@ -930,7 +930,7 @@ mod tests {
         assert_eq!(map.get_str("sender_id").unwrap().as_text().unwrap(), "jkfdsufjdk34h3Sdfjdhfduf873");
         assert_eq!(map.get_str("comment").unwrap().as_text().unwrap(), "happy birthday");
         let tags = map.get_str("tags").unwrap().as_list().unwrap();
-        let tags_i32 = tags.0.iter().map(|md| md.as_int().unwrap().as_i32().unwrap()).collect::<Vec<i32>>();
+        let tags_i32 = tags.0.iter().map(|md| md.as_int().unwrap().as_i32_or_fail().unwrap()).collect::<Vec<i32>>();
         assert_eq!(tags_i32, vec![0, 264, -1024, 32]);
         let output_str = decode_metadatum_to_json_str(&metadata, MetadataJsonSchema::NoConversions).expect("decode failed");
         let input_json: serde_json::Value = serde_json::from_str(&input_str).unwrap();
@@ -991,11 +991,11 @@ mod tests {
     fn json_encoding_check_example_metadatum(metadata: &TransactionMetadatum) {
         let map = metadata.as_map().unwrap();
         assert_eq!(map.get(&TransactionMetadatum::new_bytes(hex::decode("8badf00d").unwrap()).unwrap()).unwrap().as_bytes().unwrap(), hex::decode("deadbeef").unwrap());
-        assert_eq!(map.get_i32(9).unwrap().as_int().unwrap().as_i32().unwrap(), 5);
+        assert_eq!(map.get_i32(9).unwrap().as_int().unwrap().as_i32_or_fail().unwrap(), 5);
         let inner_map = map.get_str("obj").unwrap().as_map().unwrap();
         let a = inner_map.get_str("a").unwrap().as_list().unwrap();
         let a1 = a.get(0).as_map().unwrap();
-        assert_eq!(a1.get_i32(5).unwrap().as_int().unwrap().as_i32().unwrap(), 2);
+        assert_eq!(a1.get_i32(5).unwrap().as_int().unwrap().as_i32_or_fail().unwrap(), 2);
         let a2 = a.get(1).as_map().unwrap();
         assert_eq!(a2.keys().len(), 0);
     }
@@ -1025,11 +1025,11 @@ mod tests {
 
         let map = metadata.as_map().unwrap();
         let key = map.keys().get(0);
-        assert_eq!(map.get(&key).unwrap().as_int().unwrap().as_i32().unwrap(), 5);
+        assert_eq!(map.get(&key).unwrap().as_int().unwrap().as_i32_or_fail().unwrap(), 5);
         let key_list = key.as_list().unwrap();
         assert_eq!(key_list.len(), 2);
         let key_map = key_list.get(0).as_map().unwrap();
-        assert_eq!(key_map.get_i32(5).unwrap().as_int().unwrap().as_i32().unwrap(), -7);
+        assert_eq!(key_map.get_i32(5).unwrap().as_int().unwrap().as_i32_or_fail().unwrap(), -7);
         assert_eq!(key_map.get_str("hello").unwrap().as_text().unwrap(), "world");
         let key_bytes = key_list.get(1).as_bytes().unwrap();
         assert_eq!(key_bytes, hex::decode("ff00ff00").unwrap());

rust/src/utils.rs

@@ -487,6 +487,12 @@ impl Int {
         return self.0 >= 0
     }
 
+    /// BigNum can only contain unsigned u64 values
+    ///
+    /// This function will return the BigNum representation
+    /// only in case the underlying i128 value is positive.
+    ///
+    /// Otherwise nothing will be returned (undefined).
     pub fn as_positive(&self) -> Option<BigNum> {
         if self.is_positive() {
             Some(to_bignum(self.0 as u64))
@@ -495,6 +501,12 @@ impl Int {
         }
     }
 
+    /// BigNum can only contain unsigned u64 values
+    ///
+    /// This function will return the *absolute* BigNum representation
+    /// only in case the underlying i128 value is negative.
+    ///
+    /// Otherwise nothing will be returned (undefined).
     pub fn as_negative(&self) -> Option<BigNum> {
         if !self.is_positive() {
             Some(to_bignum((-self.0) as u64))
@@ -503,10 +515,37 @@ impl Int {
         }
     }
 
+    /// !!! DEPRECATED !!!
+    /// Returns an i32 value in case the underlying original i128 value is within the limits.
+    /// Otherwise will just return an empty value (undefined).
+    #[deprecated(
+        since = "10.0.0",
+        note = "Unsafe ignoring of possible boundary error and it's not clear from the function name. Use `as_i32_or_nothing`, `as_i32_or_fail`, or `to_str`"
+    )]
     pub fn as_i32(&self) -> Option<i32> {
+        self.as_i32_or_nothing()
+    }
+
+    /// Returns the underlying value converted to i32 if possible (within limits)
+    /// Otherwise will just return an empty value (undefined).
+    pub fn as_i32_or_nothing(&self) -> Option<i32> {
         use std::convert::TryFrom;
         i32::try_from(self.0).ok()
     }
+
+    /// Returns the underlying value converted to i32 if possible (within limits)
+    /// JsError in case of out of boundary overflow
+    pub fn as_i32_or_fail(&self) -> Result<i32, JsError> {
+        use std::convert::TryFrom;
+        i32::try_from(self.0)
+            .map_err(|e| JsError::from_str(&format!("{}", e)))
+    }
+
+    /// Returns string representation of the underlying i128 value directly.
+    /// Might contain the minus sign (-) in case of negative value.
+    pub fn to_str(&self) -> String {
+        format!("{}", self.0)
+    }
 }
 
 impl cbor_event::se::Serialize for Int {
@@ -2192,4 +2231,60 @@ mod tests {
             Bip32PublicKey::from_bytes(&hex::decode(self_key_hex).unwrap()).unwrap().to_raw_key().hash()
         );
     }
+
+    #[test]
+    fn int_to_str() {
+        assert_eq!(Int::new(&BigNum(u64::max_value())).to_str(), u64::max_value().to_string());
+        assert_eq!(Int::new(&BigNum(u64::min_value())).to_str(), u64::min_value().to_string());
+        assert_eq!(Int::new_negative(&BigNum(u64::max_value())).to_str(), (-(u64::max_value() as i128)).to_string());
+        assert_eq!(Int::new_negative(&BigNum(u64::min_value())).to_str(), (-(u64::min_value() as i128)).to_string());
+        assert_eq!(Int::new_i32(142).to_str(), "142");
+        assert_eq!(Int::new_i32(-142).to_str(), "-142");
+    }
+
+    #[test]
+    fn int_as_i32_or_nothing() {
+
+        let over_pos_i32 = (i32::max_value() as i64) + 1;
+        assert!(Int::new(&BigNum(over_pos_i32 as u64)).as_i32_or_nothing().is_none());
+
+        let valid_pos_i32 = (i32::max_value() as i64);
+        assert_eq!(Int::new(&BigNum(valid_pos_i32 as u64)).as_i32_or_nothing().unwrap(), i32::max_value());
+
+        let over_neg_i32 = (i32::min_value() as i64) - 1;
+        assert!(Int::new_negative(&BigNum((-over_neg_i32) as u64)).as_i32_or_nothing().is_none());
+
+        let valid_neg_i32 = (i32::min_value() as i64);
+        assert_eq!(Int::new_negative(&BigNum((-valid_neg_i32) as u64)).as_i32_or_nothing().unwrap(), i32::min_value());
+
+        assert!(Int::new(&BigNum(u64::max_value())).as_i32_or_nothing().is_none());
+        assert_eq!(Int::new(&BigNum(i32::max_value() as u64)).as_i32_or_nothing().unwrap(), i32::max_value());
+        assert_eq!(Int::new_negative(&BigNum(i32::max_value() as u64)).as_i32_or_nothing().unwrap(), -i32::max_value());
+
+        assert_eq!(Int::new_i32(42).as_i32_or_nothing().unwrap(), 42);
+        assert_eq!(Int::new_i32(-42).as_i32_or_nothing().unwrap(), -42);
+    }
+
+    #[test]
+    fn int_as_i32_or_fail() {
+
+        let over_pos_i32 = (i32::max_value() as i64) + 1;
+        assert!(Int::new(&BigNum(over_pos_i32 as u64)).as_i32_or_fail().is_err());
+
+        let valid_pos_i32 = (i32::max_value() as i64);
+        assert_eq!(Int::new(&BigNum(valid_pos_i32 as u64)).as_i32_or_fail().unwrap(), i32::max_value());
+
+        let over_neg_i32 = (i32::min_value() as i64) - 1;
+        assert!(Int::new_negative(&BigNum((-over_neg_i32) as u64)).as_i32_or_fail().is_err());
+
+        let valid_neg_i32 = (i32::min_value() as i64);
+        assert_eq!(Int::new_negative(&BigNum((-valid_neg_i32) as u64)).as_i32_or_fail().unwrap(), i32::min_value());
+
+        assert!(Int::new(&BigNum(u64::max_value())).as_i32_or_fail().is_err());
+        assert_eq!(Int::new(&BigNum(i32::max_value() as u64)).as_i32_or_fail().unwrap(), i32::max_value());
+        assert_eq!(Int::new_negative(&BigNum(i32::max_value() as u64)).as_i32_or_fail().unwrap(), -i32::max_value());
+
+        assert_eq!(Int::new_i32(42).as_i32_or_fail().unwrap(), 42);
+        assert_eq!(Int::new_i32(-42).as_i32_or_fail().unwrap(), -42);
+    }
 }