From 0a95bae451c1847f4f0b9601e60959f4e8e6b669 Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Thu, 12 Mar 2026 14:28:08 +0800 Subject: Refactor display utilities --- utils/src/display.rs | 490 +------------------------------ utils/src/display/colorful.rs | 275 +++++++++++++++++ utils/src/display/table.rs | 143 +++++++++ utils/src/env.rs | 107 ------- utils/src/fs.rs | 40 --- utils/src/globber.rs | 279 ------------------ utils/src/input.rs | 151 ---------- utils/src/lazy_macros.rs | 14 - utils/src/legacy.rs | 9 + utils/src/legacy/display.rs | 488 ++++++++++++++++++++++++++++++ utils/src/legacy/env.rs | 107 +++++++ utils/src/legacy/fs.rs | 40 +++ utils/src/legacy/globber.rs | 279 ++++++++++++++++++ utils/src/legacy/input.rs | 151 ++++++++++ utils/src/legacy/levenshtein_distance.rs | 34 +++ utils/src/legacy/logger.rs | 86 ++++++ utils/src/legacy/push_version.rs | 30 ++ utils/src/legacy/socket_addr_helper.rs | 194 ++++++++++++ utils/src/levenshtein_distance.rs | 34 --- utils/src/lib.rs | 14 +- utils/src/logger.rs | 86 ------ utils/src/macros.rs | 14 + utils/src/math.rs | 1 + utils/src/math/levenshtein_distance.rs | 38 +++ utils/src/push_version.rs | 30 -- utils/src/socket_addr_helper.rs | 194 ------------ 26 files changed, 1896 insertions(+), 1432 deletions(-) create mode 100644 utils/src/display/colorful.rs create mode 100644 utils/src/display/table.rs delete mode 100644 utils/src/env.rs delete mode 100644 utils/src/fs.rs delete mode 100644 utils/src/globber.rs delete mode 100644 utils/src/input.rs delete mode 100644 utils/src/lazy_macros.rs create mode 100644 utils/src/legacy.rs create mode 100644 utils/src/legacy/display.rs create mode 100644 utils/src/legacy/env.rs create mode 100644 utils/src/legacy/fs.rs create mode 100644 utils/src/legacy/globber.rs create mode 100644 utils/src/legacy/input.rs create mode 100644 utils/src/legacy/levenshtein_distance.rs create mode 100644 utils/src/legacy/logger.rs create mode 100644 utils/src/legacy/push_version.rs create mode 100644 utils/src/legacy/socket_addr_helper.rs delete mode 100644 utils/src/levenshtein_distance.rs delete mode 100644 utils/src/logger.rs create mode 100644 utils/src/macros.rs create mode 100644 utils/src/math.rs create mode 100644 utils/src/math/levenshtein_distance.rs delete mode 100644 utils/src/push_version.rs delete mode 100644 utils/src/socket_addr_helper.rs (limited to 'utils/src') diff --git a/utils/src/display.rs b/utils/src/display.rs index fc94d90..a9c48e8 100644 --- a/utils/src/display.rs +++ b/utils/src/display.rs @@ -1,488 +1,2 @@ -use colored::*; -use just_enough_vcs::lib::data::sheet::SheetMappingMetadata; -use std::{ - collections::{BTreeMap, HashMap, VecDeque}, - path::PathBuf, -}; - -pub struct SimpleTable { - items: Vec, - line: Vec>, - length: Vec, - padding: usize, -} - -impl SimpleTable { - /// Create a new Table - pub fn new(items: Vec>) -> Self { - Self::new_with_padding(items, 2) - } - - /// Create a new Table with padding - pub fn new_with_padding(items: Vec>, padding: usize) -> Self { - let items: Vec = items.into_iter().map(|v| v.into()).collect(); - let mut length = Vec::with_capacity(items.len()); - - for item in &items { - length.push(display_width(item)); - } - - SimpleTable { - items, - padding, - line: Vec::new(), - length, - } - } - - /// Push a new row of items to the table - pub fn push_item(&mut self, items: Vec>) { - let items: Vec = items.into_iter().map(|v| v.into()).collect(); - - let mut processed_items = Vec::with_capacity(self.items.len()); - - for i in 0..self.items.len() { - if i < items.len() { - processed_items.push(items[i].clone()); - } else { - processed_items.push(String::new()); - } - } - - for (i, d) in processed_items.iter().enumerate() { - let d_len = display_width(d); - if d_len > self.length[i] { - self.length[i] = d_len; - } - } - - self.line.push(processed_items); - } - - /// Insert a new row of items at the specified index - pub fn insert_item(&mut self, index: usize, items: Vec>) { - let items: Vec = items.into_iter().map(|v| v.into()).collect(); - - let mut processed_items = Vec::with_capacity(self.items.len()); - - for i in 0..self.items.len() { - if i < items.len() { - processed_items.push(items[i].clone()); - } else { - processed_items.push(String::new()); - } - } - - for (i, d) in processed_items.iter().enumerate() { - let d_len = display_width(d); - if d_len > self.length[i] { - self.length[i] = d_len; - } - } - - self.line.insert(index, processed_items); - } - - /// Get the current maximum column widths - fn get_column_widths(&self) -> &[usize] { - &self.length - } -} - -impl std::fmt::Display for SimpleTable { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - let column_widths = self.get_column_widths(); - - // Build the header row - let header: Vec = self - .items - .iter() - .enumerate() - .map(|(i, item)| { - let target_width = column_widths[i] + self.padding; - let current_width = display_width(item); - let space_count = target_width - current_width; - let space = " ".repeat(space_count); - let result = format!("{}{}", item, space); - result - }) - .collect(); - writeln!(f, "{}", header.join(""))?; - - // Build each data row - for row in &self.line { - let formatted_row: Vec = row - .iter() - .enumerate() - .map(|(i, cell)| { - let target_width = column_widths[i] + self.padding; - let current_width = display_width(cell); - let space_count = target_width - current_width; - let spaces = " ".repeat(space_count); - let result = format!("{}{}", cell, spaces); - result - }) - .collect(); - writeln!(f, "{}", formatted_row.join(""))?; - } - - Ok(()) - } -} - -pub fn display_width(s: &str) -> usize { - // Filter out ANSI escape sequences before calculating width - let filtered_bytes = strip_ansi_escapes::strip(s); - let filtered_str = match std::str::from_utf8(&filtered_bytes) { - Ok(s) => s, - Err(_) => s, // Fallback to original string if UTF-8 conversion fails - }; - - let mut width = 0; - for c in filtered_str.chars() { - if c.is_ascii() { - width += 1; - } else { - width += 2; - } - } - width -} - -/// Convert byte size to a human-readable string format -/// -/// Automatically selects the appropriate unit (B, KB, MB, GB, TB) based on the byte size -/// and formats it as a string with two decimal places -pub fn size_str(total_size: usize) -> String { - if total_size < 1024 { - format!("{} B", total_size) - } else if total_size < 1024 * 1024 { - format!("{:.2} KB", total_size as f64 / 1024.0) - } else if total_size < 1024 * 1024 * 1024 { - format!("{:.2} MB", total_size as f64 / (1024.0 * 1024.0)) - } else if total_size < 1024 * 1024 * 1024 * 1024 { - format!("{:.2} GB", total_size as f64 / (1024.0 * 1024.0 * 1024.0)) - } else { - format!( - "{:.2} TB", - total_size as f64 / (1024.0 * 1024.0 * 1024.0 * 1024.0) - ) - } -} - -// Convert the Markdown formatted text into a format supported by the command line -pub fn md(text: impl AsRef) -> String { - let text = text.as_ref().trim(); - let mut result = String::new(); - let mut color_stack: VecDeque = VecDeque::new(); - - let mut i = 0; - let chars: Vec = text.chars().collect(); - - while i < chars.len() { - // Check for escape character \ - if chars[i] == '\\' && i + 1 < chars.len() { - let escaped_char = chars[i + 1]; - // Only escape specific characters - if matches!(escaped_char, '*' | '<' | '>' | '`') { - let mut escaped_text = escaped_char.to_string(); - - // Apply current color stack - for color in color_stack.iter().rev() { - escaped_text = apply_color(&escaped_text, color); - } - - result.push_str(&escaped_text); - i += 2; - continue; - } - } - - // Check for color tag start [[color]] - if i + 1 < chars.len() && chars[i] == '[' && chars[i + 1] == '[' { - let mut j = i + 2; - while j < chars.len() - && !(chars[j] == ']' && j + 1 < chars.len() && chars[j + 1] == ']') - { - j += 1; - } - - if j + 1 < chars.len() { - let tag_content: String = chars[i + 2..j].iter().collect(); - - // Check if it's a closing tag [[/]] - if tag_content == "/" { - color_stack.pop_back(); - i = j + 2; - continue; - } - - // It's a color tag - color_stack.push_back(tag_content.clone()); - i = j + 2; - continue; - } - } - - // Check for bold **text** - if i + 1 < chars.len() && chars[i] == '*' && chars[i + 1] == '*' { - let mut j = i + 2; - while j + 1 < chars.len() && !(chars[j] == '*' && chars[j + 1] == '*') { - j += 1; - } - - if j + 1 < chars.len() { - let bold_text: String = chars[i + 2..j].iter().collect(); - let mut formatted_text = bold_text.bold().to_string(); - - // Apply current color stack - for color in color_stack.iter().rev() { - formatted_text = apply_color(&formatted_text, color); - } - - result.push_str(&formatted_text); - i = j + 2; - continue; - } - } - - // Check for italic *text* - if chars[i] == '*' { - let mut j = i + 1; - while j < chars.len() && chars[j] != '*' { - j += 1; - } - - if j < chars.len() { - let italic_text: String = chars[i + 1..j].iter().collect(); - let mut formatted_text = italic_text.italic().to_string(); - - // Apply current color stack - for color in color_stack.iter().rev() { - formatted_text = apply_color(&formatted_text, color); - } - - result.push_str(&formatted_text); - i = j + 1; - continue; - } - } - - // Check for angle-bracketed content - if chars[i] == '<' { - let mut j = i + 1; - while j < chars.len() && chars[j] != '>' { - j += 1; - } - - if j < chars.len() { - // Include the angle brackets in the output - let angle_text: String = chars[i..=j].iter().collect(); - let mut formatted_text = angle_text.cyan().to_string(); - - // Apply current color stack - for color in color_stack.iter().rev() { - formatted_text = apply_color(&formatted_text, color); - } - - result.push_str(&formatted_text); - i = j + 1; - continue; - } - } - - // Check for inline code `text` - if chars[i] == '`' { - let mut j = i + 1; - while j < chars.len() && chars[j] != '`' { - j += 1; - } - - if j < chars.len() { - // Include the backticks in the output - let code_text: String = chars[i..=j].iter().collect(); - let mut formatted_text = code_text.green().to_string(); - - // Apply current color stack - for color in color_stack.iter().rev() { - formatted_text = apply_color(&formatted_text, color); - } - - result.push_str(&formatted_text); - i = j + 1; - continue; - } - } - - // Regular character - let mut current_char = chars[i].to_string(); - - // Apply current color stack - for color in color_stack.iter().rev() { - current_char = apply_color(¤t_char, color); - } - - result.push_str(¤t_char); - i += 1; - } - - result -} - -// Helper function to apply color to text -fn apply_color(text: impl AsRef, color_name: impl AsRef) -> String { - let text = text.as_ref(); - let color_name = color_name.as_ref(); - match color_name { - // Normal colors - "black" => text.black().to_string(), - "red" => text.red().to_string(), - "green" => text.green().to_string(), - "yellow" => text.yellow().to_string(), - "blue" => text.blue().to_string(), - "magenta" => text.magenta().to_string(), - "cyan" => text.cyan().to_string(), - "white" => text.white().to_string(), - "bright_black" => text.bright_black().to_string(), - "bright_red" => text.bright_red().to_string(), - "bright_green" => text.bright_green().to_string(), - "bright_yellow" => text.bright_yellow().to_string(), - "bright_blue" => text.bright_blue().to_string(), - "bright_magenta" => text.bright_magenta().to_string(), - "bright_cyan" => text.bright_cyan().to_string(), - "bright_white" => text.bright_white().to_string(), - - // Short aliases for bright colors - "b_black" => text.bright_black().to_string(), - "b_red" => text.bright_red().to_string(), - "b_green" => text.bright_green().to_string(), - "b_yellow" => text.bright_yellow().to_string(), - "b_blue" => text.bright_blue().to_string(), - "b_magenta" => text.bright_magenta().to_string(), - "b_cyan" => text.bright_cyan().to_string(), - "b_white" => text.bright_white().to_string(), - - // Gray colors using truecolor - "gray" | "grey" => text.truecolor(128, 128, 128).to_string(), - "bright_gray" | "bright_grey" => text.truecolor(192, 192, 192).to_string(), - "b_gray" | "b_grey" => text.truecolor(192, 192, 192).to_string(), - - // Default to white if color not recognized - _ => text.to_string(), - } -} - -/// Render a HashMap of PathBuf to SheetMappingMetadata as a tree string. -pub fn render_share_path_tree(paths: &HashMap) -> String { - if paths.is_empty() { - return String::new(); - } - - // Collect all path components into a tree structure - let mut root = TreeNode::new("".to_string()); - - for (path, metadata) in paths { - let mut current = &mut root; - let components: Vec = path - .components() - .filter_map(|comp| match comp { - std::path::Component::Normal(s) => s.to_str().map(|s| s.to_string()), - _ => None, - }) - .collect(); - - for (i, comp) in components.iter().enumerate() { - let is_leaf = i == components.len() - 1; - let child = current - .children - .entry(comp.clone()) - .or_insert_with(|| TreeNode::new(comp.clone())); - - // If this is the leaf node, store the metadata - if is_leaf { - child.metadata = Some((metadata.id.clone(), metadata.version.clone())); - } - - current = child; - } - } - - // Convert tree to string representation - let mut result = String::new(); - let is_root = true; - let prefix = String::new(); - let last_stack = vec![true]; // Root is always "last" - - add_tree_node_to_string(&root, &mut result, is_root, &prefix, &last_stack); - - result -} - -/// Internal tree node structure for building the path tree -#[derive(Debug)] -struct TreeNode { - name: String, - children: BTreeMap, // Use BTreeMap for sorted output - metadata: Option<(String, String)>, // Store (id, version) for leaf nodes -} - -impl TreeNode { - fn new(name: String) -> Self { - Self { - name, - children: BTreeMap::new(), - metadata: None, - } - } -} - -/// Recursively add tree node to string representation -fn add_tree_node_to_string( - node: &TreeNode, - result: &mut String, - is_root: bool, - prefix: &str, - last_stack: &[bool], -) { - if !is_root { - // Add the tree prefix for this node - for &is_last in &last_stack[1..] { - if is_last { - result.push_str(" "); - } else { - result.push_str("│ "); - } - } - - // Add the connector for this node - if let Some(&is_last) = last_stack.last() { - if is_last { - result.push_str("└── "); - } else { - result.push_str("├── "); - } - } - - // Add node name - result.push_str(&node.name); - - // Add metadata for leaf nodes - if let Some((id, version)) = &node.metadata { - // Truncate id to first 11 characters - let truncated_id = if id.len() > 11 { &id[..11] } else { id }; - result.push_str(&format!(" [{}|{}]", truncated_id, version)); - } - - result.push('\n'); - } - - // Process children - let child_count = node.children.len(); - for (i, (_, child)) in node.children.iter().enumerate() { - let is_last_child = i == child_count - 1; - let mut new_last_stack = last_stack.to_vec(); - new_last_stack.push(is_last_child); - - add_tree_node_to_string(child, result, false, prefix, &new_last_stack); - } -} +pub mod colorful; +pub mod table; diff --git a/utils/src/display/colorful.rs b/utils/src/display/colorful.rs new file mode 100644 index 0000000..7daa6f2 --- /dev/null +++ b/utils/src/display/colorful.rs @@ -0,0 +1,275 @@ +use std::collections::VecDeque; + +use crossterm::style::Stylize; + +/// Trait for adding markdown formatting to strings +pub trait Colorful { + fn colorful(&self) -> String; +} + +impl Colorful for &str { + fn colorful(&self) -> String { + colorful(self) + } +} + +impl Colorful for String { + fn colorful(&self) -> String { + colorful(self) + } +} + +/// Converts a string to colored/formatted text with ANSI escape codes. +/// +/// Supported syntax: +/// - Bold: `**text**` +/// - Italic: `*text*` +/// - Underline: `_text_` +/// - Angle-bracketed content: `` (displayed as cyan) +/// - Inline code: `` `text` `` (displayed as green) +/// - Color tags: `[[color_name]]` and `[[/]]` to close color +/// - Escape characters: `\*`, `\<`, `\>`, `` \` ``, `\_` for literal characters +/// +/// Color tags support the following color names: +/// Color tags support the following color names: +/// +/// | Type | Color Names | +/// |-----------------------|-----------------------------------------------------------------------------| +/// | Standard colors | `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white` | +/// | Bright colors | `bright_black` | +/// | | `bright_red` | +/// | | `bright_green` | +/// | | `bright_yellow` | +/// | | `bright_blue` | +/// | | `bright_magenta` | +/// | | `bright_cyan` | +/// | | `bright_white` | +/// | Bright color shorthands | `b_black` | +/// | | `b_red` | +/// | | `b_green` | +/// | | `b_yellow` | +/// | | `b_blue` | +/// | | `b_magenta` | +/// | | `b_cyan` | +/// | | `b_white` | +/// | Gray colors | `gray`/`grey` | +/// | | `bright_gray`/`bright_grey` | +/// | | `b_gray`/`b_grey` | +/// +/// Color tags can be nested, `[[/]]` will close the most recently opened color tag. +/// +/// # Arguments +/// * `text` - The text to format, can be any type that implements `AsRef` +/// +/// # Returns +/// Returns a `String` containing ANSI escape codes that can display colored/formatted text in ANSI-supported terminals. +/// +/// # Examples +/// ``` +/// use testing::fmt::colorful; +/// +/// let formatted = colorful("Hello **world**!"); +/// println!("{}", formatted); +/// +/// let colored = colorful("[[red]]Red text[[/]] and normal text"); +/// println!("{}", colored); +/// +/// let nested = colorful("[[blue]]Blue [[green]]Green[[/]] Blue[[/]] normal"); +/// println!("{}", nested); +/// ``` +pub fn colorful(text: impl AsRef) -> String { + let text = text.as_ref().trim(); + let mut result = String::new(); + let mut color_stack: VecDeque = VecDeque::new(); + + let chars: Vec = text.chars().collect(); + let mut i = 0; + + while i < chars.len() { + // Check for escape character \ + if chars[i] == '\\' && i + 1 < chars.len() { + let escaped_char = chars[i + 1]; + // Only escape specific characters + if matches!(escaped_char, '*' | '<' | '>' | '`' | '_') { + let mut escaped_text = escaped_char.to_string(); + apply_color_stack(&mut escaped_text, &color_stack); + result.push_str(&escaped_text); + i += 2; + continue; + } + } + + // Check for color tag start [[color]] + if i + 1 < chars.len() && chars[i] == '[' && chars[i + 1] == '[' { + if let Some(end) = find_tag_end(&chars, i) { + let tag_content: String = chars[i + 2..end].iter().collect(); + + // Check if it's a closing tag [[/]] + if tag_content == "/" { + color_stack.pop_back(); + } else { + // It's a color tag + color_stack.push_back(tag_content.clone()); + } + i = end + 2; + continue; + } + } + + // Check for bold **text** + if i + 1 < chars.len() && chars[i] == '*' && chars[i + 1] == '*' { + if let Some(end) = find_matching(&chars, i + 2, "**") { + let bold_text: String = chars[i + 2..end].iter().collect(); + let mut formatted_text = bold_text.bold().to_string(); + apply_color_stack(&mut formatted_text, &color_stack); + result.push_str(&formatted_text); + i = end + 2; + continue; + } + } + + // Check for italic *text* + if chars[i] == '*' { + if let Some(end) = find_matching(&chars, i + 1, "*") { + let italic_text: String = chars[i + 1..end].iter().collect(); + let mut formatted_text = italic_text.italic().to_string(); + apply_color_stack(&mut formatted_text, &color_stack); + result.push_str(&formatted_text); + i = end + 1; + continue; + } + } + + // Check for underline _text_ + if chars[i] == '_' { + if let Some(end) = find_matching(&chars, i + 1, "_") { + let underline_text: String = chars[i + 1..end].iter().collect(); + let mut formatted_text = format!("\x1b[4m{}\x1b[0m", underline_text); + apply_color_stack(&mut formatted_text, &color_stack); + result.push_str(&formatted_text); + i = end + 1; + continue; + } + } + + // Check for angle-bracketed content + if chars[i] == '<' { + if let Some(end) = find_matching(&chars, i + 1, ">") { + // Include the angle brackets in the output + let angle_text: String = chars[i..=end].iter().collect(); + let mut formatted_text = angle_text.cyan().to_string(); + apply_color_stack(&mut formatted_text, &color_stack); + result.push_str(&formatted_text); + i = end + 1; + continue; + } + } + + // Check for inline code `text` + if chars[i] == '`' { + if let Some(end) = find_matching(&chars, i + 1, "`") { + // Include the backticks in the output + let code_text: String = chars[i..=end].iter().collect(); + let mut formatted_text = code_text.green().to_string(); + apply_color_stack(&mut formatted_text, &color_stack); + result.push_str(&formatted_text); + i = end + 1; + continue; + } + } + + // Regular character + let mut current_char = chars[i].to_string(); + apply_color_stack(&mut current_char, &color_stack); + result.push_str(¤t_char); + i += 1; + } + + result +} + +// Helper function to find matching delimiter +fn find_matching(chars: &[char], start: usize, delimiter: &str) -> Option { + let delim_chars: Vec = delimiter.chars().collect(); + let delim_len = delim_chars.len(); + + let mut j = start; + while j < chars.len() { + if delim_len == 1 { + if chars[j] == delim_chars[0] { + return Some(j); + } + } else if j + 1 < chars.len() + && chars[j] == delim_chars[0] + && chars[j + 1] == delim_chars[1] + { + return Some(j); + } + j += 1; + } + None +} + +// Helper function to find color tag end +fn find_tag_end(chars: &[char], start: usize) -> Option { + let mut j = start + 2; + while j + 1 < chars.len() { + if chars[j] == ']' && chars[j + 1] == ']' { + return Some(j); + } + j += 1; + } + None +} + +// Helper function to apply color stack to text +fn apply_color_stack(text: &mut String, color_stack: &VecDeque) { + let mut result = text.clone(); + for color in color_stack.iter().rev() { + result = apply_color(&result, color); + } + *text = result; +} + +// Helper function to apply color to text +fn apply_color(text: impl AsRef, color_name: impl AsRef) -> String { + let text = text.as_ref(); + let color_name = color_name.as_ref(); + match color_name { + // Normal colors + "black" => text.dark_grey().to_string(), + "red" => text.dark_red().to_string(), + "green" => text.dark_green().to_string(), + "yellow" => text.dark_yellow().to_string(), + "blue" => text.dark_blue().to_string(), + "magenta" => text.dark_magenta().to_string(), + "cyan" => text.dark_cyan().to_string(), + "white" => text.white().to_string(), + "bright_black" => text.black().to_string(), + "bright_red" => text.red().to_string(), + "bright_green" => text.green().to_string(), + "bright_yellow" => text.yellow().to_string(), + "bright_blue" => text.blue().to_string(), + "bright_magenta" => text.magenta().to_string(), + "bright_cyan" => text.cyan().to_string(), + "bright_white" => text.white().to_string(), + + // Short aliases for bright colors + "b_black" => text.black().to_string(), + "b_red" => text.red().to_string(), + "b_green" => text.green().to_string(), + "b_yellow" => text.yellow().to_string(), + "b_blue" => text.blue().to_string(), + "b_magenta" => text.magenta().to_string(), + "b_cyan" => text.cyan().to_string(), + "b_white" => text.white().to_string(), + + // Gray colors using truecolor + "gray" | "grey" => text.grey().to_string(), + "bright_gray" | "bright_grey" => text.white().to_string(), + "b_gray" | "b_grey" => text.white().to_string(), + + // Default to white if color not recognized + _ => text.to_string(), + } +} diff --git a/utils/src/display/table.rs b/utils/src/display/table.rs new file mode 100644 index 0000000..ae745d8 --- /dev/null +++ b/utils/src/display/table.rs @@ -0,0 +1,143 @@ +pub struct Table { + items: Vec, + line: Vec>, + length: Vec, + padding: usize, +} + +impl Table { + /// Create a new Table + pub fn new(items: Vec>) -> Self { + Self::new_with_padding(items, 2) + } + + /// Create a new Table with padding + pub fn new_with_padding(items: Vec>, padding: usize) -> Self { + let items: Vec = items.into_iter().map(|v| v.into()).collect(); + let mut length = Vec::with_capacity(items.len()); + + for item in &items { + length.push(display_width(item)); + } + + Table { + items, + padding, + line: Vec::new(), + length, + } + } + + /// Push a new row of items to the table + pub fn push_item(&mut self, items: Vec>) { + let items: Vec = items.into_iter().map(|v| v.into()).collect(); + + let mut processed_items = Vec::with_capacity(self.items.len()); + + for i in 0..self.items.len() { + if i < items.len() { + processed_items.push(items[i].clone()); + } else { + processed_items.push(String::new()); + } + } + + for (i, d) in processed_items.iter().enumerate() { + let d_len = display_width(d); + if d_len > self.length[i] { + self.length[i] = d_len; + } + } + + self.line.push(processed_items); + } + + /// Insert a new row of items at the specified index + pub fn insert_item(&mut self, index: usize, items: Vec>) { + let items: Vec = items.into_iter().map(|v| v.into()).collect(); + + let mut processed_items = Vec::with_capacity(self.items.len()); + + for i in 0..self.items.len() { + if i < items.len() { + processed_items.push(items[i].clone()); + } else { + processed_items.push(String::new()); + } + } + + for (i, d) in processed_items.iter().enumerate() { + let d_len = display_width(d); + if d_len > self.length[i] { + self.length[i] = d_len; + } + } + + self.line.insert(index, processed_items); + } + + /// Get the current maximum column widths + fn get_column_widths(&self) -> &[usize] { + &self.length + } +} + +impl std::fmt::Display for Table { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let column_widths = self.get_column_widths(); + + // Build the header row + let header: Vec = self + .items + .iter() + .enumerate() + .map(|(i, item)| { + let target_width = column_widths[i] + self.padding; + let current_width = display_width(item); + let space_count = target_width - current_width; + let space = " ".repeat(space_count); + let result = format!("{}{}", item, space); + result + }) + .collect(); + writeln!(f, "{}", header.join(""))?; + + // Build each data row + for row in &self.line { + let formatted_row: Vec = row + .iter() + .enumerate() + .map(|(i, cell)| { + let target_width = column_widths[i] + self.padding; + let current_width = display_width(cell); + let space_count = target_width - current_width; + let spaces = " ".repeat(space_count); + let result = format!("{}{}", cell, spaces); + result + }) + .collect(); + writeln!(f, "{}", formatted_row.join(""))?; + } + + Ok(()) + } +} + +pub fn display_width(s: &str) -> usize { + // Filter out ANSI escape sequences before calculating width + let filtered_bytes = strip_ansi_escapes::strip(s); + let filtered_str = match std::str::from_utf8(&filtered_bytes) { + Ok(s) => s, + Err(_) => s, // Fallback to original string if UTF-8 conversion fails + }; + + let mut width = 0; + for c in filtered_str.chars() { + if c.is_ascii() { + width += 1; + } else { + width += 2; + } + } + width +} diff --git a/utils/src/env.rs b/utils/src/env.rs deleted file mode 100644 index 1834cd3..0000000 --- a/utils/src/env.rs +++ /dev/null @@ -1,107 +0,0 @@ -use std::path::PathBuf; - -/// Returns the current locale string based on environment variables. -/// -/// The function checks for locale settings in the following order: -/// 1. JV_LANG environment variable -/// 2. APP_LANG environment variable -/// 3. LANG environment variable (extracts base language before dot and replaces underscores with hyphens) -/// 4. Defaults to "en" if no locale environment variables are found -/// -/// # Returns -/// A String containing the detected locale code -pub fn current_locales() -> String { - if let Ok(lang) = std::env::var("JV_LANG") { - return lang; - } - - if let Ok(lang) = std::env::var("APP_LANG") { - return lang; - } - - if let Ok(lang) = std::env::var("LANG") { - if let Some(base_lang) = lang.split('.').next() { - return base_lang.replace('_', "-"); - } - return lang; - } - - "en".to_string() -} - -/// Checks if auto update is enabled based on environment variables. -/// -/// The function checks the JV_AUTO_UPDATE environment variable and compares -/// its value (after trimming and converting to lowercase) against known -/// positive and negative values. -/// -/// # Returns -/// `true` if the value matches "yes", "y", or "true" -/// `false` if the value matches "no", "n", or "false", or if the variable is not set -pub fn enable_auto_update() -> bool { - if let Ok(auto_update) = std::env::var("JV_AUTO_UPDATE") { - let normalized = auto_update.trim().to_lowercase(); - match normalized.as_str() { - "yes" | "y" | "true" => return true, - "no" | "n" | "false" => return false, - _ => {} - } - } - false -} - -/// Gets the auto update expiration time based on environment variables. -/// -/// The function checks the JV_OUTDATED_MINUTES environment variable. -/// Requires JV_AUTO_UPDATE to be enabled. -/// Next time the `jv` command is used, if the content is outdated, `jv update` will be automatically executed. -/// -/// # Returns -/// - When the set number is < 0, timeout-based update is disabled -/// - When the set number = 0, update runs every time (not recommended) -/// - When the set number > 0, update according to the specified time -/// - If not set or conversion error occurs, the default is -1 -pub fn auto_update_outdate() -> i64 { - if !enable_auto_update() { - return -1; - } - - match std::env::var("JV_OUTDATED_MINUTES") { - Ok(value) => match value.trim().parse::() { - Ok(num) => num, - Err(_) => -1, - }, - Err(_) => -1, - } -} - -/// Gets the default text editor based on environment variables. -/// -/// The function checks the JV_TEXT_EDITOR and EDITOR environment variables -/// and returns their values if they are set. If neither variable is set, -/// it returns "jvii" as the default editor. -/// -/// # Returns -/// A String containing the default text editor -pub async fn get_default_editor() -> String { - if let Ok(editor) = std::env::var("JV_TEXT_EDITOR") { - return editor; - } - - if let Ok(editor) = std::env::var("EDITOR") { - return editor; - } - - "jvii".to_string() -} - -/// Get temporary file path -pub fn current_tempfile_path(name: &str) -> Option { - dirs::config_local_dir().map(|path| { - if cfg!(target_os = "linux") { - path.join("jvcs").join(".temp").join(name) - } else { - path.join("JustEnoughVCS").join(".temp").join(name) - } - }) -} diff --git a/utils/src/fs.rs b/utils/src/fs.rs deleted file mode 100644 index 0050cf1..0000000 --- a/utils/src/fs.rs +++ /dev/null @@ -1,40 +0,0 @@ -pub async fn move_across_partitions( - source_path: impl AsRef, - dest_path: impl AsRef, -) -> Result<(), std::io::Error> { - let source_path = source_path.as_ref(); - let dest_path = dest_path.as_ref(); - if !source_path.exists() { - return Err(std::io::Error::new( - std::io::ErrorKind::NotFound, - "Source file does not exist", - )); - } - - if let Ok(()) = std::fs::rename(source_path, dest_path) { - return Ok(()); - } - - std::fs::copy(source_path, dest_path)?; - std::fs::remove_file(source_path)?; - - Ok(()) -} - -pub async fn copy_across_partitions( - source_path: impl AsRef, - dest_path: impl AsRef, -) -> Result<(), std::io::Error> { - let source_path = source_path.as_ref(); - let dest_path = dest_path.as_ref(); - if !source_path.exists() { - return Err(std::io::Error::new( - std::io::ErrorKind::NotFound, - "Source file does not exist", - )); - } - - std::fs::copy(source_path, dest_path)?; - - Ok(()) -} diff --git a/utils/src/globber.rs b/utils/src/globber.rs deleted file mode 100644 index 7021898..0000000 --- a/utils/src/globber.rs +++ /dev/null @@ -1,279 +0,0 @@ -use std::{io::Error, path::PathBuf, str::FromStr}; - -use just_fmt::fmt_path::fmt_path_str; - -use crate::globber::constants::{SPLIT_STR, get_base_dir_current}; - -pub struct Globber { - pattern: String, - base: PathBuf, - names: Vec, -} - -#[allow(dead_code)] -impl Globber { - pub fn new(pattern: String, base: PathBuf) -> Self { - Self { - pattern, - base, - names: Vec::new(), - } - } - - pub fn names(&self) -> Vec<&String> { - self.names.iter().collect() - } - - pub fn base(&self) -> &PathBuf { - &self.base - } - - pub fn into_names(self) -> Vec { - self.names - } - - pub fn paths(&self) -> Vec { - self.names.iter().map(|n| self.base.join(n)).collect() - } - - pub fn glob(mut self, get_names: F) -> Result - where - F: Fn(PathBuf) -> Vec, - { - let full_path = format!("{}{}{}", self.base.display(), SPLIT_STR, self.pattern); - - let (path, pattern) = if let Some(last_split) = full_path.rfind(SPLIT_STR) { - let (path_part, pattern_part) = full_path.split_at(last_split); - let mut path = path_part.to_string(); - if !path.ends_with(SPLIT_STR) { - path.push_str(SPLIT_STR); - } - let Ok(result) = fmt_path_str(&path) else { - return Err(Error::new( - std::io::ErrorKind::InvalidInput, - format!("Invalid path: \"{}\"", &path), - )); - }; - (result, pattern_part[SPLIT_STR.len()..].to_string()) - } else { - (String::default(), full_path) - }; - - self.base = match PathBuf::from_str(&path) { - Ok(r) => r, - Err(_) => { - return Err(Error::new( - std::io::ErrorKind::InvalidInput, - format!("Invalid path: \"{}\"", &path), - )); - } - }; - - let pattern = if pattern.is_empty() { - "*".to_string() - } else if pattern == "." { - "*".to_string() - } else if pattern.ends_with(SPLIT_STR) { - format!("{}*", pattern) - } else { - pattern - }; - - if !pattern.contains('*') && !pattern.contains('?') { - self.names = vec![pattern]; - return Ok(self); - } - - let mut collected = Vec::new(); - - collect_files(&path.into(), "./".to_string(), &mut collected, &get_names); - fn collect_files( - base: &PathBuf, - current: String, - file_names: &mut Vec, - get_names: &F, - ) where - F: Fn(PathBuf) -> Vec, - { - let current_path = if current.is_empty() { - base.clone() - } else { - base.join(¤t) - }; - - let items = get_names(current_path); - for item in items { - match item { - GlobItem::File(file_name) => { - let relative_path = { - fmt_path_str(format!("{}{}{}", current, SPLIT_STR, file_name)) - .unwrap_or_default() - }; - file_names.push(relative_path) - } - GlobItem::Directory(dir_name) => { - let new_current = { - fmt_path_str(format!("{}{}{}", current, SPLIT_STR, dir_name)) - .unwrap_or_default() - }; - collect_files(base, new_current, file_names, get_names); - } - } - } - } - - self.names = collected - .iter() - .filter_map(|name| match_pattern(name, &pattern)) - .collect(); - - Ok(self) - } -} - -fn match_pattern(name: &str, pattern: &str) -> Option { - if pattern.is_empty() { - return None; - } - - let name_chars: Vec = name.chars().collect(); - let pattern_chars: Vec = pattern.chars().collect(); - - let mut name_idx = 0; - let mut pattern_idx = 0; - let mut star_idx = -1; - let mut match_idx = -1; - - while name_idx < name_chars.len() { - if pattern_idx < pattern_chars.len() - && (pattern_chars[pattern_idx] == '?' - || pattern_chars[pattern_idx] == name_chars[name_idx]) - { - name_idx += 1; - pattern_idx += 1; - } else if pattern_idx < pattern_chars.len() && pattern_chars[pattern_idx] == '*' { - star_idx = pattern_idx as i32; - match_idx = name_idx as i32; - pattern_idx += 1; - } else if star_idx != -1 { - pattern_idx = (star_idx + 1) as usize; - match_idx += 1; - name_idx = match_idx as usize; - } else { - return None; - } - } - - while pattern_idx < pattern_chars.len() && pattern_chars[pattern_idx] == '*' { - pattern_idx += 1; - } - - if pattern_idx == pattern_chars.len() { - Some(name.to_string()) - } else { - None - } -} - -impl> From for Globber { - fn from(pattern: T) -> Self { - let (base_dir, pattern) = get_base_dir_current(pattern.as_ref().to_string()); - Self::new(pattern, base_dir) - } -} - -#[derive(Debug, Clone, Hash)] -pub enum GlobItem { - File(String), - Directory(String), -} - -impl PartialEq for GlobItem { - fn eq(&self, other: &Self) -> bool { - match (self, other) { - (GlobItem::File(a), GlobItem::File(b)) => a == b, - (GlobItem::Directory(a), GlobItem::Directory(b)) => a == b, - _ => false, - } - } -} - -impl std::fmt::Display for GlobItem { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - GlobItem::File(name) => write!(f, "{}", name), - GlobItem::Directory(name) => write!(f, "{}", name), - } - } -} - -impl Eq for GlobItem {} - -pub mod constants { - use std::{env::current_dir, path::PathBuf}; - - #[cfg(unix)] - pub(crate) const CURRENT_DIR_PREFIX: &str = "./"; - #[cfg(windows)] - pub(crate) const CURRENT_DIR_PREFIX: &str = ".\\"; - - #[cfg(unix)] - pub(crate) const USER_DIR_PREFIX: &str = "~"; - #[cfg(windows)] - pub(crate) const USER_DIR_PREFIX: &str = "~\\"; - - #[cfg(unix)] - pub(crate) const ROOT_DIR_PREFIX: &str = "/"; - #[cfg(windows)] - pub(crate) const ROOT_DIR_PREFIX: &str = "\\"; - - #[cfg(unix)] - pub(crate) const SPLIT_STR: &str = "/"; - #[cfg(windows)] - pub(crate) const SPLIT_STR: &str = "\\"; - - pub fn get_base_dir_current(input: String) -> (PathBuf, String) { - get_base_dir(input, current_dir().unwrap_or_default()) - } - - pub fn get_base_dir(input: String, current_dir: PathBuf) -> (PathBuf, String) { - if let Some(remaining) = input.strip_prefix(CURRENT_DIR_PREFIX) { - (current_dir, remaining.to_string()) - } else if let Some(remaining) = input.strip_prefix(USER_DIR_PREFIX) { - (dirs::home_dir().unwrap_or_default(), remaining.to_string()) - } else if let Some(remaining) = input.strip_prefix(ROOT_DIR_PREFIX) { - { - #[cfg(unix)] - { - (PathBuf::from(ROOT_DIR_PREFIX), remaining.to_string()) - } - #[cfg(windows)] - { - let current_drive = current_dir - .components() - .find_map(|comp| { - if let std::path::Component::Prefix(prefix_component) = comp { - Some(prefix_component) - } else { - None - } - }) - .and_then(|prefix_component| match prefix_component.kind() { - std::path::Prefix::Disk(drive_letter) - | std::path::Prefix::VerbatimDisk(drive_letter) => { - Some((drive_letter as char).to_string()) - } - _ => None, - }) - .unwrap_or_else(|| "C".to_string()); - ( - PathBuf::from(format!("{}:{}", current_drive, ROOT_DIR_PREFIX)), - remaining.to_string(), - ) - } - } - } else { - (current_dir, input) - } - } -} diff --git a/utils/src/input.rs b/utils/src/input.rs deleted file mode 100644 index bc67d90..0000000 --- a/utils/src/input.rs +++ /dev/null @@ -1,151 +0,0 @@ -use tokio::{fs, process::Command}; - -use crate::env::get_default_editor; - -/// Confirm the current operation -/// Waits for user input of 'y' or 'n' -pub async fn confirm_hint(text: impl Into) -> bool { - use tokio::io::{self, AsyncBufReadExt, AsyncWriteExt, BufReader}; - - let prompt = text.into().trim().to_string(); - - let mut stdout = io::stdout(); - let mut stdin = BufReader::new(io::stdin()); - - stdout - .write_all(prompt.as_bytes()) - .await - .expect("Failed to write prompt"); - stdout.flush().await.expect("Failed to flush stdout"); - - let mut input = String::new(); - stdin - .read_line(&mut input) - .await - .expect("Failed to read input"); - - input.trim().eq_ignore_ascii_case("y") -} - -/// Confirm the current operation, or execute a closure if rejected -/// Waits for user input of 'y' or 'n' -/// If 'n' is entered, executes the provided closure and returns false -pub async fn confirm_hint_or(text: impl Into, on_reject: F) -> bool -where - F: FnOnce(), -{ - let confirmed = confirm_hint(text).await; - if !confirmed { - on_reject(); - } - confirmed -} - -/// Confirm the current operation, and execute a closure if confirmed -/// Waits for user input of 'y' or 'n' -/// If 'y' is entered, executes the provided closure and returns true -pub async fn confirm_hint_then(text: impl Into, on_confirm: F) -> bool -where - F: FnOnce(), -{ - let confirmed = confirm_hint(text).await; - if confirmed { - on_confirm(); - } - confirmed -} - -/// Input text using the system editor -/// Opens the system editor (from EDITOR environment variable) with default text in a cache file, -/// then reads back the modified content after the editor closes, removing comment lines -pub async fn input_with_editor( - default_text: impl AsRef, - cache_file: impl AsRef, - comment_char: impl AsRef, -) -> Result { - input_with_editor_cutsom( - default_text, - cache_file, - comment_char, - get_default_editor().await, - ) - .await -} - -pub async fn input_with_editor_cutsom( - default_text: impl AsRef, - cache_file: impl AsRef, - comment_char: impl AsRef, - editor: String, -) -> Result { - let cache_path = cache_file.as_ref(); - let default_content = default_text.as_ref(); - let comment_prefix = comment_char.as_ref(); - - // Write default text to cache file - fs::write(cache_path, default_content).await?; - - // Open editor with cache file - let status = Command::new(editor).arg(cache_path).status().await?; - - if !status.success() { - return Err(std::io::Error::new( - std::io::ErrorKind::Other, - "Editor exited with non-zero status", - )); - } - - // Read the modified content - let content = fs::read_to_string(cache_path).await?; - - // Remove comment lines and trim - let processed_content: String = content - .lines() - .filter_map(|line| { - let trimmed = line.trim(); - if trimmed.starts_with(comment_prefix) { - None - } else { - Some(line) - } - }) - .collect::>() - .join("\n"); - - // Delete the cache file - let _ = fs::remove_file(cache_path).await; - - Ok(processed_content) -} - -/// Show text using the system pager (less) -/// Opens the system pager (less) with the given text content written to the specified file -/// If less is not found, directly outputs the content to stdout -pub async fn show_in_pager( - content: impl AsRef, - cache_file: impl AsRef, -) -> Result<(), std::io::Error> { - let content_str = content.as_ref(); - let cache_path = cache_file.as_ref(); - - // Write content to cache file - fs::write(cache_path, content_str).await?; - - // Try to use less first - let status = Command::new("less").arg(cache_path).status().await; - - match status { - Ok(status) if status.success() => Ok(()), - _ => { - // If less failed, output directly to stdout - use tokio::io::{self, AsyncWriteExt}; - let mut stdout = io::stdout(); - stdout - .write_all(content_str.as_bytes()) - .await - .expect("Failed to write content"); - stdout.flush().await.expect("Failed to flush stdout"); - Ok(()) - } - } -} diff --git a/utils/src/lazy_macros.rs b/utils/src/lazy_macros.rs deleted file mode 100644 index f1cb75e..0000000 --- a/utils/src/lazy_macros.rs +++ /dev/null @@ -1,14 +0,0 @@ -/// A macro for creating a `Vec` from string literals. -/// -/// # Examples -/// ``` -/// # use cli_utils::string_vec; -/// let v = string_vec!["hello", "world"]; -/// assert_eq!(v, vec!["hello".to_string(), "world".to_string()]); -/// ``` -#[macro_export] -macro_rules! string_vec { - ($($elem:expr),* $(,)?) => { - vec![$($elem.to_string()),*] - }; -} diff --git a/utils/src/legacy.rs b/utils/src/legacy.rs new file mode 100644 index 0000000..682c679 --- /dev/null +++ b/utils/src/legacy.rs @@ -0,0 +1,9 @@ +pub mod display; +pub mod env; +pub mod fs; +pub mod globber; +pub mod input; +pub mod levenshtein_distance; +pub mod logger; +pub mod push_version; +pub mod socket_addr_helper; diff --git a/utils/src/legacy/display.rs b/utils/src/legacy/display.rs new file mode 100644 index 0000000..fc94d90 --- /dev/null +++ b/utils/src/legacy/display.rs @@ -0,0 +1,488 @@ +use colored::*; +use just_enough_vcs::lib::data::sheet::SheetMappingMetadata; +use std::{ + collections::{BTreeMap, HashMap, VecDeque}, + path::PathBuf, +}; + +pub struct SimpleTable { + items: Vec, + line: Vec>, + length: Vec, + padding: usize, +} + +impl SimpleTable { + /// Create a new Table + pub fn new(items: Vec>) -> Self { + Self::new_with_padding(items, 2) + } + + /// Create a new Table with padding + pub fn new_with_padding(items: Vec>, padding: usize) -> Self { + let items: Vec = items.into_iter().map(|v| v.into()).collect(); + let mut length = Vec::with_capacity(items.len()); + + for item in &items { + length.push(display_width(item)); + } + + SimpleTable { + items, + padding, + line: Vec::new(), + length, + } + } + + /// Push a new row of items to the table + pub fn push_item(&mut self, items: Vec>) { + let items: Vec = items.into_iter().map(|v| v.into()).collect(); + + let mut processed_items = Vec::with_capacity(self.items.len()); + + for i in 0..self.items.len() { + if i < items.len() { + processed_items.push(items[i].clone()); + } else { + processed_items.push(String::new()); + } + } + + for (i, d) in processed_items.iter().enumerate() { + let d_len = display_width(d); + if d_len > self.length[i] { + self.length[i] = d_len; + } + } + + self.line.push(processed_items); + } + + /// Insert a new row of items at the specified index + pub fn insert_item(&mut self, index: usize, items: Vec>) { + let items: Vec = items.into_iter().map(|v| v.into()).collect(); + + let mut processed_items = Vec::with_capacity(self.items.len()); + + for i in 0..self.items.len() { + if i < items.len() { + processed_items.push(items[i].clone()); + } else { + processed_items.push(String::new()); + } + } + + for (i, d) in processed_items.iter().enumerate() { + let d_len = display_width(d); + if d_len > self.length[i] { + self.length[i] = d_len; + } + } + + self.line.insert(index, processed_items); + } + + /// Get the current maximum column widths + fn get_column_widths(&self) -> &[usize] { + &self.length + } +} + +impl std::fmt::Display for SimpleTable { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let column_widths = self.get_column_widths(); + + // Build the header row + let header: Vec = self + .items + .iter() + .enumerate() + .map(|(i, item)| { + let target_width = column_widths[i] + self.padding; + let current_width = display_width(item); + let space_count = target_width - current_width; + let space = " ".repeat(space_count); + let result = format!("{}{}", item, space); + result + }) + .collect(); + writeln!(f, "{}", header.join(""))?; + + // Build each data row + for row in &self.line { + let formatted_row: Vec = row + .iter() + .enumerate() + .map(|(i, cell)| { + let target_width = column_widths[i] + self.padding; + let current_width = display_width(cell); + let space_count = target_width - current_width; + let spaces = " ".repeat(space_count); + let result = format!("{}{}", cell, spaces); + result + }) + .collect(); + writeln!(f, "{}", formatted_row.join(""))?; + } + + Ok(()) + } +} + +pub fn display_width(s: &str) -> usize { + // Filter out ANSI escape sequences before calculating width + let filtered_bytes = strip_ansi_escapes::strip(s); + let filtered_str = match std::str::from_utf8(&filtered_bytes) { + Ok(s) => s, + Err(_) => s, // Fallback to original string if UTF-8 conversion fails + }; + + let mut width = 0; + for c in filtered_str.chars() { + if c.is_ascii() { + width += 1; + } else { + width += 2; + } + } + width +} + +/// Convert byte size to a human-readable string format +/// +/// Automatically selects the appropriate unit (B, KB, MB, GB, TB) based on the byte size +/// and formats it as a string with two decimal places +pub fn size_str(total_size: usize) -> String { + if total_size < 1024 { + format!("{} B", total_size) + } else if total_size < 1024 * 1024 { + format!("{:.2} KB", total_size as f64 / 1024.0) + } else if total_size < 1024 * 1024 * 1024 { + format!("{:.2} MB", total_size as f64 / (1024.0 * 1024.0)) + } else if total_size < 1024 * 1024 * 1024 * 1024 { + format!("{:.2} GB", total_size as f64 / (1024.0 * 1024.0 * 1024.0)) + } else { + format!( + "{:.2} TB", + total_size as f64 / (1024.0 * 1024.0 * 1024.0 * 1024.0) + ) + } +} + +// Convert the Markdown formatted text into a format supported by the command line +pub fn md(text: impl AsRef) -> String { + let text = text.as_ref().trim(); + let mut result = String::new(); + let mut color_stack: VecDeque = VecDeque::new(); + + let mut i = 0; + let chars: Vec = text.chars().collect(); + + while i < chars.len() { + // Check for escape character \ + if chars[i] == '\\' && i + 1 < chars.len() { + let escaped_char = chars[i + 1]; + // Only escape specific characters + if matches!(escaped_char, '*' | '<' | '>' | '`') { + let mut escaped_text = escaped_char.to_string(); + + // Apply current color stack + for color in color_stack.iter().rev() { + escaped_text = apply_color(&escaped_text, color); + } + + result.push_str(&escaped_text); + i += 2; + continue; + } + } + + // Check for color tag start [[color]] + if i + 1 < chars.len() && chars[i] == '[' && chars[i + 1] == '[' { + let mut j = i + 2; + while j < chars.len() + && !(chars[j] == ']' && j + 1 < chars.len() && chars[j + 1] == ']') + { + j += 1; + } + + if j + 1 < chars.len() { + let tag_content: String = chars[i + 2..j].iter().collect(); + + // Check if it's a closing tag [[/]] + if tag_content == "/" { + color_stack.pop_back(); + i = j + 2; + continue; + } + + // It's a color tag + color_stack.push_back(tag_content.clone()); + i = j + 2; + continue; + } + } + + // Check for bold **text** + if i + 1 < chars.len() && chars[i] == '*' && chars[i + 1] == '*' { + let mut j = i + 2; + while j + 1 < chars.len() && !(chars[j] == '*' && chars[j + 1] == '*') { + j += 1; + } + + if j + 1 < chars.len() { + let bold_text: String = chars[i + 2..j].iter().collect(); + let mut formatted_text = bold_text.bold().to_string(); + + // Apply current color stack + for color in color_stack.iter().rev() { + formatted_text = apply_color(&formatted_text, color); + } + + result.push_str(&formatted_text); + i = j + 2; + continue; + } + } + + // Check for italic *text* + if chars[i] == '*' { + let mut j = i + 1; + while j < chars.len() && chars[j] != '*' { + j += 1; + } + + if j < chars.len() { + let italic_text: String = chars[i + 1..j].iter().collect(); + let mut formatted_text = italic_text.italic().to_string(); + + // Apply current color stack + for color in color_stack.iter().rev() { + formatted_text = apply_color(&formatted_text, color); + } + + result.push_str(&formatted_text); + i = j + 1; + continue; + } + } + + // Check for angle-bracketed content + if chars[i] == '<' { + let mut j = i + 1; + while j < chars.len() && chars[j] != '>' { + j += 1; + } + + if j < chars.len() { + // Include the angle brackets in the output + let angle_text: String = chars[i..=j].iter().collect(); + let mut formatted_text = angle_text.cyan().to_string(); + + // Apply current color stack + for color in color_stack.iter().rev() { + formatted_text = apply_color(&formatted_text, color); + } + + result.push_str(&formatted_text); + i = j + 1; + continue; + } + } + + // Check for inline code `text` + if chars[i] == '`' { + let mut j = i + 1; + while j < chars.len() && chars[j] != '`' { + j += 1; + } + + if j < chars.len() { + // Include the backticks in the output + let code_text: String = chars[i..=j].iter().collect(); + let mut formatted_text = code_text.green().to_string(); + + // Apply current color stack + for color in color_stack.iter().rev() { + formatted_text = apply_color(&formatted_text, color); + } + + result.push_str(&formatted_text); + i = j + 1; + continue; + } + } + + // Regular character + let mut current_char = chars[i].to_string(); + + // Apply current color stack + for color in color_stack.iter().rev() { + current_char = apply_color(¤t_char, color); + } + + result.push_str(¤t_char); + i += 1; + } + + result +} + +// Helper function to apply color to text +fn apply_color(text: impl AsRef, color_name: impl AsRef) -> String { + let text = text.as_ref(); + let color_name = color_name.as_ref(); + match color_name { + // Normal colors + "black" => text.black().to_string(), + "red" => text.red().to_string(), + "green" => text.green().to_string(), + "yellow" => text.yellow().to_string(), + "blue" => text.blue().to_string(), + "magenta" => text.magenta().to_string(), + "cyan" => text.cyan().to_string(), + "white" => text.white().to_string(), + "bright_black" => text.bright_black().to_string(), + "bright_red" => text.bright_red().to_string(), + "bright_green" => text.bright_green().to_string(), + "bright_yellow" => text.bright_yellow().to_string(), + "bright_blue" => text.bright_blue().to_string(), + "bright_magenta" => text.bright_magenta().to_string(), + "bright_cyan" => text.bright_cyan().to_string(), + "bright_white" => text.bright_white().to_string(), + + // Short aliases for bright colors + "b_black" => text.bright_black().to_string(), + "b_red" => text.bright_red().to_string(), + "b_green" => text.bright_green().to_string(), + "b_yellow" => text.bright_yellow().to_string(), + "b_blue" => text.bright_blue().to_string(), + "b_magenta" => text.bright_magenta().to_string(), + "b_cyan" => text.bright_cyan().to_string(), + "b_white" => text.bright_white().to_string(), + + // Gray colors using truecolor + "gray" | "grey" => text.truecolor(128, 128, 128).to_string(), + "bright_gray" | "bright_grey" => text.truecolor(192, 192, 192).to_string(), + "b_gray" | "b_grey" => text.truecolor(192, 192, 192).to_string(), + + // Default to white if color not recognized + _ => text.to_string(), + } +} + +/// Render a HashMap of PathBuf to SheetMappingMetadata as a tree string. +pub fn render_share_path_tree(paths: &HashMap) -> String { + if paths.is_empty() { + return String::new(); + } + + // Collect all path components into a tree structure + let mut root = TreeNode::new("".to_string()); + + for (path, metadata) in paths { + let mut current = &mut root; + let components: Vec = path + .components() + .filter_map(|comp| match comp { + std::path::Component::Normal(s) => s.to_str().map(|s| s.to_string()), + _ => None, + }) + .collect(); + + for (i, comp) in components.iter().enumerate() { + let is_leaf = i == components.len() - 1; + let child = current + .children + .entry(comp.clone()) + .or_insert_with(|| TreeNode::new(comp.clone())); + + // If this is the leaf node, store the metadata + if is_leaf { + child.metadata = Some((metadata.id.clone(), metadata.version.clone())); + } + + current = child; + } + } + + // Convert tree to string representation + let mut result = String::new(); + let is_root = true; + let prefix = String::new(); + let last_stack = vec![true]; // Root is always "last" + + add_tree_node_to_string(&root, &mut result, is_root, &prefix, &last_stack); + + result +} + +/// Internal tree node structure for building the path tree +#[derive(Debug)] +struct TreeNode { + name: String, + children: BTreeMap, // Use BTreeMap for sorted output + metadata: Option<(String, String)>, // Store (id, version) for leaf nodes +} + +impl TreeNode { + fn new(name: String) -> Self { + Self { + name, + children: BTreeMap::new(), + metadata: None, + } + } +} + +/// Recursively add tree node to string representation +fn add_tree_node_to_string( + node: &TreeNode, + result: &mut String, + is_root: bool, + prefix: &str, + last_stack: &[bool], +) { + if !is_root { + // Add the tree prefix for this node + for &is_last in &last_stack[1..] { + if is_last { + result.push_str(" "); + } else { + result.push_str("│ "); + } + } + + // Add the connector for this node + if let Some(&is_last) = last_stack.last() { + if is_last { + result.push_str("└── "); + } else { + result.push_str("├── "); + } + } + + // Add node name + result.push_str(&node.name); + + // Add metadata for leaf nodes + if let Some((id, version)) = &node.metadata { + // Truncate id to first 11 characters + let truncated_id = if id.len() > 11 { &id[..11] } else { id }; + result.push_str(&format!(" [{}|{}]", truncated_id, version)); + } + + result.push('\n'); + } + + // Process children + let child_count = node.children.len(); + for (i, (_, child)) in node.children.iter().enumerate() { + let is_last_child = i == child_count - 1; + let mut new_last_stack = last_stack.to_vec(); + new_last_stack.push(is_last_child); + + add_tree_node_to_string(child, result, false, prefix, &new_last_stack); + } +} diff --git a/utils/src/legacy/env.rs b/utils/src/legacy/env.rs new file mode 100644 index 0000000..1834cd3 --- /dev/null +++ b/utils/src/legacy/env.rs @@ -0,0 +1,107 @@ +use std::path::PathBuf; + +/// Returns the current locale string based on environment variables. +/// +/// The function checks for locale settings in the following order: +/// 1. JV_LANG environment variable +/// 2. APP_LANG environment variable +/// 3. LANG environment variable (extracts base language before dot and replaces underscores with hyphens) +/// 4. Defaults to "en" if no locale environment variables are found +/// +/// # Returns +/// A String containing the detected locale code +pub fn current_locales() -> String { + if let Ok(lang) = std::env::var("JV_LANG") { + return lang; + } + + if let Ok(lang) = std::env::var("APP_LANG") { + return lang; + } + + if let Ok(lang) = std::env::var("LANG") { + if let Some(base_lang) = lang.split('.').next() { + return base_lang.replace('_', "-"); + } + return lang; + } + + "en".to_string() +} + +/// Checks if auto update is enabled based on environment variables. +/// +/// The function checks the JV_AUTO_UPDATE environment variable and compares +/// its value (after trimming and converting to lowercase) against known +/// positive and negative values. +/// +/// # Returns +/// `true` if the value matches "yes", "y", or "true" +/// `false` if the value matches "no", "n", or "false", or if the variable is not set +pub fn enable_auto_update() -> bool { + if let Ok(auto_update) = std::env::var("JV_AUTO_UPDATE") { + let normalized = auto_update.trim().to_lowercase(); + match normalized.as_str() { + "yes" | "y" | "true" => return true, + "no" | "n" | "false" => return false, + _ => {} + } + } + false +} + +/// Gets the auto update expiration time based on environment variables. +/// +/// The function checks the JV_OUTDATED_MINUTES environment variable. +/// Requires JV_AUTO_UPDATE to be enabled. +/// Next time the `jv` command is used, if the content is outdated, `jv update` will be automatically executed. +/// +/// # Returns +/// - When the set number is < 0, timeout-based update is disabled +/// - When the set number = 0, update runs every time (not recommended) +/// - When the set number > 0, update according to the specified time +/// - If not set or conversion error occurs, the default is -1 +pub fn auto_update_outdate() -> i64 { + if !enable_auto_update() { + return -1; + } + + match std::env::var("JV_OUTDATED_MINUTES") { + Ok(value) => match value.trim().parse::() { + Ok(num) => num, + Err(_) => -1, + }, + Err(_) => -1, + } +} + +/// Gets the default text editor based on environment variables. +/// +/// The function checks the JV_TEXT_EDITOR and EDITOR environment variables +/// and returns their values if they are set. If neither variable is set, +/// it returns "jvii" as the default editor. +/// +/// # Returns +/// A String containing the default text editor +pub async fn get_default_editor() -> String { + if let Ok(editor) = std::env::var("JV_TEXT_EDITOR") { + return editor; + } + + if let Ok(editor) = std::env::var("EDITOR") { + return editor; + } + + "jvii".to_string() +} + +/// Get temporary file path +pub fn current_tempfile_path(name: &str) -> Option { + dirs::config_local_dir().map(|path| { + if cfg!(target_os = "linux") { + path.join("jvcs").join(".temp").join(name) + } else { + path.join("JustEnoughVCS").join(".temp").join(name) + } + }) +} diff --git a/utils/src/legacy/fs.rs b/utils/src/legacy/fs.rs new file mode 100644 index 0000000..0050cf1 --- /dev/null +++ b/utils/src/legacy/fs.rs @@ -0,0 +1,40 @@ +pub async fn move_across_partitions( + source_path: impl AsRef, + dest_path: impl AsRef, +) -> Result<(), std::io::Error> { + let source_path = source_path.as_ref(); + let dest_path = dest_path.as_ref(); + if !source_path.exists() { + return Err(std::io::Error::new( + std::io::ErrorKind::NotFound, + "Source file does not exist", + )); + } + + if let Ok(()) = std::fs::rename(source_path, dest_path) { + return Ok(()); + } + + std::fs::copy(source_path, dest_path)?; + std::fs::remove_file(source_path)?; + + Ok(()) +} + +pub async fn copy_across_partitions( + source_path: impl AsRef, + dest_path: impl AsRef, +) -> Result<(), std::io::Error> { + let source_path = source_path.as_ref(); + let dest_path = dest_path.as_ref(); + if !source_path.exists() { + return Err(std::io::Error::new( + std::io::ErrorKind::NotFound, + "Source file does not exist", + )); + } + + std::fs::copy(source_path, dest_path)?; + + Ok(()) +} diff --git a/utils/src/legacy/globber.rs b/utils/src/legacy/globber.rs new file mode 100644 index 0000000..4d722db --- /dev/null +++ b/utils/src/legacy/globber.rs @@ -0,0 +1,279 @@ +use std::{io::Error, path::PathBuf, str::FromStr}; + +use just_fmt::fmt_path::fmt_path_str; + +use crate::legacy::globber::constants::{SPLIT_STR, get_base_dir_current}; + +pub struct Globber { + pattern: String, + base: PathBuf, + names: Vec, +} + +#[allow(dead_code)] +impl Globber { + pub fn new(pattern: String, base: PathBuf) -> Self { + Self { + pattern, + base, + names: Vec::new(), + } + } + + pub fn names(&self) -> Vec<&String> { + self.names.iter().collect() + } + + pub fn base(&self) -> &PathBuf { + &self.base + } + + pub fn into_names(self) -> Vec { + self.names + } + + pub fn paths(&self) -> Vec { + self.names.iter().map(|n| self.base.join(n)).collect() + } + + pub fn glob(mut self, get_names: F) -> Result + where + F: Fn(PathBuf) -> Vec, + { + let full_path = format!("{}{}{}", self.base.display(), SPLIT_STR, self.pattern); + + let (path, pattern) = if let Some(last_split) = full_path.rfind(SPLIT_STR) { + let (path_part, pattern_part) = full_path.split_at(last_split); + let mut path = path_part.to_string(); + if !path.ends_with(SPLIT_STR) { + path.push_str(SPLIT_STR); + } + let Ok(result) = fmt_path_str(&path) else { + return Err(Error::new( + std::io::ErrorKind::InvalidInput, + format!("Invalid path: \"{}\"", &path), + )); + }; + (result, pattern_part[SPLIT_STR.len()..].to_string()) + } else { + (String::default(), full_path) + }; + + self.base = match PathBuf::from_str(&path) { + Ok(r) => r, + Err(_) => { + return Err(Error::new( + std::io::ErrorKind::InvalidInput, + format!("Invalid path: \"{}\"", &path), + )); + } + }; + + let pattern = if pattern.is_empty() { + "*".to_string() + } else if pattern == "." { + "*".to_string() + } else if pattern.ends_with(SPLIT_STR) { + format!("{}*", pattern) + } else { + pattern + }; + + if !pattern.contains('*') && !pattern.contains('?') { + self.names = vec![pattern]; + return Ok(self); + } + + let mut collected = Vec::new(); + + collect_files(&path.into(), "./".to_string(), &mut collected, &get_names); + fn collect_files( + base: &PathBuf, + current: String, + file_names: &mut Vec, + get_names: &F, + ) where + F: Fn(PathBuf) -> Vec, + { + let current_path = if current.is_empty() { + base.clone() + } else { + base.join(¤t) + }; + + let items = get_names(current_path); + for item in items { + match item { + GlobItem::File(file_name) => { + let relative_path = { + fmt_path_str(format!("{}{}{}", current, SPLIT_STR, file_name)) + .unwrap_or_default() + }; + file_names.push(relative_path) + } + GlobItem::Directory(dir_name) => { + let new_current = { + fmt_path_str(format!("{}{}{}", current, SPLIT_STR, dir_name)) + .unwrap_or_default() + }; + collect_files(base, new_current, file_names, get_names); + } + } + } + } + + self.names = collected + .iter() + .filter_map(|name| match_pattern(name, &pattern)) + .collect(); + + Ok(self) + } +} + +fn match_pattern(name: &str, pattern: &str) -> Option { + if pattern.is_empty() { + return None; + } + + let name_chars: Vec = name.chars().collect(); + let pattern_chars: Vec = pattern.chars().collect(); + + let mut name_idx = 0; + let mut pattern_idx = 0; + let mut star_idx = -1; + let mut match_idx = -1; + + while name_idx < name_chars.len() { + if pattern_idx < pattern_chars.len() + && (pattern_chars[pattern_idx] == '?' + || pattern_chars[pattern_idx] == name_chars[name_idx]) + { + name_idx += 1; + pattern_idx += 1; + } else if pattern_idx < pattern_chars.len() && pattern_chars[pattern_idx] == '*' { + star_idx = pattern_idx as i32; + match_idx = name_idx as i32; + pattern_idx += 1; + } else if star_idx != -1 { + pattern_idx = (star_idx + 1) as usize; + match_idx += 1; + name_idx = match_idx as usize; + } else { + return None; + } + } + + while pattern_idx < pattern_chars.len() && pattern_chars[pattern_idx] == '*' { + pattern_idx += 1; + } + + if pattern_idx == pattern_chars.len() { + Some(name.to_string()) + } else { + None + } +} + +impl> From for Globber { + fn from(pattern: T) -> Self { + let (base_dir, pattern) = get_base_dir_current(pattern.as_ref().to_string()); + Self::new(pattern, base_dir) + } +} + +#[derive(Debug, Clone, Hash)] +pub enum GlobItem { + File(String), + Directory(String), +} + +impl PartialEq for GlobItem { + fn eq(&self, other: &Self) -> bool { + match (self, other) { + (GlobItem::File(a), GlobItem::File(b)) => a == b, + (GlobItem::Directory(a), GlobItem::Directory(b)) => a == b, + _ => false, + } + } +} + +impl std::fmt::Display for GlobItem { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + GlobItem::File(name) => write!(f, "{}", name), + GlobItem::Directory(name) => write!(f, "{}", name), + } + } +} + +impl Eq for GlobItem {} + +pub mod constants { + use std::{env::current_dir, path::PathBuf}; + + #[cfg(unix)] + pub(crate) const CURRENT_DIR_PREFIX: &str = "./"; + #[cfg(windows)] + pub(crate) const CURRENT_DIR_PREFIX: &str = ".\\"; + + #[cfg(unix)] + pub(crate) const USER_DIR_PREFIX: &str = "~"; + #[cfg(windows)] + pub(crate) const USER_DIR_PREFIX: &str = "~\\"; + + #[cfg(unix)] + pub(crate) const ROOT_DIR_PREFIX: &str = "/"; + #[cfg(windows)] + pub(crate) const ROOT_DIR_PREFIX: &str = "\\"; + + #[cfg(unix)] + pub(crate) const SPLIT_STR: &str = "/"; + #[cfg(windows)] + pub(crate) const SPLIT_STR: &str = "\\"; + + pub fn get_base_dir_current(input: String) -> (PathBuf, String) { + get_base_dir(input, current_dir().unwrap_or_default()) + } + + pub fn get_base_dir(input: String, current_dir: PathBuf) -> (PathBuf, String) { + if let Some(remaining) = input.strip_prefix(CURRENT_DIR_PREFIX) { + (current_dir, remaining.to_string()) + } else if let Some(remaining) = input.strip_prefix(USER_DIR_PREFIX) { + (dirs::home_dir().unwrap_or_default(), remaining.to_string()) + } else if let Some(remaining) = input.strip_prefix(ROOT_DIR_PREFIX) { + { + #[cfg(unix)] + { + (PathBuf::from(ROOT_DIR_PREFIX), remaining.to_string()) + } + #[cfg(windows)] + { + let current_drive = current_dir + .components() + .find_map(|comp| { + if let std::path::Component::Prefix(prefix_component) = comp { + Some(prefix_component) + } else { + None + } + }) + .and_then(|prefix_component| match prefix_component.kind() { + std::path::Prefix::Disk(drive_letter) + | std::path::Prefix::VerbatimDisk(drive_letter) => { + Some((drive_letter as char).to_string()) + } + _ => None, + }) + .unwrap_or_else(|| "C".to_string()); + ( + PathBuf::from(format!("{}:{}", current_drive, ROOT_DIR_PREFIX)), + remaining.to_string(), + ) + } + } + } else { + (current_dir, input) + } + } +} diff --git a/utils/src/legacy/input.rs b/utils/src/legacy/input.rs new file mode 100644 index 0000000..95d53cb --- /dev/null +++ b/utils/src/legacy/input.rs @@ -0,0 +1,151 @@ +use tokio::{fs, process::Command}; + +use crate::legacy::env::get_default_editor; + +/// Confirm the current operation +/// Waits for user input of 'y' or 'n' +pub async fn confirm_hint(text: impl Into) -> bool { + use tokio::io::{self, AsyncBufReadExt, AsyncWriteExt, BufReader}; + + let prompt = text.into().trim().to_string(); + + let mut stdout = io::stdout(); + let mut stdin = BufReader::new(io::stdin()); + + stdout + .write_all(prompt.as_bytes()) + .await + .expect("Failed to write prompt"); + stdout.flush().await.expect("Failed to flush stdout"); + + let mut input = String::new(); + stdin + .read_line(&mut input) + .await + .expect("Failed to read input"); + + input.trim().eq_ignore_ascii_case("y") +} + +/// Confirm the current operation, or execute a closure if rejected +/// Waits for user input of 'y' or 'n' +/// If 'n' is entered, executes the provided closure and returns false +pub async fn confirm_hint_or(text: impl Into, on_reject: F) -> bool +where + F: FnOnce(), +{ + let confirmed = confirm_hint(text).await; + if !confirmed { + on_reject(); + } + confirmed +} + +/// Confirm the current operation, and execute a closure if confirmed +/// Waits for user input of 'y' or 'n' +/// If 'y' is entered, executes the provided closure and returns true +pub async fn confirm_hint_then(text: impl Into, on_confirm: F) -> bool +where + F: FnOnce(), +{ + let confirmed = confirm_hint(text).await; + if confirmed { + on_confirm(); + } + confirmed +} + +/// Input text using the system editor +/// Opens the system editor (from EDITOR environment variable) with default text in a cache file, +/// then reads back the modified content after the editor closes, removing comment lines +pub async fn input_with_editor( + default_text: impl AsRef, + cache_file: impl AsRef, + comment_char: impl AsRef, +) -> Result { + input_with_editor_cutsom( + default_text, + cache_file, + comment_char, + get_default_editor().await, + ) + .await +} + +pub async fn input_with_editor_cutsom( + default_text: impl AsRef, + cache_file: impl AsRef, + comment_char: impl AsRef, + editor: String, +) -> Result { + let cache_path = cache_file.as_ref(); + let default_content = default_text.as_ref(); + let comment_prefix = comment_char.as_ref(); + + // Write default text to cache file + fs::write(cache_path, default_content).await?; + + // Open editor with cache file + let status = Command::new(editor).arg(cache_path).status().await?; + + if !status.success() { + return Err(std::io::Error::new( + std::io::ErrorKind::Other, + "Editor exited with non-zero status", + )); + } + + // Read the modified content + let content = fs::read_to_string(cache_path).await?; + + // Remove comment lines and trim + let processed_content: String = content + .lines() + .filter_map(|line| { + let trimmed = line.trim(); + if trimmed.starts_with(comment_prefix) { + None + } else { + Some(line) + } + }) + .collect::>() + .join("\n"); + + // Delete the cache file + let _ = fs::remove_file(cache_path).await; + + Ok(processed_content) +} + +/// Show text using the system pager (less) +/// Opens the system pager (less) with the given text content written to the specified file +/// If less is not found, directly outputs the content to stdout +pub async fn show_in_pager( + content: impl AsRef, + cache_file: impl AsRef, +) -> Result<(), std::io::Error> { + let content_str = content.as_ref(); + let cache_path = cache_file.as_ref(); + + // Write content to cache file + fs::write(cache_path, content_str).await?; + + // Try to use less first + let status = Command::new("less").arg(cache_path).status().await; + + match status { + Ok(status) if status.success() => Ok(()), + _ => { + // If less failed, output directly to stdout + use tokio::io::{self, AsyncWriteExt}; + let mut stdout = io::stdout(); + stdout + .write_all(content_str.as_bytes()) + .await + .expect("Failed to write content"); + stdout.flush().await.expect("Failed to flush stdout"); + Ok(()) + } + } +} diff --git a/utils/src/legacy/levenshtein_distance.rs b/utils/src/legacy/levenshtein_distance.rs new file mode 100644 index 0000000..6bdb7e7 --- /dev/null +++ b/utils/src/legacy/levenshtein_distance.rs @@ -0,0 +1,34 @@ +use std::cmp::min; + +pub fn levenshtein_distance(a: &str, b: &str) -> usize { + let a_chars: Vec = a.chars().collect(); + let b_chars: Vec = b.chars().collect(); + let a_len = a_chars.len(); + let b_len = b_chars.len(); + + if a_len == 0 { + return b_len; + } + if b_len == 0 { + return a_len; + } + + let mut dp = vec![vec![0; b_len + 1]; a_len + 1]; + + for (i, row) in dp.iter_mut().enumerate() { + row[0] = i; + } + + for (j, cell) in dp[0].iter_mut().enumerate() { + *cell = j; + } + + for (i, a_char) in a_chars.iter().enumerate() { + for (j, b_char) in b_chars.iter().enumerate() { + let cost = if a_char == b_char { 0 } else { 1 }; + dp[i + 1][j + 1] = min(dp[i][j + 1] + 1, min(dp[i + 1][j] + 1, dp[i][j] + cost)); + } + } + + dp[a_len][b_len] +} diff --git a/utils/src/legacy/logger.rs b/utils/src/legacy/logger.rs new file mode 100644 index 0000000..1bc96c1 --- /dev/null +++ b/utils/src/legacy/logger.rs @@ -0,0 +1,86 @@ +use std::path::Path; + +use colored::Colorize; +use env_logger::{Builder, Target}; +use just_enough_vcs::lib::data::vault::vault_config::LoggerLevel; +use just_fmt::fmt_path::fmt_path; +use log::{Level, LevelFilter}; + +pub fn build_env_logger(log_path: impl AsRef, logger_level: LoggerLevel) { + use std::io::{self, Write}; + + struct MultiWriter { + a: A, + b: B, + } + + impl MultiWriter { + fn new(a: A, b: B) -> Self { + Self { a, b } + } + } + + impl Write for MultiWriter { + fn write(&mut self, buf: &[u8]) -> io::Result { + let _ = self.a.write(buf); + self.b.write(buf) + } + + fn flush(&mut self) -> io::Result<()> { + let _ = self.a.flush(); + self.b.flush() + } + } + + let log_path = { + let path = log_path.as_ref(); + let Ok(path) = fmt_path(path) else { + eprintln!( + "Build logger failed: {} is not a vaild path.", + path.display() + ); + return; + }; + path + }; + + let mut builder = Builder::new(); + + let log_format = |buf: &mut env_logger::fmt::Formatter, record: &log::Record| { + let now = chrono::Local::now(); + + let level_style = match record.level() { + Level::Error => record.args().to_string().red().bold(), + Level::Warn => record.args().to_string().yellow().bold(), + Level::Info => record.args().to_string().white(), + Level::Debug => record.args().to_string().white(), + Level::Trace => record.args().to_string().cyan(), + }; + + writeln!( + buf, + "{} {}", + now.format("%H:%M:%S") + .to_string() + .truecolor(105, 105, 105) + .bold(), + level_style + ) + }; + + let log_file = std::fs::File::create(log_path).expect("Failed to create log file"); + let combined_target = Target::Pipe(Box::new(MultiWriter::new(std::io::stdout(), log_file))); + + let level = match logger_level { + LoggerLevel::Debug => LevelFilter::Debug, + LoggerLevel::Trace => LevelFilter::Trace, + LoggerLevel::Info => LevelFilter::Info, + }; + + builder + .format(log_format) + .filter(None, level.clone()) + .filter_module("just_enough_vcs", level) + .target(combined_target) + .init(); +} diff --git a/utils/src/legacy/push_version.rs b/utils/src/legacy/push_version.rs new file mode 100644 index 0000000..6da9039 --- /dev/null +++ b/utils/src/legacy/push_version.rs @@ -0,0 +1,30 @@ +pub fn push_version(current_version: impl Into) -> Option { + let version_str = current_version.into(); + let parts: Vec<&str> = version_str.split('.').collect(); + + if parts.len() != 3 { + return None; + } + + let major: Result = parts[0].parse(); + let minor: Result = parts[1].parse(); + let patch: Result = parts[2].parse(); + + if let (Ok(mut major), Ok(mut minor), Ok(mut patch)) = (major, minor, patch) { + patch += 1; + + if patch > 99 { + patch = 0; + minor += 1; + + if minor > 99 { + minor = 0; + major += 1; + } + } + + Some(format!("{}.{}.{}", major, minor, patch)) + } else { + None + } +} diff --git a/utils/src/legacy/socket_addr_helper.rs b/utils/src/legacy/socket_addr_helper.rs new file mode 100644 index 0000000..29ccd9f --- /dev/null +++ b/utils/src/legacy/socket_addr_helper.rs @@ -0,0 +1,194 @@ +use std::net::SocketAddr; +use tokio::net::lookup_host; + +/// Helper function to parse a string into a SocketAddr with optional default port +pub async fn get_socket_addr( + address_str: impl AsRef, + default_port: u16, +) -> Result { + let address = address_str.as_ref().trim(); + + // Return error if input is empty after trimming + if address.is_empty() { + return Err(std::io::Error::new( + std::io::ErrorKind::InvalidInput, + "Empty address string", + )); + } + + // Check if the address contains a port + if let Some((host, port_str)) = parse_host_and_port(address) { + let port = port_str.parse::().map_err(|e| { + std::io::Error::new( + std::io::ErrorKind::InvalidInput, + format!("Invalid port number '{}': {}", port_str, e), + ) + })?; + + return resolve_to_socket_addr(host, port).await; + } + + // No port specified, use default port + resolve_to_socket_addr(address, default_port).await +} + +/// Parse host and port from address string +fn parse_host_and_port(address: &str) -> Option<(&str, &str)> { + if address.starts_with('[') + && let Some(close_bracket) = address.find(']') + && close_bracket + 1 < address.len() + && address.as_bytes()[close_bracket + 1] == b':' + { + let host = &address[1..close_bracket]; + let port = &address[close_bracket + 2..]; + return Some((host, port)); + } + + // Handle IPv4 addresses and hostnames with ports + if let Some(colon_pos) = address.rfind(':') { + // Check if this is not part of an IPv6 address without brackets + if !address.contains('[') && !address.contains(']') { + let host = &address[..colon_pos]; + let port = &address[colon_pos + 1..]; + + // Basic validation to avoid false positives + if !host.is_empty() && !port.is_empty() && port.chars().all(|c| c.is_ascii_digit()) { + return Some((host, port)); + } + } + } + + None +} + +/// Resolve host to SocketAddr, handling both IP addresses and domain names +async fn resolve_to_socket_addr(host: &str, port: u16) -> Result { + // First try to parse as IP address (IPv4 or IPv6) + if let Ok(ip_addr) = host.parse() { + return Ok(SocketAddr::new(ip_addr, port)); + } + + // If it's not a valid IP address, treat it as a domain name and perform DNS lookup + let lookup_addr = format!("{}:{}", host, port); + let mut addrs = lookup_host(&lookup_addr).await?; + + if let Some(addr) = addrs.next() { + Ok(addr) + } else { + Err(std::io::Error::new( + std::io::ErrorKind::NotFound, + format!("Could not resolve host '{}'", host), + )) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn test_ipv4_with_port() { + let result = get_socket_addr("127.0.0.1:8080", 80).await; + assert!(result.is_ok()); + let addr = result.unwrap(); + assert_eq!(addr.port(), 8080); + assert_eq!(addr.ip().to_string(), "127.0.0.1"); + } + + #[tokio::test] + async fn test_ipv4_without_port() { + let result = get_socket_addr("192.168.1.1", 443).await; + assert!(result.is_ok()); + let addr = result.unwrap(); + assert_eq!(addr.port(), 443); + assert_eq!(addr.ip().to_string(), "192.168.1.1"); + } + + #[tokio::test] + async fn test_ipv6_with_port() { + let result = get_socket_addr("[::1]:8080", 80).await; + assert!(result.is_ok()); + let addr = result.unwrap(); + assert_eq!(addr.port(), 8080); + assert_eq!(addr.ip().to_string(), "::1"); + } + + #[tokio::test] + async fn test_ipv6_without_port() { + let result = get_socket_addr("[::1]", 443).await; + assert!(result.is_ok()); + let addr = result.unwrap(); + assert_eq!(addr.port(), 443); + assert_eq!(addr.ip().to_string(), "::1"); + } + + #[tokio::test] + async fn test_invalid_port() { + let result = get_socket_addr("127.0.0.1:99999", 80).await; + assert!(result.is_err()); + } + + #[tokio::test] + async fn test_empty_string() { + let result = get_socket_addr("", 80).await; + assert!(result.is_err()); + } + + #[tokio::test] + async fn test_whitespace_trimming() { + let result = get_socket_addr(" 127.0.0.1:8080 ", 80).await; + assert!(result.is_ok()); + let addr = result.unwrap(); + assert_eq!(addr.port(), 8080); + } + + #[tokio::test] + async fn test_domain_name_with_port() { + // This test will only pass if localhost resolves + let result = get_socket_addr("localhost:8080", 80).await; + if result.is_ok() { + let addr = result.unwrap(); + assert_eq!(addr.port(), 8080); + // localhost should resolve to 127.0.0.1 or ::1 + assert!(addr.ip().is_loopback()); + } + } + + #[tokio::test] + async fn test_domain_name_without_port() { + // This test will only pass if localhost resolves + let result = get_socket_addr("localhost", 443).await; + if result.is_ok() { + let addr = result.unwrap(); + assert_eq!(addr.port(), 443); + // localhost should resolve to 127.0.0.1 or ::1 + assert!(addr.ip().is_loopback()); + } + } + + #[tokio::test] + async fn test_parse_host_and_port() { + // IPv4 with port + assert_eq!( + parse_host_and_port("192.168.1.1:8080"), + Some(("192.168.1.1", "8080")) + ); + + // IPv6 with port + assert_eq!(parse_host_and_port("[::1]:8080"), Some(("::1", "8080"))); + + // Hostname with port + assert_eq!( + parse_host_and_port("example.com:443"), + Some(("example.com", "443")) + ); + + // No port + assert_eq!(parse_host_and_port("192.168.1.1"), None); + assert_eq!(parse_host_and_port("example.com"), None); + + // Invalid cases + assert_eq!(parse_host_and_port(":"), None); + assert_eq!(parse_host_and_port("192.168.1.1:"), None); + } +} diff --git a/utils/src/levenshtein_distance.rs b/utils/src/levenshtein_distance.rs deleted file mode 100644 index 6bdb7e7..0000000 --- a/utils/src/levenshtein_distance.rs +++ /dev/null @@ -1,34 +0,0 @@ -use std::cmp::min; - -pub fn levenshtein_distance(a: &str, b: &str) -> usize { - let a_chars: Vec = a.chars().collect(); - let b_chars: Vec = b.chars().collect(); - let a_len = a_chars.len(); - let b_len = b_chars.len(); - - if a_len == 0 { - return b_len; - } - if b_len == 0 { - return a_len; - } - - let mut dp = vec![vec![0; b_len + 1]; a_len + 1]; - - for (i, row) in dp.iter_mut().enumerate() { - row[0] = i; - } - - for (j, cell) in dp[0].iter_mut().enumerate() { - *cell = j; - } - - for (i, a_char) in a_chars.iter().enumerate() { - for (j, b_char) in b_chars.iter().enumerate() { - let cost = if a_char == b_char { 0 } else { 1 }; - dp[i + 1][j + 1] = min(dp[i][j + 1] + 1, min(dp[i + 1][j] + 1, dp[i][j] + cost)); - } - } - - dp[a_len][b_len] -} diff --git a/utils/src/lib.rs b/utils/src/lib.rs index ef56189..ca2be9c 100644 --- a/utils/src/lib.rs +++ b/utils/src/lib.rs @@ -1,10 +1,6 @@ pub mod display; -pub mod env; -pub mod fs; -pub mod globber; -pub mod input; -pub mod lazy_macros; -pub mod levenshtein_distance; -pub mod logger; -pub mod push_version; -pub mod socket_addr_helper; +pub mod macros; +pub mod math; + +// Legacy +pub mod legacy; diff --git a/utils/src/logger.rs b/utils/src/logger.rs deleted file mode 100644 index 1bc96c1..0000000 --- a/utils/src/logger.rs +++ /dev/null @@ -1,86 +0,0 @@ -use std::path::Path; - -use colored::Colorize; -use env_logger::{Builder, Target}; -use just_enough_vcs::lib::data::vault::vault_config::LoggerLevel; -use just_fmt::fmt_path::fmt_path; -use log::{Level, LevelFilter}; - -pub fn build_env_logger(log_path: impl AsRef, logger_level: LoggerLevel) { - use std::io::{self, Write}; - - struct MultiWriter { - a: A, - b: B, - } - - impl MultiWriter { - fn new(a: A, b: B) -> Self { - Self { a, b } - } - } - - impl Write for MultiWriter { - fn write(&mut self, buf: &[u8]) -> io::Result { - let _ = self.a.write(buf); - self.b.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - let _ = self.a.flush(); - self.b.flush() - } - } - - let log_path = { - let path = log_path.as_ref(); - let Ok(path) = fmt_path(path) else { - eprintln!( - "Build logger failed: {} is not a vaild path.", - path.display() - ); - return; - }; - path - }; - - let mut builder = Builder::new(); - - let log_format = |buf: &mut env_logger::fmt::Formatter, record: &log::Record| { - let now = chrono::Local::now(); - - let level_style = match record.level() { - Level::Error => record.args().to_string().red().bold(), - Level::Warn => record.args().to_string().yellow().bold(), - Level::Info => record.args().to_string().white(), - Level::Debug => record.args().to_string().white(), - Level::Trace => record.args().to_string().cyan(), - }; - - writeln!( - buf, - "{} {}", - now.format("%H:%M:%S") - .to_string() - .truecolor(105, 105, 105) - .bold(), - level_style - ) - }; - - let log_file = std::fs::File::create(log_path).expect("Failed to create log file"); - let combined_target = Target::Pipe(Box::new(MultiWriter::new(std::io::stdout(), log_file))); - - let level = match logger_level { - LoggerLevel::Debug => LevelFilter::Debug, - LoggerLevel::Trace => LevelFilter::Trace, - LoggerLevel::Info => LevelFilter::Info, - }; - - builder - .format(log_format) - .filter(None, level.clone()) - .filter_module("just_enough_vcs", level) - .target(combined_target) - .init(); -} diff --git a/utils/src/macros.rs b/utils/src/macros.rs new file mode 100644 index 0000000..f1cb75e --- /dev/null +++ b/utils/src/macros.rs @@ -0,0 +1,14 @@ +/// A macro for creating a `Vec` from string literals. +/// +/// # Examples +/// ``` +/// # use cli_utils::string_vec; +/// let v = string_vec!["hello", "world"]; +/// assert_eq!(v, vec!["hello".to_string(), "world".to_string()]); +/// ``` +#[macro_export] +macro_rules! string_vec { + ($($elem:expr),* $(,)?) => { + vec![$($elem.to_string()),*] + }; +} diff --git a/utils/src/math.rs b/utils/src/math.rs new file mode 100644 index 0000000..42a44a1 --- /dev/null +++ b/utils/src/math.rs @@ -0,0 +1 @@ +pub mod levenshtein_distance; diff --git a/utils/src/math/levenshtein_distance.rs b/utils/src/math/levenshtein_distance.rs new file mode 100644 index 0000000..98caa20 --- /dev/null +++ b/utils/src/math/levenshtein_distance.rs @@ -0,0 +1,38 @@ +use std::cmp::min; + +pub fn levenshtein_distance(a: &str, b: &str) -> usize { + let a_len = a.chars().count(); + let b_len = b.chars().count(); + + if a_len == 0 { + return b_len; + } + if b_len == 0 { + return a_len; + } + + let mut prev_row: Vec = (0..=b_len).collect(); + let mut curr_row = vec![0; b_len + 1]; + + let mut a_chars = a.chars(); + + for i in 1..=a_len { + let a_char = a_chars.next().unwrap(); + curr_row[0] = i; + + let mut b_chars = b.chars(); + for j in 1..=b_len { + let b_char = b_chars.next().unwrap(); + + let cost = if a_char == b_char { 0 } else { 1 }; + curr_row[j] = min( + prev_row[j] + 1, + min(curr_row[j - 1] + 1, prev_row[j - 1] + cost), + ); + } + + std::mem::swap(&mut prev_row, &mut curr_row); + } + + prev_row[b_len] +} diff --git a/utils/src/push_version.rs b/utils/src/push_version.rs deleted file mode 100644 index 6da9039..0000000 --- a/utils/src/push_version.rs +++ /dev/null @@ -1,30 +0,0 @@ -pub fn push_version(current_version: impl Into) -> Option { - let version_str = current_version.into(); - let parts: Vec<&str> = version_str.split('.').collect(); - - if parts.len() != 3 { - return None; - } - - let major: Result = parts[0].parse(); - let minor: Result = parts[1].parse(); - let patch: Result = parts[2].parse(); - - if let (Ok(mut major), Ok(mut minor), Ok(mut patch)) = (major, minor, patch) { - patch += 1; - - if patch > 99 { - patch = 0; - minor += 1; - - if minor > 99 { - minor = 0; - major += 1; - } - } - - Some(format!("{}.{}.{}", major, minor, patch)) - } else { - None - } -} diff --git a/utils/src/socket_addr_helper.rs b/utils/src/socket_addr_helper.rs deleted file mode 100644 index 29ccd9f..0000000 --- a/utils/src/socket_addr_helper.rs +++ /dev/null @@ -1,194 +0,0 @@ -use std::net::SocketAddr; -use tokio::net::lookup_host; - -/// Helper function to parse a string into a SocketAddr with optional default port -pub async fn get_socket_addr( - address_str: impl AsRef, - default_port: u16, -) -> Result { - let address = address_str.as_ref().trim(); - - // Return error if input is empty after trimming - if address.is_empty() { - return Err(std::io::Error::new( - std::io::ErrorKind::InvalidInput, - "Empty address string", - )); - } - - // Check if the address contains a port - if let Some((host, port_str)) = parse_host_and_port(address) { - let port = port_str.parse::().map_err(|e| { - std::io::Error::new( - std::io::ErrorKind::InvalidInput, - format!("Invalid port number '{}': {}", port_str, e), - ) - })?; - - return resolve_to_socket_addr(host, port).await; - } - - // No port specified, use default port - resolve_to_socket_addr(address, default_port).await -} - -/// Parse host and port from address string -fn parse_host_and_port(address: &str) -> Option<(&str, &str)> { - if address.starts_with('[') - && let Some(close_bracket) = address.find(']') - && close_bracket + 1 < address.len() - && address.as_bytes()[close_bracket + 1] == b':' - { - let host = &address[1..close_bracket]; - let port = &address[close_bracket + 2..]; - return Some((host, port)); - } - - // Handle IPv4 addresses and hostnames with ports - if let Some(colon_pos) = address.rfind(':') { - // Check if this is not part of an IPv6 address without brackets - if !address.contains('[') && !address.contains(']') { - let host = &address[..colon_pos]; - let port = &address[colon_pos + 1..]; - - // Basic validation to avoid false positives - if !host.is_empty() && !port.is_empty() && port.chars().all(|c| c.is_ascii_digit()) { - return Some((host, port)); - } - } - } - - None -} - -/// Resolve host to SocketAddr, handling both IP addresses and domain names -async fn resolve_to_socket_addr(host: &str, port: u16) -> Result { - // First try to parse as IP address (IPv4 or IPv6) - if let Ok(ip_addr) = host.parse() { - return Ok(SocketAddr::new(ip_addr, port)); - } - - // If it's not a valid IP address, treat it as a domain name and perform DNS lookup - let lookup_addr = format!("{}:{}", host, port); - let mut addrs = lookup_host(&lookup_addr).await?; - - if let Some(addr) = addrs.next() { - Ok(addr) - } else { - Err(std::io::Error::new( - std::io::ErrorKind::NotFound, - format!("Could not resolve host '{}'", host), - )) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[tokio::test] - async fn test_ipv4_with_port() { - let result = get_socket_addr("127.0.0.1:8080", 80).await; - assert!(result.is_ok()); - let addr = result.unwrap(); - assert_eq!(addr.port(), 8080); - assert_eq!(addr.ip().to_string(), "127.0.0.1"); - } - - #[tokio::test] - async fn test_ipv4_without_port() { - let result = get_socket_addr("192.168.1.1", 443).await; - assert!(result.is_ok()); - let addr = result.unwrap(); - assert_eq!(addr.port(), 443); - assert_eq!(addr.ip().to_string(), "192.168.1.1"); - } - - #[tokio::test] - async fn test_ipv6_with_port() { - let result = get_socket_addr("[::1]:8080", 80).await; - assert!(result.is_ok()); - let addr = result.unwrap(); - assert_eq!(addr.port(), 8080); - assert_eq!(addr.ip().to_string(), "::1"); - } - - #[tokio::test] - async fn test_ipv6_without_port() { - let result = get_socket_addr("[::1]", 443).await; - assert!(result.is_ok()); - let addr = result.unwrap(); - assert_eq!(addr.port(), 443); - assert_eq!(addr.ip().to_string(), "::1"); - } - - #[tokio::test] - async fn test_invalid_port() { - let result = get_socket_addr("127.0.0.1:99999", 80).await; - assert!(result.is_err()); - } - - #[tokio::test] - async fn test_empty_string() { - let result = get_socket_addr("", 80).await; - assert!(result.is_err()); - } - - #[tokio::test] - async fn test_whitespace_trimming() { - let result = get_socket_addr(" 127.0.0.1:8080 ", 80).await; - assert!(result.is_ok()); - let addr = result.unwrap(); - assert_eq!(addr.port(), 8080); - } - - #[tokio::test] - async fn test_domain_name_with_port() { - // This test will only pass if localhost resolves - let result = get_socket_addr("localhost:8080", 80).await; - if result.is_ok() { - let addr = result.unwrap(); - assert_eq!(addr.port(), 8080); - // localhost should resolve to 127.0.0.1 or ::1 - assert!(addr.ip().is_loopback()); - } - } - - #[tokio::test] - async fn test_domain_name_without_port() { - // This test will only pass if localhost resolves - let result = get_socket_addr("localhost", 443).await; - if result.is_ok() { - let addr = result.unwrap(); - assert_eq!(addr.port(), 443); - // localhost should resolve to 127.0.0.1 or ::1 - assert!(addr.ip().is_loopback()); - } - } - - #[tokio::test] - async fn test_parse_host_and_port() { - // IPv4 with port - assert_eq!( - parse_host_and_port("192.168.1.1:8080"), - Some(("192.168.1.1", "8080")) - ); - - // IPv6 with port - assert_eq!(parse_host_and_port("[::1]:8080"), Some(("::1", "8080"))); - - // Hostname with port - assert_eq!( - parse_host_and_port("example.com:443"), - Some(("example.com", "443")) - ); - - // No port - assert_eq!(parse_host_and_port("192.168.1.1"), None); - assert_eq!(parse_host_and_port("example.com"), None); - - // Invalid cases - assert_eq!(parse_host_and_port(":"), None); - assert_eq!(parse_host_and_port("192.168.1.1:"), None); - } -} -- cgit