Automatical formatting

members/libpt-bin/src/ccc/mod.rs

@@ -19,7 +19,7 @@ use libpt::ccc::*;
 use libpt::log::*;
 
 use clap::Parser;
-use clap_verbosity_flag::{Verbosity, InfoLevel};
+use clap_verbosity_flag::{InfoLevel, Verbosity};
 
 use std::path::PathBuf;
 
@@ -64,7 +64,7 @@ pub struct Cli {
     pub log_meta: bool,
 
     /// your exporession(s)
-    #[clap(trailing_var_arg=true)]
+    #[clap(trailing_var_arg = true)]
     pub expression: Vec<String>,
 }
 

members/libpt-bin/src/main/args.rs

@@ -19,7 +19,7 @@ use clap::{Parser, Subcommand};
 
 use clap_num::number_range;
 
-use clap_verbosity_flag::{Verbosity, InfoLevel};
+use clap_verbosity_flag::{InfoLevel, Verbosity};
 
 //// CONSTANTS /////////////////////////////////////////////////////////////////////////////////////
 /// short about section displayed in help
@@ -103,13 +103,10 @@ pub enum NetCommands {
 
         /// set a timeout (in ms)
         #[clap(short, long, default_value_t = 100)]
-        timeout: u64
+        timeout: u64,
-
     },
     /// discover hosts in your network
-    Discover {
+    Discover {},
-
-    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

members/libpt-bin/src/main/mod.rs

@@ -13,7 +13,6 @@
 // enable clippy's extra lints, the pedantic version
 #![warn(clippy::pedantic)]
 
-
 //// IMPORTS ///////////////////////////////////////////////////////////////////////////////////////
 use libpt::{log::*, net::monitoring::uptime};
 
@@ -26,7 +25,6 @@ use std::path::PathBuf;
 
 //// CONSTANTS /////////////////////////////////////////////////////////////////////////////////////
 #[allow(dead_code)]
-
 //// STATICS ///////////////////////////////////////////////////////////////////////////////////////
 
 //// MACROS ////////////////////////////////////////////////////////////////////////////////////////

members/libpt-bintols/src/datalayout.rs

@@ -20,7 +20,8 @@ macro_rules! investigate_memory_layout {
                 let pointer = item as *const $t;
                 let mut memory: [u8; std::mem::size_of::<$t>()] = std::mem::transmute(item.clone());
                 memory.reverse();
-                println!("\
+                println!(
+                    "\
                     \t{index:02x}\titem:\t\t{item:?}\n\
                     \t\tpointer:   \t{:X?}\n\
                     \t\talign:     \t{}\n\

members/libpt-bintols/src/display.rs

@@ -59,8 +59,7 @@ where
             return format!("{:.2} Z", total.to_f64().unwrap() / ZEBI as f64);
         } else if YOBI <= total {
             return format!("{:.2} Y", total.to_f64().unwrap() / YOBI as f64);
-        }
+        } else {
-        else {
             unreachable!()
         }
     }

members/libpt-bintols/tests/display.rs

@@ -1,5 +1,5 @@
-use libpt_bintols::*;
 use libpt_bintols::display::*;
+use libpt_bintols::*;
 
 #[test]
 fn btobin() {
@@ -10,11 +10,16 @@ fn btobin() {
 
 #[test]
 fn big_btobin() {
-    let data = [12,31,82,32,123,32,92,23,12,32,12,1,1,1];
+    let data = [12, 31, 82, 32, 123, 32, 92, 23, 12, 32, 12, 1, 1, 1];
     let r = bytes_to_bin(&data);
-    assert_eq!(r, format!("0b00001100_00011111_01010010_\
+    assert_eq!(
+        r,
+        format!(
+            "0b00001100_00011111_01010010_\
     00100000_01111011_00100000_01011100_00010111_00001100\n\
-    _00100000_00001100_00000001_00000001_00000001"));
+    _00100000_00001100_00000001_00000001_00000001"
+        )
+    );
 }
 
 #[test]
@@ -29,35 +34,35 @@ fn hmnbytes() {
     assert_eq!(humanbytes(0), format!("0 B"));
     assert_eq!(humanbytes(1), format!("1 B"));
 
-    assert_eq!(humanbytes(KIBI-1),  format!("1023 B"));
+    assert_eq!(humanbytes(KIBI - 1), format!("1023 B"));
     assert_eq!(humanbytes(KIBI), format!("1.00 K"));
-    assert_eq!(humanbytes(KIBI+1),  format!("1.00 K"));
+    assert_eq!(humanbytes(KIBI + 1), format!("1.00 K"));
 
-    assert_eq!(humanbytes(MEBI-1),  format!("1024.00 K"));
+    assert_eq!(humanbytes(MEBI - 1), format!("1024.00 K"));
     assert_eq!(humanbytes(MEBI), format!("1.00 M"));
-    assert_eq!(humanbytes(MEBI+1),  format!("1.00 M"));
+    assert_eq!(humanbytes(MEBI + 1), format!("1.00 M"));
 
-    assert_eq!(humanbytes(GIBI-1),  format!("1024.00 M"));
+    assert_eq!(humanbytes(GIBI - 1), format!("1024.00 M"));
     assert_eq!(humanbytes(GIBI), format!("1.00 G"));
-    assert_eq!(humanbytes(GIBI+1),  format!("1.00 G"));
+    assert_eq!(humanbytes(GIBI + 1), format!("1.00 G"));
 
-    assert_eq!(humanbytes(TEBI-1),  format!("1024.00 G"));
+    assert_eq!(humanbytes(TEBI - 1), format!("1024.00 G"));
     assert_eq!(humanbytes(TEBI), format!("1.00 T"));
-    assert_eq!(humanbytes(TEBI+1),  format!("1.00 T"));
+    assert_eq!(humanbytes(TEBI + 1), format!("1.00 T"));
 
-    assert_eq!(humanbytes(PEBI-1),  format!("1024.00 T"));
+    assert_eq!(humanbytes(PEBI - 1), format!("1024.00 T"));
     assert_eq!(humanbytes(PEBI), format!("1.00 P"));
-    assert_eq!(humanbytes(PEBI+1),  format!("1.00 P"));
+    assert_eq!(humanbytes(PEBI + 1), format!("1.00 P"));
 
-    assert_eq!(humanbytes(EXBI-1),  format!("1024.00 P"));
+    assert_eq!(humanbytes(EXBI - 1), format!("1024.00 P"));
     assert_eq!(humanbytes(EXBI), format!("1.00 E"));
-    assert_eq!(humanbytes(EXBI+1),  format!("1.00 E"));
+    assert_eq!(humanbytes(EXBI + 1), format!("1.00 E"));
 
-    assert_eq!(humanbytes(ZEBI-1),  format!("1024.00 E"));
+    assert_eq!(humanbytes(ZEBI - 1), format!("1024.00 E"));
     assert_eq!(humanbytes(ZEBI), format!("1.00 Z"));
-    assert_eq!(humanbytes(ZEBI+1),  format!("1.00 Z"));
+    assert_eq!(humanbytes(ZEBI + 1), format!("1.00 Z"));
 
-    assert_eq!(humanbytes(YOBI-1),  format!("1024.00 Z"));
+    assert_eq!(humanbytes(YOBI - 1), format!("1024.00 Z"));
     assert_eq!(humanbytes(YOBI), format!("1.00 Y"));
-    assert_eq!(humanbytes(YOBI+1),  format!("1.00 Y"));
+    assert_eq!(humanbytes(YOBI + 1), format!("1.00 Y"));
 }

members/libpt-ccc/src/base.rs

@@ -12,8 +12,8 @@
 #![warn(clippy::pedantic)]
 
 //// IMPORTS ///////////////////////////////////////////////////////////////////////////////////////
-use std::fmt::Display;
 pub use num_traits::PrimInt;
+use std::fmt::Display;
 
 #[allow(unused_imports)] // we possibly want to use all log levels
 use libpt_log::*;
@@ -48,7 +48,7 @@ pub enum Operator {
     /// Mathmatical modulo, finite field arithmetic
     Modulo,
     /// Any function, seel [`Function`]
-    Function(Function)
+    Function(Function),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -82,7 +82,7 @@ pub enum Function {
 #[derive(Debug)]
 pub enum Error {
     /// The term has bad syntax
-    SyntaxError(String)
+    SyntaxError(String),
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -106,7 +106,7 @@ pub enum NumVal {
     /// Value can be negative
     Unsigned(u128),
     /// Value is not an integer
-    Float(f64)
+    Float(f64),
 }
 
 //// STRUCTS ///////////////////////////////////////////////////////////////////////////////////////
@@ -114,28 +114,27 @@ pub enum NumVal {
 ///
 /// currently not implemented
 #[derive(Debug)]
-pub struct VarVal {
+pub struct VarVal {}
-}
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 /// Represents a Value with a complex number,
 ///
 /// currently not implemented
 #[derive(Debug)]
-pub struct ComplVal {
+pub struct ComplVal {}
-}
 
 //// IMPLEMENTATION ////////////////////////////////////////////////////////////////////////////////
-impl<T: num_traits::PrimInt> From<T> for NumVal where
+impl<T: num_traits::PrimInt> From<T> for NumVal
+where
     u128: TryFrom<T>,
-    u128: TryFrom<T> {
+    u128: TryFrom<T>,
+{
     fn from(value: T) -> Self {
         if T::min_value().is_zero() {
             // unsigned data types
             // `u128` is the largest unsigned datatype, any other type will fit.
             NumVal::Unsigned(value.to_u128().unwrap())
-        }
+        } else {
-        else {
             // signed data types
             // `i128` is the largest unsigned datatype, any other type will fit.
             NumVal::Signed(value.to_i128().unwrap())
@@ -155,9 +154,11 @@ impl Display for Error {
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-impl<T: PrimInt> From<T> for Value where
+impl<T: PrimInt> From<T> for Value
+where
     u128: TryFrom<T>,
-    u128: TryFrom<T> {
+    u128: TryFrom<T>,
+{
     fn from(value: T) -> Self {
         NumVal::from(value).into()
     }

members/libpt-ccc/src/lib.rs

@@ -52,7 +52,7 @@ pub struct Calculator;
 impl Calculator {
     /// Do a single calculation without doing anything else
     pub fn oneshot(t: String) -> Result<Value> {
-        trace!(orig=t, "parsing original string to Term");
+        trace!(orig = t, "parsing original string to Term");
         let t = Term::new(t)?;
         trace!("term has been parsed, starting Calculation");
         debug!("parsed term: {t:#?}");
@@ -73,9 +73,9 @@ impl Calculator {
         if t.result.is_none() {
             let reason = format!("Term was processed but no result was assigned.");
             // FIXME: unfitting error type
-            return Err(Error::SyntaxError(reason))
+            return Err(Error::SyntaxError(reason));
         }
-        return t.result.unwrap()
+        return t.result.unwrap();
     }
 }
 

members/libpt-ccc/src/term.rs

@@ -20,7 +20,10 @@
 use std::collections::VecDeque;
 
 //// IMPORTS ///////////////////////////////////////////////////////////////////////////////////////
-pub use super::{Error, Result, Value, base::{self, *}};
+pub use super::{
+    base::{self, *},
+    Error, Result, Value,
+};
 #[allow(unused_imports)] // we possibly want to use all log levels
 use libpt_log::*;
 #[allow(unused_imports)] // import more complex math stuff from there
@@ -73,7 +76,7 @@ pub struct Term {
     /////////////////////////////////////
     #[allow(unused)] // tmp
     operator_stack: Vec<Operator>,
-    output_queue: VecDeque<Token>
+    output_queue: VecDeque<Token>,
 }
 
 //// IMPLEMENTATION ////////////////////////////////////////////////////////////////////////////////
@@ -82,15 +85,13 @@ impl Term {
     ///
     /// Invalid terms will result in an [`Err`].
     pub fn new(orig: String) -> Result<Term> {
-        return Ok(
+        return Ok(Term {
-            Term {
             original: orig,
             text: String::new(), // will be initialized in `prepare()`
             result: None,
             operator_stack: Vec::new(),
-                output_queue: VecDeque::new()
+            output_queue: VecDeque::new(),
-            }
+        });
-        )
     }
 
     /// Prepare the term for the processing.
@@ -144,8 +145,10 @@ impl Term {
         // - '学' alphanumeric
         // - '+'  not alphanumeric
         for c in s.chars() {
-            #[cfg(debug_assertions)] {
+            #[cfg(debug_assertions)]
-                debug!("filter checks for '{c}':
+            {
+                debug!(
+                    "filter checks for '{c}':
                 alphanumeric:       {}
                 allowed special:    {}
                 EXCEPT IF
@@ -156,16 +159,7 @@ impl Term {
                     c.is_ascii_control(),
                 )
             }
-            if
+            if (!c.is_alphanumeric() || !Self::is_allowed_special_c(&c)) && (c.is_ascii_control()) {
-                (
-                    !c.is_alphanumeric()                    ||
-                    !Self::is_allowed_special_c(&c)
-                )
-                &&
-                (
-                    c.is_ascii_control()
-                )
-            {
                 // TODO: allow any unicode char to be a variable
                 let reason = format!("'{c}' is not a valid character, only alphanumeric, punctuation, operators are allowed.");
                 warn!(reason);
@@ -181,14 +175,14 @@ impl Term {
             }
         }
 
-        return Ok(filtered)
+        return Ok(filtered);
     }
 
     /// check if we should ignore this character
     fn is_ignore(c: &char) -> bool {
         match *c {
             ' ' => true,
-            _ => false
+            _ => false,
         }
     }
 
@@ -196,21 +190,22 @@ impl Term {
     fn is_allowed_special_c(c: &char) -> bool {
         match *c {
             '+' | '-' | '*' | '/' | '%' => true,
-            _ => false
+            _ => false,
         }
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 /// Helper methods for Tokens
-impl Token { }
+impl Token {}
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-impl<T> From<T> for Token where
+impl<T> From<T> for Token
+where
     T: Into<Value>,
     T: PrimInt,
-    u128: TryFrom<T>
+    u128: TryFrom<T>,
-    {
+{
     fn from(value: T) -> Self {
         Token::Value(base::Value::from(value))
     }

members/libpt-core/src/lib.rs

@@ -10,11 +10,9 @@
 // we want docs
 #![warn(missing_docs)]
 #![warn(rustdoc::missing_crate_level_docs)]
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // we want Debug everywhere.
 #![warn(missing_debug_implementations)]
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // enable clippy's extra lints, the pedantic version
 #![warn(clippy::pedantic)]

members/libpt-core/src/macros.rs

@@ -6,11 +6,9 @@
 // we want docs
 #![warn(missing_docs)]
 #![warn(rustdoc::missing_crate_level_docs)]
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // we want Debug everywhere.
 #![warn(missing_debug_implementations)]
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // enable clippy's extra lints, the pedantic version
 #![warn(clippy::pedantic)]

members/libpt-log/src/error.rs

@@ -90,4 +90,3 @@ impl std::fmt::Display for Error {
 //// PUBLIC FUNCTIONS //////////////////////////////////////////////////////////////////////////////
 
 //// PRIVATE FUNCTIONS /////////////////////////////////////////////////////////////////////////////
-

members/libpt-log/src/lib.rs

@@ -28,7 +28,7 @@ use error::*;
 
 pub use tracing::{debug, error, info, trace, warn, Level};
 use tracing_appender;
-use tracing_subscriber::{prelude::*, fmt::format::FmtSpan};
+use tracing_subscriber::{fmt::format::FmtSpan, prelude::*};
 
 use pyo3::prelude::*;
 //// CONSTANTS /////////////////////////////////////////////////////////////////////////////////////
@@ -254,4 +254,3 @@ impl fmt::Debug for Logger {
 //// PUBLIC FUNCTIONS //////////////////////////////////////////////////////////////////////////////
 
 //// PRIVATE FUNCTIONS /////////////////////////////////////////////////////////////////////////////
-

members/libpt-net/src/lib.rs

@@ -10,11 +10,9 @@
 // we want docs
 #![warn(missing_docs)]
 #![warn(rustdoc::missing_crate_level_docs)]
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // we want Debug everywhere.
 #![warn(missing_debug_implementations)]
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // enable clippy's extra lints, the pedantic version
 #![warn(clippy::pedantic)]

members/libpt-net/src/monitoring/mod.rs

@@ -6,11 +6,9 @@
 // we want docs
 #![warn(missing_docs)]
 #![warn(rustdoc::missing_crate_level_docs)]
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // we want Debug everywhere.
 #![warn(missing_debug_implementations)]
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // enable clippy's extra lints, the pedantic version
 #![warn(clippy::pedantic)]

members/libpt-net/src/monitoring/uptime.rs

@@ -188,7 +188,11 @@ pub fn continuous_uptime_monitor(
     let mut last_was_up: bool = true;
     let mut last_ratio: u8 = status.success_ratio;
     loop {
-        trace!(?status, ?last_was_up, "loop iteration for continuous uptime monitor");
+        trace!(
+            ?status,
+            ?last_was_up,
+            "loop iteration for continuous uptime monitor"
+        );
         if !status.success {
             if last_was_up {
                 trace!("displaying status");

members/libpt-py/src/lib.rs

@@ -1,7 +1,5 @@
 // FIXME: Using a local dependency does not work with maturin as it seems?
-use libpt::{
+use libpt::log::*;
-    log::*,
-};
 
 use pyo3::prelude::*;
 

src/lib.rs

@@ -6,10 +6,12 @@
 //! `pt` is a project consisting of multiple smaller crates, all bundled together in this
 //! "main crate". Most crates will only show up if you activate their feature.
 
-#[cfg(feature = "core")]
-pub use libpt_core     as core;
 #[cfg(feature = "bintols")]
 pub use libpt_bintols as bintols;
+#[cfg(feature = "ccc")]
+pub use libpt_ccc as ccc;
+#[cfg(feature = "core")]
+pub use libpt_core as core;
 #[cfg(feature = "hedu")]
 pub use libpt_hedu as hedu;
 #[cfg(feature = "log")]
@@ -18,5 +20,3 @@ pub use libpt_log      as log;
 pub use libpt_math as math;
 #[cfg(feature = "net")]
 pub use libpt_net as net;
-#[cfg(feature = "ccc")]
-pub use libpt_ccc      as ccc;