✨ Updated Structure and Documentation

Author: nwrenger

Cargo.lock

@@ -1,9 +1,9 @@
 [package]
 name = "console-utils"
-version = "1.5.3"
+version = "1.5.4"
 edition = "2021"
 authors = ["Nils Wrenger <[email protected]>"]
-description = "Cli input utilities."
+description = "Simple CLI Input and Control Utilities"
 keywords = ["console", "terminal", "cli"]
 categories = ["command-line-utilities", "cli"]
 repository = "https://github.com/nwrenger/console-utils-rs"

Cargo.toml

@@ -1,128 +1,69 @@
-# Console Utility Library
+# Console Utils
 
 [![Crate](https://img.shields.io/crates/v/console-utils.svg)](https://crates.io/crates/console-utils)
 [![API](https://docs.rs/console-utils/badge.svg)](https://docs.rs/console-utils)
 
-A simple Rust library for console-based user input, option selection and more.
+_A Rust library for console-based user input, option selection, control, and more._
 
-## Input Function
+# Overview
 
-The `input` function reads user input from the console. It prompts the user with a message, reads a line of input, and returns an `Option<T>`.
+This crate offers utility functions for various console-related operations in Rust programs. From obtaining user input to achieving precise terminal control, its main focus is to remain simple while providing extensive functionality.
 
-### Usage
 
-```rust
-use console_utils::input;
 
-fn main() {
-    // Prompt the user for input
-    let user_input = input::<String>("Enter something: ", false);
+## Usage
 
-    // Process the user input
-    match user_input {
-        Some(value) => println!("You entered: {}", value),
-        None => panic!("The Input cannot be None, allow_empty is false."),
-    }
-}
+To use Console Utils in your Rust project, you can add the following dependency to your `Cargo.toml` file:
+
+```toml
+[dependencies]
+console-utils = "1.5.4"
 ```
-## Select Function
 
-The `select` function allows the user to interactively select options from a list. It uses arrow keys or 'w' and 's' keys for navigation, spacebar for selection, and Enter to confirm. It returns an `Option<Vec<bool>>` indicating which options were selected.
+After adding the dependency, you can import the modules you need in your Rust code. For example:
 
-### Usage
+```rust
+use console_utils::input::{input, select};
+use console_utils::control::{flush, clear_line};
+```
+
+## Example
 
 ```rust
-use console_utils::select;
+use console_utils::input::{input, select, spinner, SpinnerType};
 
 fn main() {
+    // Read user input as a string
+    let user_input: Option<String> = input("Enter something: ", false);
+    
+    match user_input {
+        Some(value) => println!("You entered: {}", value),
+        None => panic!("Input cannot be None when 'allow_empty' is set to false."),
+    }
+
+    // Display a standard spinner for 3 seconds
+    spinner(3.0, SpinnerType::Standard);
+
     let options = vec![
         "Option 1",
         "Option 2",
         "Option 3",
     ];
 
-    // Prompt the user to select options
-    let selected_options = select("Select an option:", &options, false, false);
+    // Allow the user to select one option
+    let selected_indices = select("Select an option:", &options, false, false);
 
-    // Process the selected options
-    match selected_options {
-        Some(selections) => {
-            for (i, selected) in selections.iter().enumerate() {
-                println!("Option {} selected: {}", i + 1, selected);
-            }
-        }
+    match selected_indices {
+        Some(indices) => println!("Selected indices: {:?}", indices),
         None => panic!("The Options cannot be None, allow_empty is false."),
     }
-}
-```
-
-## Read Function
-
-The read module provides cross-platform functionality for reading keyboard input. It includes the Key enum representing different keyboard keys and platform-specific implementations for Windows and Unix.
-
-### Usage
-
-```rust
-use console_utils::read::{Key, read_key};
-
-fn main() {
-    // Cross-platform key reading example
-    let key = read_key().unwrap();
-
-    println!("Pressed key: {:?}", key);
-}
-```
-
-## Spinner Function
-
-The spinner function creates a console-based spinner animation, offering a visually appealing way to indicate ongoing processes.
-
-### Usage
-
-```rust
-use console_utils::{spinner, SpinnerType};
-fn main() {
-    // Display a standard spinner for 3 seconds
-    spinner(3.0, SpinnerType::Standard);
-    
-    // Display a dots spinner for 2 seconds
-    spinner(2.0, SpinnerType::Dots);
-    
-    // Display a custom spinner for 1 second (using custom frames)
-    spinner(1.0, SpinnerType::Custom(vec!["1", "2", "3", "4", "3", "2"]));
 
-    // Display a box spinner for 1.5 seconds
-    spinner(1.5, SpinnerType::Box);
-    
-    // Display a flip spinner for 2 seconds
-    spinner(2.0, SpinnerType::Flip);
-}
-```
-
-## Reveal Function
-
-Displays a string gradually, revealing one character at a time with a specified time interval between each character.
-
-### Usage
-
-```rust
-use console_utils::reveal;
-fn main() {
-    // Display "Hello World!" with a time interval of 0.1 seconds between each character and a new line after it's finished.
+    // Display "Hello World!" with a time interval of 0.1 seconds between each character
     reveal("Hello World!", 0.1);
+
+    // Clear the current line in the console, so the "Hello World!"
+    clear_line();
 }
 ```
 
-## Output Control and Cursor Movement
-
-The library also provides functions for output control and precise cursor movement:
-
-- `clear_line`
-- `flush`
-- `move_cursor_down`
-- `move_cursor_up`
-- `move_cursor_left`
-- `move_cursor_right`
-- `move_cursor_to`
-
 For more detailed documentation, please refer to the [generated Rust Docs](https://docs.rs/console-utils/latest/console_utils/).

README.md

@@ -0,0 +1,141 @@
+//! Control Utilities
+//!
+//! This module provides functions for controlling the console, including flushing the output buffer,
+//! clearing lines, and moving the cursor in various directions.
+use std::io::{self, Write};
+
+/// Flushes the output buffer, ensuring that all content is written to the console.
+///
+/// # Example
+///
+/// ```rust
+/// use console_utils::control::flush;
+///
+/// // Flush the output buffer to ensure content is displayed immediately
+/// flush();
+/// ```
+pub fn flush() {
+    io::stdout().flush().unwrap();
+}
+
+/// Clears the current line in the console.
+///
+/// This function uses ANSI escape codes to clear the entire line and move the cursor to the
+/// beginning of the line.
+///
+/// # Example
+///
+/// ```rust
+/// use console_utils::control::clear_line;
+///
+/// // Clear the current line
+/// clear_line();
+/// ```
+pub fn clear_line() {
+    print!("\r\x1b[2K");
+    flush();
+}
+
+/// Moves the cursor down by the specified number of lines.
+///
+/// # Arguments
+///
+/// * `n` - The number of lines to move the cursor down.
+///
+/// # Example
+///
+/// ```rust
+/// use console_utils::control::move_cursor_down;
+///
+/// // Move the cursor down by 2 lines
+/// move_cursor_down(2);
+/// ```
+pub fn move_cursor_down(n: usize) {
+    if n > 0 {
+        print!("\x1b[{}B", n);
+        flush();
+    }
+}
+
+/// Moves the cursor up by the specified number of lines.
+///
+/// # Arguments
+///
+/// * `n` - The number of lines to move the cursor up.
+///
+/// # Example
+///
+/// ```rust
+/// use console_utils::control::move_cursor_up;
+///
+/// // Move the cursor up by 3 lines
+/// move_cursor_up(3);
+/// ```
+pub fn move_cursor_up(n: usize) {
+    if n > 0 {
+        print!("\x1b[{}A", n);
+        flush();
+    }
+}
+
+/// Moves the cursor to the left by the specified number of characters.
+///
+/// # Arguments
+///
+/// * `n` - The number of characters to move the cursor to the left.
+///
+/// # Example
+///
+/// ```rust
+/// use console_utils::control::move_cursor_left;
+///
+/// // Move the cursor left by 4 characters
+/// move_cursor_left(4);
+/// ```
+pub fn move_cursor_left(n: usize) {
+    if n > 0 {
+        print!("\x1b[{}D", n);
+        flush();
+    }
+}
+
+/// Moves the cursor to the right by the specified number of characters.
+///
+/// # Arguments
+///
+/// * `n` - The number of characters to move the cursor to the right.
+///
+/// # Example
+///
+/// ```rust
+/// use console_utils::control::move_cursor_right;
+///
+/// // Move the cursor right by 5 characters
+/// move_cursor_right(5);
+/// ```
+pub fn move_cursor_right(n: usize) {
+    if n > 0 {
+        print!("\x1b[{}C", n);
+        flush();
+    }
+}
+
+/// Moves the cursor to the specified position on the console.
+///
+/// # Arguments
+///
+/// * `x` - The horizontal position (column) to move the cursor to.
+/// * `y` - The vertical position (row) to move the cursor to.
+///
+/// # Example
+///
+/// ```rust
+/// use console_utils::control::move_cursor_to;
+///
+/// // Move the cursor to column 3, row 5
+/// move_cursor_to(3, 5);
+/// ```
+pub fn move_cursor_to(x: usize, y: usize) {
+    print!("\x1B[{};{}H", y + 1, x + 1);
+    flush();
+}