[FEAT]: add features, ci, CODEOWNERS, etc. (#6)

* feat: add CODEOWNERS

* feat: add `get` and `set`

* ci: init github action ci

* docs: add comment in `pre-commit`

* feat: add `debounce`

* feat: add `is_number`

* refactor: colocate tests into folders

Author: ImBIOS

.githooks/pre-commit

@@ -2,17 +2,20 @@
 
 set -eu
 
+# Format staged files
 if ! cargo fmt -- --check; then
   echo "There are some code style issues."
   echo "Run cargo fmt first."
   exit 1
 fi
 
+# Lint staged files
 if ! cargo clippy --all-targets -- -D warnings; then
   echo "There are some clippy issues."
   exit 1
 fi
 
+# Full test
 if ! cargo test; then
   echo "There are some test issues."
   exit 1

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @ImBIOS

.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: Cargo Build & Test
+
+on:
+  push:
+  pull_request:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  pre_ci:
+    uses: ImBIOS/.github/.github/workflows/pre_ci.yml@main
+
+  build_and_test:
+    name: Rust project - latest
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        toolchain:
+          - stable
+          - beta
+          - nightly
+    steps:
+      - uses: actions/checkout@v3
+      - run: rustup update ${{ matrix.toolchain }} && rustup default ${{ matrix.toolchain }}
+      - run: cargo build --verbose
+      - run: cargo test --verbose

Cargo.toml

@@ -3,6 +3,7 @@ name = "lorust"
 authors = ["Imamuzzaki Abu Salam <[email protected]>"]
 description = "Modern Rust utility library delivering modularity, performance & extras; or simply Rust version of Lodash"
 version = "0.1.0"
+rust-version = "1.70"
 edition = "2021"
 readme = "README.md"
 license = "MIT OR Apache-2.0"
@@ -22,19 +23,33 @@ categories = [
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-default = ["math", "object", "string"]
-math = []
-object = ["serde_json"]
-string = ["unicode-normalization", "regex"]
-
-[dependencies.unicode-normalization]
-version = "0.1.22"
-optional = true
-
-[dependencies.regex]
-version = "1.5.4"
-optional = true
-
-[dependencies.serde_json]
-version = "1.0.100"
-optional = true
+default = ["function", "lang", "math", "object", "string"]
+
+function = ["debounce"]
+debounce = ["log"]
+
+lang = ["is_number"]
+is_number = []
+
+math = ["round"]
+round = []
+
+object = ["get", "map_values", "merge", "pick", "set"]
+get = []
+map_values = []
+merge = ["serde_json"]
+pick = []
+set = []
+
+string = ["capitalize", "deburr", "ends_with", "kebab_case", "words"]
+capitalize = []
+deburr = ["unicode-normalization"]
+ends_with = []
+kebab_case = []
+words = ["regex"]
+
+[dependencies]
+serde_json = { version = "1.0.100", optional = true }
+regex = { version = "1.5.4", optional = true }
+unicode-normalization = { version = "0.1.22", optional = true }
+log = { version = "0.4.14", optional = true }

rust-toolchain.toml

@@ -0,0 +1,150 @@
+use std::{
+    pin::Pin,
+    sync::{mpsc, Arc, Mutex},
+    time::Duration,
+};
+
+/// Debounce function takes a closure and a delay, and returns a `Debounce` struct.
+///
+/// # Arguments
+///
+/// * `closure` - A closure which accepts a parameter of type `T` and returns `()`.
+/// * `delay` - The duration after which the closure should be invoked.
+///
+/// # Returns
+///
+/// * `Debounce<T>` - An instance of Debounce struct which can be used to call the closure
+///   or terminate the execution.
+///
+/// The function also spawns a new thread which waits for a message to arrive on the receiver
+/// end of a channel. The first message that arrives sets the `current_param`.
+/// After the first message arrives, the thread waits with a timeout equal to `delay`.
+/// If another message arrives during this period, `current_param` is overwritten.
+/// If the timeout occurs without a new message, the closure is called with `current_param` as the argument.
+pub fn debounce<F, T>(closure: F, delay: Duration) -> Debounce<T>
+where
+    F: Fn(T) + Send + Sync + 'static,
+    T: Send + Sync + 'static,
+{
+    let (sender, receiver) = mpsc::channel();
+    let sender = Arc::new(Mutex::new(sender));
+    let debounce_config = Arc::new(Mutex::new(DebounceConfig {
+        closure: Box::pin(closure),
+        delay,
+    }));
+
+    let dup_debounce_config = debounce_config.clone();
+
+    Debounce {
+        sender: Some(sender),
+        thread: Some(std::thread::spawn(move || {
+            let debounce_config = dup_debounce_config;
+            let mut current_param = None; // finally saved as an argument to the execution
+            loop {
+                if current_param.is_none() {
+                    let message = receiver.recv();
+                    match message {
+                        Ok(param) => current_param = param,
+                        Err(_) => {
+                            break;
+                        }
+                    }
+                } else {
+                    let message = receiver.recv_timeout(debounce_config.lock().unwrap().delay);
+                    match message {
+                        Ok(param) => current_param = param,
+                        Err(err) => match err {
+                            mpsc::RecvTimeoutError::Timeout => {
+                                if let Some(param) = current_param.take() {
+                                    (*debounce_config.lock().unwrap().closure)(param);
+                                }
+                            }
+                            mpsc::RecvTimeoutError::Disconnected => {
+                                break;
+                            }
+                        },
+                    }
+                }
+            }
+        })),
+        debounce_config,
+    }
+}
+
+/// `DebounceConfig` struct stores a closure and a delay duration.
+/// This struct is used within `Debounce` struct to keep track of the configuration.
+///
+/// # Fields
+///
+/// * `closure` - A closure which accepts a parameter of type `T` and returns `()`.
+/// * `delay` - The duration after which the closure should be invoked.
+struct DebounceConfig<T> {
+    closure: Pin<Box<dyn Fn(T) + Send + Sync + 'static>>,
+    delay: Duration,
+}
+
+impl<T> Drop for DebounceConfig<T> {
+    /// The `Drop` trait implementation for `DebounceConfig`.
+    /// Logs a message with the memory address of the `DebounceConfig` instance when it's dropped.
+    fn drop(&mut self) {
+        log::trace!("drop DebounceConfig {:?}", format!("{:p}", self));
+    }
+}
+
+/// `Debounce` struct enables calling the provided closure after a specified delay.
+/// The delay is reset if another call is made before the delay duration has passed.
+/// It holds an `Option` for a sender which is used to send messages to the worker thread.
+/// It also holds an `Option` for a JoinHandle for the worker thread.
+/// The `debounce_config` stores the closure and delay information.
+///
+/// # Fields
+///
+/// * `sender` - An `Option` for a sender which is used to send messages to the worker thread.
+/// * `thread` - An `Option` for a JoinHandle for the worker thread.
+/// * `debounce_config` - Stores the closure and delay information.
+#[allow(dead_code)]
+pub struct Debounce<T> {
+    sender: Option<Arc<Mutex<mpsc::Sender<Option<T>>>>>,
+    thread: Option<std::thread::JoinHandle<()>>,
+    debounce_config: Arc<Mutex<DebounceConfig<T>>>,
+}
+
+impl<T> Debounce<T> {
+    /// Method `call` sends a message with a parameter to the worker thread.
+    /// This causes the delay timer to reset in the worker thread.
+    ///
+    /// # Arguments
+    ///
+    /// * `param` - The parameter to send to the worker thread.
+    /// This will be used as the argument for the closure when the delay has passed.
+    pub fn call(&self, param: T) {
+        self.sender
+            .as_ref()
+            .unwrap()
+            .lock()
+            .unwrap()
+            .send(Some(param))
+            .unwrap();
+    }
+
+    /// Method `terminate` sends a `None` message to the worker thread,
+    /// causing it to exit the loop and end the execution.
+    pub fn terminate(&self) {
+        self.sender
+            .as_ref()
+            .unwrap()
+            .lock()
+            .unwrap()
+            .send(None)
+            .unwrap();
+    }
+}
+
+impl<T> Drop for Debounce<T> {
+    /// The `Drop` trait implementation for `Debounce`.
+    /// On drop, it terminates the worker thread and logs a message with the memory address of the `Debounce` instance.
+    fn drop(&mut self) {
+        self.terminate();
+        log::trace!("drop Debounce {:?}", format!("{:p}", self));
+    }
+}

src/function/debounce.rs

@@ -0,0 +1,3 @@
+mod debounce;
+#[cfg(feature = "debounce")]
+pub use debounce::*;

src/function/mod.rs

@@ -0,0 +1,26 @@
+/// The `is_number` function takes a string and returns a boolean value.
+/// It checks if the input string can be parsed into a f64 number excluding the special f64 number cases
+/// (i.e., "inf", "-inf", "+inf", "infinity", "-infinity", "+infinity", "nan").
+///
+/// # Arguments
+///
+/// * `s` - A String to check if it can be parsed into a f64 number excluding special cases.
+///
+/// # Example
+///
+/// ```
+/// use lorust::is_number;
+///
+/// assert_eq!(is_number("123.456".to_string()), true);
+/// assert_eq!(is_number("abc".to_string()), false);
+/// assert_eq!(is_number("inf".to_string()), false);
+/// assert_eq!(is_number("NaN".to_string()), false);
+/// ```
+pub fn is_number(s: String) -> bool {
+    match s.to_lowercase().as_str() {
+        "inf" | "-inf" | "+inf" | "infinity" | "-infinity" | "+infinity" | "nan" => return false,
+        _ => {}
+    }
+
+    s.parse::<f64>().is_ok()
+}

src/lang/is_number.rs

@@ -0,0 +1,3 @@
+mod is_number;
+#[cfg(feature = "is_number")]
+pub use is_number::*;

src/lang/mod.rs

@@ -10,18 +10,14 @@
 //! [dependencies]
 //! lorust = "0.1.0"
 //! ```
-//!
-//! ## Functions Categorization
-//!
-//! We follow the flat function structure of **Lodash**, but the functions can be categorized into following areas:
-//!
-//! | Category     | Description                                                  |
-//! |--------------|--------------------------------------------------------------|
-//! | `string`     | Utility functions to deal with Strings                       |
-//! | `array`      | Utility functions to deal with Arrays (Not yet support)      |
-//! | `math`       | Utility functions to deal with Maths (Not yet support)       |
-//! | `object`     | Utility functions to deal with Objects (Not yet support)     |
-//!
+
+mod function;
+#[cfg(feature = "function")]
+pub use function::*;
+
+mod lang;
+#[cfg(feature = "lang")]
+pub use lang::*;
 
 mod math;
 #[cfg(feature = "math")]