add

Author: baseplate-admin

crates/bencode/src/dispatcher/bdecode.rs

@@ -1,5 +1,5 @@
-use crate::parser::parse_bencode;
 use crate::enums::bencode::BencodeValue;
+use crate::parser::parse_bencode;
 
 /// Decode bencode data using the cursor-based iterative parser.
 pub fn decode_bencode(data: &[u8]) -> Result<(BencodeValue, &[u8]), &'static str> {

crates/bencode/src/lib.rs

@@ -1,7 +1,7 @@
-pub mod parser;
 pub mod dispatcher;
 pub mod encoders;
 pub mod enums;
+pub mod parser;
 
 // Re-export top-level API for convenience
 pub use dispatcher::bdecode::decode_bencode;

crates/bencode/src/parser/cursor.rs

@@ -57,7 +57,8 @@ impl<'a> Cursor<'a> {
             }
             let digit = (b - b'0') as usize;
             if digit < 10 {
-                len = len.checked_mul(10)
+                len = len
+                    .checked_mul(10)
                     .ok_or("String length overflow")?
                     .checked_add(digit)
                     .ok_or("String length overflow")?;
@@ -89,7 +90,9 @@ impl<'a> Cursor<'a> {
         }
 
         // Leading-zero check: if next byte is '0' and followed by another digit, reject
-        if let Some(&b) = self.input.get(self.position) && b == b'0' {
+        if let Some(&b) = self.input.get(self.position)
+            && b == b'0'
+        {
             if let Some(&b2) = self.input.get(self.position + 1)
                 && b2.is_ascii_digit()
             {
@@ -110,7 +113,8 @@ impl<'a> Cursor<'a> {
             }
             if b.is_ascii_digit() {
                 let digit = (b - b'0') as i128;
-                value = value.checked_mul(10)
+                value = value
+                    .checked_mul(10)
                     .ok_or("Integer overflow")?
                     .checked_add(digit)
                     .ok_or("Integer overflow")?;

crates/bencode/src/parser/mod.rs

@@ -40,9 +40,7 @@ pub fn parse_bencode(input: &[u8]) -> Result<(BencodeValue, &[u8]), &'static str
         }
         b'l' => {
             cursor.advance(1);
-            stack.push(ParseFrame::List {
-                items: Vec::new(),
-            });
+            stack.push(ParseFrame::List { items: Vec::new() });
         }
         b'd' => {
             cursor.advance(1);
@@ -121,7 +119,10 @@ fn push_value(stack: &mut ParseStack, value: BencodeValue) -> Result<(), &'stati
             items.push(value);
             Ok(())
         }
-        ParseFrame::Dict { entries, pending_key } => {
+        ParseFrame::Dict {
+            entries,
+            pending_key,
+        } => {
             if let Some(key) = pending_key.take() {
                 entries.insert(key, value);
                 Ok(())
@@ -143,7 +144,10 @@ fn push_value(stack: &mut ParseStack, value: BencodeValue) -> Result<(), &'stati
 fn complete_frame(frame: ParseFrame) -> Result<BencodeValue, &'static str> {
     match frame {
         ParseFrame::List { items } => Ok(BencodeValue::List(items)),
-        ParseFrame::Dict { entries, pending_key } => {
+        ParseFrame::Dict {
+            entries,
+            pending_key,
+        } => {
             if pending_key.is_some() {
                 return Err("Dictionary has unpaired key at end");
             }

crates/bencode/src/parser/stack.rs

@@ -6,9 +6,7 @@ use std::collections::BTreeMap;
 #[derive(Debug)]
 pub enum ParseFrame {
     /// Collecting items into a list (terminated by 'e').
-    List {
-        items: Vec<BencodeValue>,
-    },
+    List { items: Vec<BencodeValue> },
     /// Collecting key-value pairs into a dictionary (terminated by 'e').
     Dict {
         entries: BTreeMap<Vec<u8>, BencodeValue>,

crates/bencode/src/parser/tests.rs

@@ -2,7 +2,7 @@
 #[allow(clippy::module_inception)]
 mod tests {
     use crate::enums::bencode::BencodeValue;
-    use crate::parser::{parse_bencode, Cursor};
+    use crate::parser::{Cursor, parse_bencode};
 
     // --- Strings ---
 
@@ -141,7 +141,10 @@ mod tests {
         match val {
             BencodeValue::Dict(map) => {
                 assert_eq!(map.len(), 1);
-                assert_eq!(*map.get(b"name".as_slice()).unwrap(), BencodeValue::Str(b"alice".to_vec()));
+                assert_eq!(
+                    *map.get(b"name".as_slice()).unwrap(),
+                    BencodeValue::Str(b"alice".to_vec())
+                );
             }
             _ => panic!("Expected dict"),
         }
@@ -154,7 +157,10 @@ mod tests {
             BencodeValue::Dict(map) => {
                 assert_eq!(map.len(), 2);
                 assert_eq!(*map.get(b"age".as_slice()).unwrap(), BencodeValue::Int(25));
-                assert_eq!(*map.get(b"name".as_slice()).unwrap(), BencodeValue::Str(b"alice".to_vec()));
+                assert_eq!(
+                    *map.get(b"name".as_slice()).unwrap(),
+                    BencodeValue::Str(b"alice".to_vec())
+                );
             }
             _ => panic!("Expected dict"),
         }
@@ -169,7 +175,10 @@ mod tests {
                 match map.get(b"addr".as_slice()) {
                     Some(BencodeValue::Dict(inner)) => {
                         assert_eq!(inner.len(), 1);
-                        assert_eq!(*inner.get(b"zipcode".as_slice()).unwrap(), BencodeValue::Int(90210));
+                        assert_eq!(
+                            *inner.get(b"zipcode".as_slice()).unwrap(),
+                            BencodeValue::Int(90210)
+                        );
                     }
                     _ => panic!("Expected nested dict"),
                 }
@@ -234,9 +243,7 @@ mod tests {
                 map.insert(b"key".to_vec(), BencodeValue::Int(-99));
                 map
             }),
-            BencodeValue::List(vec![
-                BencodeValue::Str(b"nested".to_vec()),
-            ]),
+            BencodeValue::List(vec![BencodeValue::Str(b"nested".to_vec())]),
         ]);
 
         let encoded = encode_bencode(original.clone()).unwrap();