feat: support api for deserializer to check trailing chars (#177)

* feat: support api for deserializer to check trailing chars

* chore: update version

* chore: cargo clippy

Author: Ggiggle

Cargo.toml

@@ -10,7 +10,7 @@ license       = "Apache-2.0"
 name          = "sonic-rs"
 readme        = "README.md"
 repository    = "https://github.com/cloudwego/sonic-rs"
-version       = "0.5.0"
+version       = "0.5.1"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

examples/get_many.rs

@@ -26,7 +26,7 @@ fn main() {
             }
         }
         Err(e) => {
-            println!("err: {:?}", e)
+            println!("err: {e:?}")
         }
     }
 }

examples/handle_error.rs

@@ -11,41 +11,41 @@ fn main() {
     // deal with Eof errors
     let err = from_str::<Foo>("{\"a\": [").unwrap_err();
     assert!(err.is_eof());
-    eprintln!("{}", err);
+    eprintln!("{err}");
     // EOF while parsing at line 1 column 6
 
     //     {"a": [
     //     ......^
     assert_eq!(
-        format!("{}", err),
+        format!("{err}"),
         "EOF while parsing at line 1 column 6\n\n\t{\"a\": [\n\t......^\n"
     );
 
     // deal with unmatched type errors
     let err = from_str::<Foo>("{ \"b\":[]}").unwrap_err();
-    eprintln!("{}", err);
+    eprintln!("{err}");
     assert!(err.is_unmatched_type());
     // println as follows:
     // missing field `a` at line 1 column 8
     //
     //     { "b":[]}
     //     ........^
     assert_eq!(
-        format!("{}", err),
+        format!("{err}"),
         "missing field `a` at line 1 column 8\n\n\t{ \"b\":[]}\n\t........^\n"
     );
 
     // deal with Syntax errors
     let err = from_slice::<Foo>(b"{\"b\":\"\x80\"}").unwrap_err();
-    eprintln!("{}", err);
+    eprintln!("{err}");
     assert!(err.is_syntax());
     // println as follows:
     // Invalid UTF-8 characters in json at line 1 column 6
     //
     //     {"b":"�"}
     //     ......^...
     assert_eq!(
-        format!("{}", err),
+        format!("{err}"),
         "Invalid UTF-8 characters in json at line 1 column 6\n\n\t{\"b\":\"�\"}\n\t......^..\n"
     );
 }

src/error.rs

@@ -332,7 +332,7 @@ impl Error {
             0
         };
         let mask = ".".repeat(left) + "^" + &".".repeat(right);
-        let descript = format!("\n\n\t{}\n\t{}\n", fragment, mask);
+        let descript = format!("\n\n\t{fragment}\n\t{mask}\n");
 
         Error {
             err: Box::new(ErrorImpl {
@@ -426,9 +426,9 @@ impl de::Error for Error {
     #[cold]
     fn invalid_type(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self {
         if let de::Unexpected::Unit = unexp {
-            Error::custom(format_args!("invalid type: null, expected {}", exp))
+            Error::custom(format_args!("invalid type: null, expected {exp}"))
         } else {
-            Error::custom(format_args!("invalid type: {}, expected {}", unexp, exp))
+            Error::custom(format_args!("invalid type: {unexp}, expected {exp}"))
         }
     }
 }
@@ -520,73 +520,73 @@ mod test {
 
         let err = from_str::<Foo>("{ \"b\":[]}").unwrap_err();
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "missing field `a` at line 1 column 8\n\n\t{ \"b\":[]}\n\t........^\n"
         );
 
         let err = from_str::<Foo>("{\"a\": [1, 2x, 3, 4, 5]}").unwrap_err();
-        println!("{}", err);
+        println!("{err}");
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "Expected this character to be either a ',' or a ']' while parsing at line 1 column \
              11\n\n\t\": [1, 2x, 3, 4,\n\t........^.......\n"
         );
 
         let err = from_str::<Foo>("{\"a\": null}").unwrap_err();
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "invalid type: null, expected a sequence at line 1 column 9\n\n\t\"a\": \
              null}\n\t........^.\n"
         );
 
         let err = from_str::<Foo>("{\"a\": [1,2,3  }").unwrap_err();
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "Expected this character to be either a ',' or a ']' while parsing at line 1 column \
              14\n\n\t[1,2,3  }\n\t........^\n"
         );
 
         let err = from_str::<Foo>("{\"a\": [\"123\"]}").unwrap_err();
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "invalid type: string \"123\", expected i32 at line 1 column 11\n\n\t\": \
              [\"123\"]}\n\t........^..\n"
         );
 
         let err = from_str::<Foo>("{\"a\": [").unwrap_err();
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "EOF while parsing at line 1 column 6\n\n\t{\"a\": [\n\t......^\n"
         );
 
         let err = from_str::<Foo>("{\"a\": [000]}").unwrap_err();
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "Expected this character to be either a ',' or a ']' while parsing at line 1 column \
              8\n\n\t{\"a\": [000]}\n\t........^...\n"
         );
 
         let err = from_str::<Foo>("{\"a\": [-]}").unwrap_err();
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "Invalid number at line 1 column 7\n\n\t{\"a\": [-]}\n\t.......^..\n"
         );
 
         let err = from_str::<Foo>("{\"a\": [-1.23e]}").unwrap_err();
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "Invalid number at line 1 column 12\n\n\t: [-1.23e]}\n\t........^..\n"
         );
 
         let err = from_str::<Foo>("{\"c\": \"哈哈哈哈哈哈}").unwrap_err();
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "EOF while parsing at line 1 column 25\n\n\t哈哈哈}\n\t.........^\n"
         );
 
         let err = from_slice::<Foo>(b"{\"b\":\"\x80\"}").unwrap_err();
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "Invalid UTF-8 characters in json at line 1 column 6\n\n\t{\"b\":\"�\"}\n\t......^..\n"
         );
     }
@@ -595,7 +595,7 @@ mod test {
     fn test_other_errors() {
         let err = crate::Value::try_from(f64::NAN).unwrap_err();
         assert_eq!(
-            format!("{}", err),
+            format!("{err}"),
             "NaN or Infinity is not a valid JSON value"
         );
     }

src/index.rs

@@ -142,7 +142,7 @@ impl Index for usize {
         let typ = v.get_type();
         let len = v.len();
         v.as_array_mut()
-            .unwrap_or_else(|| panic!("cannot access index in non-array value type {:?}", typ))
+            .unwrap_or_else(|| panic!("cannot access index in non-array value type {typ:?}"))
             .0
             .get_index_mut(*self)
             .unwrap_or_else(|| panic!("index {} out of bounds (len: {})", *self, len))

src/lazyvalue/get.rs

@@ -569,7 +569,7 @@ mod test {
     fn test_get_from_json_failed() {
         fn test_get_failed(json: &[u8], path: &JsonPointer) {
             let out = get_from_slice(json, path);
-            assert!(out.is_err(), "json is {:?}", json);
+            assert!(out.is_err(), "json is {json:?}");
 
             // test for SIMD codes
             let json = unsafe { from_utf8_unchecked(json) }.to_string() + &" ".repeat(1000);

src/lazyvalue/iterator.rs

@@ -88,9 +88,11 @@ impl<'de> ObjectJsonIter<'de> {
     }
 
     pub(crate) fn new<I: JsonInput<'de>>(input: I, skip_strict: bool) -> Self {
-        let validate_utf8 = skip_strict
-            .then_some(input.need_utf8_valid())
-            .unwrap_or_default();
+        let validate_utf8 = if skip_strict {
+            input.need_utf8_valid()
+        } else {
+            Default::default()
+        };
 
         Self {
             parser: Parser::new(Read::new_in(input.to_json_slice(), validate_utf8)),
@@ -147,9 +149,11 @@ impl<'de> ArrayJsonIter<'de> {
     }
 
     pub(crate) fn new<I: JsonInput<'de>>(input: I, skip_strict: bool) -> Self {
-        let validate_utf8 = skip_strict
-            .then_some(input.need_utf8_valid())
-            .unwrap_or_default();
+        let validate_utf8 = if skip_strict {
+            input.need_utf8_valid()
+        } else {
+            Default::default()
+        };
 
         Self {
             parser: Parser::new(Read::new_in(input.to_json_slice(), validate_utf8)),
@@ -394,8 +398,7 @@ mod test {
             assert_eq!(
                 ret.1.as_raw_str().as_bytes(),
                 val.as_bytes(),
-                "key is {} ",
-                key
+                "key is {key} ",
             );
             assert_eq!(ret.1.get_type(), typ);
 
@@ -404,8 +407,7 @@ mod test {
             assert_eq!(
                 ret.1.as_raw_str().as_bytes(),
                 val.as_bytes(),
-                "key is {} ",
-                key
+                "key is {key} ",
             );
             assert_eq!(ret.1.get_type(), typ);
         };
@@ -521,7 +523,7 @@ mod test {
         let json = Bytes::from(r#"[1, true, "hello", null, 5, 6]"#);
         let iter = to_array_iter(&json);
         let out: Vec<JsonType> = iter.map(|e| e.get_type()).collect();
-        println!("array elem type is {:?}", out);
+        println!("array elem type is {out:?}");
     }
 
     #[test]

src/lazyvalue/ser.rs

@@ -61,7 +61,7 @@ mod test {
             };
             assert_eq!(to_string(&data).unwrap(), to_string(&data2).unwrap());
             let json = json.trim();
-            let expect: String = format!("{{\"borrowed_lv\":{},\"owned_lv\":{}}}", json, json);
+            let expect: String = format!("{{\"borrowed_lv\":{json},\"owned_lv\":{json}}}");
             let serialized = to_string(&data).expect(json);
             assert_eq!(expect, serialized);
             assert_eq!(serialized, to_string(&data).unwrap());
@@ -85,7 +85,7 @@ mod test {
     fn test_raw_value_failed() {
         fn test_json_failed(json: &str) {
             let ret: Result<LazyValue<'_>> = from_str(json);
-            assert!(ret.is_err(), "invalid json is {}", json);
+            assert!(ret.is_err(), "invalid json is {json}");
         }
         test_json_failed(r#"""#);
         test_json_failed(r#""raw " value""#);

src/parser.rs

@@ -60,8 +60,8 @@ impl<'b, 'c> From<Reference<'b, 'c, str>> for Cow<'b, str> {
 impl<'b, 'c, T: Debug + ?Sized + 'static> Debug for Reference<'b, 'c, T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Borrowed(c) => write!(f, "Borrowed({:?})", c),
-            Self::Copied(c) => write!(f, "Copied({:?})", c),
+            Self::Borrowed(c) => write!(f, "Borrowed({c:?})"),
+            Self::Copied(c) => write!(f, "Copied({c:?})"),
         }
     }
 }

src/pointer/point.rs

@@ -58,9 +58,9 @@ mod test {
     #[test]
     fn test_json_pointer() {
         let pointers = pointer![];
-        println!("{:?}", pointers);
+        println!("{pointers:?}");
         let mut pointers = pointer![1, 2, 3, "foo", "bar"].to_vec();
         pointers.push(123.into());
-        println!("{:?}", pointers);
+        println!("{pointers:?}");
     }
 }