feat: implement bencodex JSON format

https://github.com/planetarium/bencodex/blob/bdac452c2a43aad227f381dc72202c6dfc11ac53/JSON.md

Cargo.toml

@@ -19,6 +19,7 @@ name = "bencodex"
 itertools = "0.10.0"
 num-traits = "0.2.14"
 num-bigint = "0.3"
+hex = "0.4.3"
 
 [dev-dependencies]
 yaml-rust = "0.4.4"

bencodex/src/main.rs

@@ -16,5 +16,5 @@ fn main() {
         }
     };
 
-    println!("{:?}", decoded);
+    println!("{}", decoded);
 }

src/codec/types.rs

@@ -1,5 +1,5 @@
 use num_bigint::BigInt;
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, fmt::{Debug, Display}};
 
 /// The type alias of `BTreepMap<BencodexKey, BencodexValue>` to reduce code size.
 ///
@@ -40,7 +40,7 @@ pub type BencodexList = Vec<BencodexValue>;
 /// ```
 pub const BENCODEX_NULL: BencodexValue = BencodexValue::Null;
 
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Clone)]
 pub enum BencodexValue {
     Binary(Vec<u8>),
     Text(String),
@@ -51,12 +51,75 @@ pub enum BencodexValue {
     Null,
 }
 
-#[derive(PartialEq, Eq, PartialOrd, Debug, Clone, Ord)]
+#[derive(PartialEq, Eq, PartialOrd, Clone, Ord)]
 pub enum BencodexKey {
     Binary(Vec<u8>),
     Text(String),
 }
 
+impl Debug for BencodexValue {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Binary(arg0) => write!(f, "{:?}", BencodexKey::from(arg0)),
+            Self::Text(arg0) => write!(f, "{:?}", BencodexKey::from(arg0)),
+            Self::Boolean(arg0) => f.write_str(if *arg0 { "true" } else { "false" }),
+            Self::Number(arg0) => f.write_str(&arg0.to_string()),
+            Self::List(arg0) => f.debug_list().entries(arg0.iter()).finish(),
+            Self::Dictionary(arg0) => f.debug_map().entries(arg0.iter()).finish(),
+            Self::Null => write!(f, "null"),
+        }
+    }
+}
+
+impl Display for BencodexValue {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Binary(arg0) => f.write_fmt(format_args!("{}", BencodexKey::from(arg0))),
+            Self::Text(arg0) => f.write_fmt(format_args!("{}", BencodexKey::from(arg0))),
+            Self::Boolean(arg0) => f.write_str(if *arg0 { "true" } else { "false" }),
+            Self::Number(arg0) => f.write_str(&arg0.to_string()),
+            Self::List(arg0) => {
+                f.write_str("[")?;
+                for (i, item) in arg0.iter().enumerate() {
+                    if i == arg0.len() - 1 {
+                        write!(f, "{}", item)?;
+                    } else {
+                        write!(f, "{},", item)?;
+                    }
+                }
+                f.write_str("]")
+            },
+            Self::Dictionary(arg0) => {
+                f.write_str("{")?;
+                let mut iter = arg0.iter().peekable();
+                while let Some((key, value)) = iter.next() {
+                    write!(f, "{}:{}", key, value)?;
+                    if iter.peek().is_some() {
+                        f.write_str(",")?;
+                    }
+                }
+                f.write_str("}")
+            },
+            Self::Null => write!(f, "null"),
+        }
+    }
+}
+
+impl Debug for BencodexKey {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("{}", self))
+    }
+}
+
+impl Display for BencodexKey {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Binary(arg0) => write!(f, "\"0x{}\"", hex::encode(arg0)),
+            Self::Text(arg0) => write!(f, "\"\u{FEFF}{}\"", arg0),
+        }
+    }
+}
+
 impl From<&str> for BencodexKey {
     fn from(val: &str) -> Self {
         BencodexKey::Text(val.to_string())
@@ -69,12 +132,24 @@ impl From<String> for BencodexKey {
     }
 }
 
+impl From<&String> for BencodexKey {
+    fn from(val: &String) -> Self {
+        BencodexKey::Text(val.clone())
+    }
+}
+
 impl From<Vec<u8>> for BencodexKey {
     fn from(val: Vec<u8>) -> Self {
         BencodexKey::Binary(val)
     }
 }
 
+impl From<&Vec<u8>> for BencodexKey {
+    fn from(val: &Vec<u8>) -> Self {
+        BencodexKey::Binary(val.clone())
+    }
+}
+
 impl From<&[u8]> for BencodexKey {
     fn from(val: &[u8]) -> Self {
         BencodexKey::Binary(val.to_vec())