members/libpt-bintols/src/display.rs

@@ -9,13 +9,13 @@ pub use num_traits::{PrimInt, ToPrimitive};
 /// * `data` - The data you are trying to dump
 pub fn bytes_to_bin(data: &[u8]) -> String {
     let mut s = format!("0b{:08b}", data.first().unwrap());
-    for i in 1..data.len() {
-        s.push_str(&format!("_{:08b}", data[i]));
-        if i % 8 == 0 {
-            s.push_str("\n")
+    for dat in data {
+        s.push_str(&format!("_{:08b}", dat));
+        if dat % 8 == 0 {
+            s.push('\n')
         }
     }
-    return s;
+    s
 }
 
 /// Quickly format a number of Bytes [`usize`] with the corresponding

members/libpt-core/src/lib.rs

@@ -6,33 +6,7 @@
 //! This crate implements core functionality useful for many use cases, such as macros,
 //! formatting functions and more.
 
-//// ATTRIBUTES ////////////////////////////////////////////////////////////////////////////////////
-// 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)]
-
-//// IMPORTS ///////////////////////////////////////////////////////////////////////////////////////
 /// macros to make things faster in your code
 pub mod macros;
 /// some general use printing to stdout tools
 pub mod printing;
-
-//// CONSTANTS /////////////////////////////////////////////////////////////////////////////////////
-
-//// STATICS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// ENUMS /////////////////////////////////////////////////////////////////////////////////////////
-
-//// STRUCTS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// IMPLEMENTATION ////////////////////////////////////////////////////////////////////////////////
-
-//// PUBLIC FUNCTIONS //////////////////////////////////////////////////////////////////////////////
-
-//// PRIVATE FUNCTIONS /////////////////////////////////////////////////////////////////////////////

members/libpt-core/src/macros.rs

@@ -2,33 +2,15 @@
 //!
 //! This module implements macros for use with `libpt`.
 
-//// ATTRIBUTES ////////////////////////////////////////////////////////////////////////////////////
-// 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)]
 
-//// IMPORTS ///////////////////////////////////////////////////////////////////////////////////////
 pub use crate::get_stdout_for;
 
-//// CONSTANTS /////////////////////////////////////////////////////////////////////////////////////
-
-//// STATICS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// MACROS ////////////////////////////////////////////////////////////////////////////////////////
 /// ## catches what the expression would write to the `stdout`
 ///
 /// This macro takes an expression, executes it, and catches what it would write to the stdout.
 /// The buffer of the stdout will then be returned for further use.
 ///
 /// This is especially useful when testing loggers or other frontend CLI functions.
-///
-/// Inspiration: [users.rust-lang.org](https://users.rust-lang.org/t/how-to-test-functions-that-use-println/67188/5)
 #[macro_export]
 macro_rules! get_stdout_for {
     ($test:expr) => {{
@@ -46,13 +28,3 @@ macro_rules! get_stdout_for {
         output
     }};
 }
-
-//// ENUMS /////////////////////////////////////////////////////////////////////////////////////////
-
-//// STRUCTS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// IMPLEMENTATION ////////////////////////////////////////////////////////////////////////////////
-
-//// PUBLIC FUNCTIONS //////////////////////////////////////////////////////////////////////////////
-
-//// PRIVATE FUNCTIONS /////////////////////////////////////////////////////////////////////////////

members/libpt-core/src/printing.rs

@@ -1,26 +1,9 @@
 //! # tools that make printing stuff better
 
-//// ATTRIBUTES ////////////////////////////////////////////////////////////////////////////////////
-// 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)]
-
-//// IMPORTS ///////////////////////////////////////////////////////////////////////////////////////
 // reimport our macros to this module, so the user does not get confused when importing the macros
 pub use crate::divider;
 pub use crate::print_divider;
 
-//// TYPES /////////////////////////////////////////////////////////////////////////////////////////
-
-//// CONSTANTS /////////////////////////////////////////////////////////////////////////////////////
-
-//// STATICS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// MACROS ////////////////////////////////////////////////////////////////////////////////////////
 /// Quickly get a one line visual divider
 #[macro_export]
 macro_rules! divider {
@@ -29,7 +12,6 @@ macro_rules! divider {
     }};
 }
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
 /// Quickly print a one line visual divider
 #[macro_export]
 macro_rules! print_divider {
@@ -37,13 +19,3 @@ macro_rules! print_divider {
         println!("{}", divider!())
     }};
 }
-
-//// ENUMS /////////////////////////////////////////////////////////////////////////////////////////
-
-//// STRUCTS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// IMPLEMENTATION ////////////////////////////////////////////////////////////////////////////////
-
-//// PUBLIC FUNCTIONS //////////////////////////////////////////////////////////////////////////////
-
-//// PRIVATE FUNCTIONS /////////////////////////////////////////////////////////////////////////////

members/libpt-log/src/error.rs

@@ -2,29 +2,9 @@
 //!
 //! This module handles errors in logging contexts.
 
-//// ATTRIBUTES ////////////////////////////////////////////////////////////////////////////////////
-// 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)]
-
-//// IMPORTS ///////////////////////////////////////////////////////////////////////////////////////
 use anyhow;
 use thiserror::Error;
 use tracing::subscriber::SetGlobalDefaultError;
-
-//// TYPES /////////////////////////////////////////////////////////////////////////////////////////
-
-//// CONSTANTS /////////////////////////////////////////////////////////////////////////////////////
-
-//// STATICS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// MACROS ////////////////////////////////////////////////////////////////////////////////////////
-
-//// ENUMS /////////////////////////////////////////////////////////////////////////////////////////
 /// ## Errors for the [Logger](super::Logger)
 #[derive(Error, Debug)]
 pub enum Error {
@@ -41,11 +21,3 @@ pub enum Error {
     #[error(transparent)]
     Other(#[from] anyhow::Error),
 }
-
-//// STRUCTS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// IMPLEMENTATION ////////////////////////////////////////////////////////////////////////////////
-
-//// PUBLIC FUNCTIONS //////////////////////////////////////////////////////////////////////////////
-
-//// PRIVATE FUNCTIONS /////////////////////////////////////////////////////////////////////////////

members/libpt-log/src/lib.rs

@@ -14,9 +14,6 @@
 //! - [`tracing_appender`]: Used to log to files
 //! - [`tracing_subscriber`]: Used to do actual logging, formatting, to stdout
 
-//// ATTRIBUTES ////////////////////////////////////////////////////////////////////////////////////
-
-//// IMPORTS ///////////////////////////////////////////////////////////////////////////////////////
 use std::{
     fmt,
     ops::Deref,
@@ -41,8 +38,6 @@ use tracing_subscriber::{
 };
 
 use anyhow::{bail, Result};
-
-//// CONSTANTS /////////////////////////////////////////////////////////////////////////////////////
 /// The log level used when none is specified
 pub const DEFAULT_LOG_LEVEL: Level = Level::INFO;
 /// The path where logs are stored when no path is given.
@@ -50,17 +45,14 @@ pub const DEFAULT_LOG_LEVEL: Level = Level::INFO;
 /// Currently, this is `/dev/null`, meaning they will be written to the void = discarded.
 pub const DEFAULT_LOG_DIR: &'static str = "/dev/null";
 
-//// STATICS ///////////////////////////////////////////////////////////////////////////////////////
 static INITIALIZED: AtomicBool = AtomicBool::new(false);
 
-//// STRUCTS ///////////////////////////////////////////////////////////////////////////////////////
 /// ## Logger for [`pt`](../libpt/index.html)
 ///
 /// This struct exists mainly for the python module, so that we can use the same logger with both
 /// python and rust.
 pub struct Logger;
 
-//// IMPLEMENTATION ////////////////////////////////////////////////////////////////////////////////
 /// ## Main implementation
 impl Logger {
     /// ## create a `Logger`
@@ -117,6 +109,8 @@ impl Logger {
         )
     }
 
+    // TODO: make the args a struct for easy access
+    //
     /// ## initializes the logger
     ///
     /// Will enable the logger to be used.
@@ -262,7 +256,6 @@ impl Logger {
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
 impl fmt::Debug for Logger {
     /// ## DEBUG representation for [`Logger`]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -274,9 +267,6 @@ impl fmt::Debug for Logger {
     }
 }
 
-//// PUBLIC FUNCTIONS //////////////////////////////////////////////////////////////////////////////
-
-//// PRIVATE FUNCTIONS /////////////////////////////////////////////////////////////////////////////
 fn new_file_appender(log_dir: PathBuf) -> NonBlocking {
     let file_appender = tracing_appender::rolling::daily(log_dir.clone(), "log");
     return tracing_appender::non_blocking(file_appender).0;

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

@@ -1,41 +0,0 @@
-//! # Calculate expressions
-//!
-//! This crate is part of [`pt`](../libpt/index.html), but can also be used as a standalone
-//! module.
-//!
-//! Calculate Calculations with your Calculator (`ccc`)
-//!
-//! This modules aim is to take a term of any kind ([String]) and calculate it's value, be it
-//! variable based or a concrete numerical value. It implements different operators and
-//! (mathematical) functions.
-
-//// ATTRIBUTES ////////////////////////////////////////////////////////////////////////////////////
-// 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)]
-
-//// IMPORTS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// TYPES /////////////////////////////////////////////////////////////////////////////////////////
-
-//// CONSTANTS /////////////////////////////////////////////////////////////////////////////////////
-
-//// STATICS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// MACROS ////////////////////////////////////////////////////////////////////////////////////////
-
-//// ENUMS /////////////////////////////////////////////////////////////////////////////////////////
-
-//// STRUCTS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// IMPLEMENTATION ////////////////////////////////////////////////////////////////////////////////
-
-//// PUBLIC FUNCTIONS //////////////////////////////////////////////////////////////////////////////
-
-//// PRIVATE FUNCTIONS /////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////////////////////////

members/libpt-math/src/lib.rs

@@ -3,36 +3,4 @@
 //! This crate is part of [`pt`](../libpt/index.html), but can also be used as a standalone
 //! module.
 //!
-//! This module is currently empty, but will contain many math functionalities in a future version.
-
-//// ATTRIBUTES ////////////////////////////////////////////////////////////////////////////////////
-// 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)]
-
-//// IMPORTS ///////////////////////////////////////////////////////////////////////////////////////
-pub mod ccc;
-
-//// TYPES /////////////////////////////////////////////////////////////////////////////////////////
-
-//// CONSTANTS /////////////////////////////////////////////////////////////////////////////////////
-
-//// STATICS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// MACROS ////////////////////////////////////////////////////////////////////////////////////////
-
-//// ENUMS /////////////////////////////////////////////////////////////////////////////////////////
-
-//// STRUCTS ///////////////////////////////////////////////////////////////////////////////////////
-
-//// IMPLEMENTATION ////////////////////////////////////////////////////////////////////////////////
-
-//// PUBLIC FUNCTIONS //////////////////////////////////////////////////////////////////////////////
-
-//// PRIVATE FUNCTIONS /////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
+//! This crate is currently empty, but will contain many math functionalities in a future version.