misc: applied cargo fmt

Author: WolverinDEV

bmatcher-core/src/compiler/error.rs

@@ -1,4 +1,7 @@
-use core::{fmt::Debug, ops::Range};
+use core::{
+    fmt::Debug,
+    ops::Range,
+};
 
 /// A PositionedError representing an error that is associated with a specific position in the given pattern.
 #[derive(Debug, PartialEq)]

bmatcher-core/src/compiler/lexer.rs

@@ -1,5 +1,7 @@
-use core::ops::Range;
-use core::str::CharIndices;
+use core::{
+    ops::Range,
+    str::CharIndices,
+};
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
 pub enum Token<'a> {
@@ -187,7 +189,10 @@ impl<'a> Lexer<'a> {
 mod test {
     use std::iter;
 
-    use super::{Lexer, Token};
+    use super::{
+        Lexer,
+        Token,
+    };
 
     fn execut_tests(test_cases: &[(&str, &[Token<'_>])]) {
         for (input, expected_output) in test_cases {

bmatcher-core/src/compiler/mod.rs

@@ -2,10 +2,16 @@ mod error;
 pub use error::PositionedError;
 
 mod lexer;
-use lexer::{Lexer, Token};
+use lexer::{
+    Lexer,
+    Token,
+};
 
 mod parser;
-pub use parser::{parse_pattern, ParseError};
+pub use parser::{
+    parse_pattern,
+    ParseError,
+};
 
 mod optimizer;
 pub use optimizer::optimize_pattern;

bmatcher-core/src/compiler/optimizer.rs

@@ -1,7 +1,10 @@
 use alloc::vec::Vec;
 
 use crate::{
-    pattern::{BinaryPattern, OwnedBinaryPattern},
+    pattern::{
+        BinaryPattern,
+        OwnedBinaryPattern,
+    },
     Atom,
 };
 
@@ -235,8 +238,13 @@ pub fn optimize_pattern(pattern: &dyn BinaryPattern) -> OwnedBinaryPattern {
 
 #[cfg(test)]
 mod test {
-    use crate::pattern::BinaryPattern;
-    use crate::{pattern::OwnedBinaryPattern, Atom};
+    use crate::{
+        pattern::{
+            BinaryPattern,
+            OwnedBinaryPattern,
+        },
+        Atom,
+    };
 
     fn test_optimize(input: &[Atom], expected: &[Atom]) {
         println!("Testing: {:?}", input);

bmatcher-core/src/compiler/parser.rs

@@ -1,10 +1,17 @@
-use core::num::ParseIntError;
-
 use alloc::vec::Vec;
+use core::num::ParseIntError;
 
-use crate::{pattern::OwnedBinaryPattern, Atom, JumpType, ReadWidth};
-
-use super::{Lexer, PositionedError, Token};
+use super::{
+    Lexer,
+    PositionedError,
+    Token,
+};
+use crate::{
+    pattern::OwnedBinaryPattern,
+    Atom,
+    JumpType,
+    ReadWidth,
+};
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum ParseError {
@@ -363,14 +370,17 @@ pub fn parse_pattern(pattern: &str) -> Result<OwnedBinaryPattern, PositionedErro
 
 #[cfg(test)]
 mod test {
+    use super::PatternParser;
     use crate::{
-        compiler::{parser::ParseError, PositionedError},
-        Atom, JumpType,
+        compiler::{
+            parser::ParseError,
+            PositionedError,
+        },
+        pattern::BinaryPattern,
+        Atom,
+        JumpType,
     };
 
-    use super::PatternParser;
-    use crate::pattern::BinaryPattern;
-
     #[test]
     fn test_byte_sequence() {
         {

bmatcher-core/src/lib.rs

@@ -4,7 +4,11 @@ extern crate alloc;
 pub mod compiler;
 
 mod atom;
-pub use atom::{Atom, JumpType, ReadWidth};
+pub use atom::{
+    Atom,
+    JumpType,
+    ReadWidth,
+};
 
 mod target;
 pub use target::MatchTarget;
@@ -13,4 +17,8 @@ mod matcher;
 pub use matcher::BinaryMatcher;
 
 mod pattern;
-pub use pattern::{BinaryPattern, BorrowedBinaryPattern, OwnedBinaryPattern};
+pub use pattern::{
+    BinaryPattern,
+    BorrowedBinaryPattern,
+    OwnedBinaryPattern,
+};

bmatcher-core/src/matcher.rs

@@ -1,7 +1,15 @@
-use alloc::vec;
-use alloc::vec::Vec;
-
-use crate::{Atom, BinaryPattern, JumpType, MatchTarget, ReadWidth};
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
+use crate::{
+    Atom,
+    BinaryPattern,
+    JumpType,
+    MatchTarget,
+    ReadWidth,
+};
 
 /// The `BinaryMatcher` is responsible for searching a [BinaryPattern] within a [MatchTarget].
 ///
@@ -190,9 +198,11 @@ impl<'a> BinaryMatcher<'a> {
 
 #[cfg(test)]
 mod test {
-    use crate::{compiler::parse_pattern, BinaryPattern};
-
     use super::BinaryMatcher;
+    use crate::{
+        compiler::parse_pattern,
+        BinaryPattern,
+    };
 
     const DATA: &[u8] = &[
         0xCA, 0x70, 0x11, 0xB5, 0xA, 0x9D, 0x91, 0x83, 0xC4, 0x5A, 0xFC, 0xC7, 0x31, 0x26, 0xC3,

bmatcher-core/src/pattern.rs

@@ -1,6 +1,5 @@
-use core::fmt::Debug;
-
 use alloc::vec::Vec;
+use core::fmt::Debug;
 
 use crate::Atom;
 

bmatcher-proc/src/macro_pattern.rs

@@ -1,9 +1,25 @@
-use std::io::{self, Cursor, Write};
-
-use bmatcher_core::{compiler, Atom, BinaryPattern, JumpType, ReadWidth};
+use std::io::{
+    self,
+    Cursor,
+    Write,
+};
+
+use bmatcher_core::{
+    compiler,
+    Atom,
+    BinaryPattern,
+    JumpType,
+    ReadWidth,
+};
 use proc_macro2::TokenStream;
 use quote::ToTokens;
-use syn::{parse2, Error, Expr, LitStr, Result};
+use syn::{
+    parse2,
+    Error,
+    Expr,
+    LitStr,
+    Result,
+};
 
 fn emit_atom(output: &mut dyn Write, atom: &Atom) -> io::Result<()> {
     match atom {

example/src/main.rs

@@ -1,4 +1,7 @@
-use bmatcher::{pattern, BinaryMatcher};
+use bmatcher::{
+    pattern,
+    BinaryMatcher,
+};
 
 fn main() {
     let data: &[u8] = &[0xE8, 0x00, 0x00, 0x00, 0x00, 0x48, 0x89, 0x04, 0x24, 0xE9];