lano_stre/

lib.rs

// pub fn add(left: u64, right: u64) -> u64 {
//     left + right
// }

// #[cfg(test)]
// mod tests {
//     use super::*;

//     #[test]
//     fn it_works() {
//         let result = add(2, 2);
//         assert_eq!(result, 4);
//     }
// }

use regex::Regex;
// use fancy_regex::Regex;

/// mock js String.prototype.replace
///
/// ```rs
/// let result = str_pattern_replace(input_string, pattern, replacement_function);
/// ```
fn str_pattern_replace<F>(input: &str, pattern: &str, replacement: F) -> String
where
    F: Fn(usize, &str) -> String,
{
    // Compile the regex pattern
    let regex = Regex::new(pattern).expect("Invalid regex pattern");

    // Create a mutable String to hold the modified result
    let mut result = String::new();
    let mut last_end = 0;

    // Iterate over all matches
    for (index, caps) in regex.captures_iter(input).enumerate() {
        // Get the matched value
        let matched_value = &caps[0];

        // Get the start index of the match
        let start_index = caps.get(0).unwrap().start();

        // Append the part of the string before the match
        result.push_str(&input[last_end..start_index]);

        // Call the replacement function with the index and matched value
        result.push_str(&replacement(index, matched_value));

        // Update the last end position
        last_end = caps.get(0).unwrap().end();
    }

    // Append the remaining part of the input string after the last match
    result.push_str(&input[last_end..]);

    result
}

/// Handle the first character to be uppercase and others to be lowercase
///
/// If `otherslower` is `Some(true)`, the other characters will be converted to lowercase.
/// If `otherslower` is `Some(false)`, the other characters will retain their original case.
/// If `otherslower` is `None`, the other characters will also be converted to lowercase.
///
/// ```rs
/// let res = str_first_upper("hello world", Some(true));
/// assert_eq!(res, "Hello world");
/// ```
fn str_first_upper(s: &str, otherslower: Option<bool>) -> String {
    let res: String = s
        .chars()
        .enumerate()
        .map(|(i, c)| {
            if i == 0 {
                c.to_uppercase().to_string() // Capitalize the first character
            } else {
                match otherslower {
                    Some(false) => c.to_string(),      // Retain original case if false
                    _ => c.to_lowercase().to_string(), // Convert to lowercase if true or None
                }
            }
        })
        .collect();

    res
}

fn str_first_lower(s: &str) -> String {
    let res: String = s
        .chars()
        .enumerate()
        .map(|(i, c)| {
            if i == 0 {
                c.to_lowercase().to_string() // Capitalize the first character
            } else {
                c.to_string()
            }
        })
        .collect();
    res
}

/// add filled letters as prefix when enable and  pattern match
///
/// ```rs
/// res = str_pattern_prefix(&res, r"(?:[A-Z]+)", index != 0);
/// ```
fn str_pattern_prefix(s: &str, pattern: &str, filled: &str, enable: bool) -> String {
    if enable {
        let upper_case_pattern = Regex::new(pattern).unwrap();
        upper_case_pattern.replace_all(s, format!("{}{}", filled, "$0")).to_string()
    } else {
        s.to_string()
    }
}

/// padd letters when enable and  pattern match
///
/// ```rs
/// res = str_case_switch_when_enable(&res, index == 0);
/// ```
// fn str_case_switch_when_enable(s: &str, enable: bool) -> String {
//     if enable {
//         s.to_uppercase()
//     } else {
//         s.to_lowercase()
//     }
// }

fn baseify(input_string: &str) -> String {
    // Define a regex pattern for camelCase words
    // let pattern = r"(?:^\w|[A-Z_-]|\b\w)";
    // let separator_pattern = Regex::new(r"[-_]+").unwrap();

    // let debug = false;
    // // Define a replacement function that uses the index
    // let replacement_function = |index: usize, match_str: &str| {
    //     // info match key and val
    //     if debug {
    //         println!("{},{}", index, match_str);
    //     }

    //     // Replace multi - or _ with a space
    //     let res = separator_pattern.replace_all(match_str, " ").to_string();

    //     // Add space before uppercase letters that are not the first index
    //     // res = str_pattern_prefix(&res, r"(?:[A-Z]+)", " ", index != 0);

    //     // Handle the first character to be uppercase and others to be lowercase
    //     // res = str_first_upper(&match_str, None);

    //     // Capitalize the first character and lowercase the rest
    //     // res = str_case_switch_when_enable(&res, index == 0);
    //     res
    //     // format!("REPLACED_{}: {} ", index, match_str.to_lowercase())
    // };
    // let result = str_pattern_replace(input_string, pattern, replacement_function);

    // step 1 - Replace multi - or _ with a space
    let result = str_pattern_replace(input_string, r"[-_]+", |_index: usize, _match_str: &str| {
        " ".to_string()
    });
    // println!("[replace multi - or _ with a space]: {}", result);

    // optinal
    // let filled as prefix to sequence of two or more uppercase letters
    // let result = str_pattern_prefix(&result, r"(?:[A-Z]{2,})", " ", true);

    // let frst char upper for sequence of two or more uppercase letters
    let result =
        str_pattern_replace(&result, r"(?:[A-Z]{2,})", |_index: usize, match_str: &str| {
            str_first_upper(&match_str, None)
        });
    // println!("[NAME to Name]: {}", result);

    // let filled as prefix to a uppercase letter
    let result = str_pattern_prefix(&result, r"[A-Z]+", " ", true);
    let result =
        str_pattern_replace(&result, r" +", |_index: usize, _match_str: &str| " ".to_string());
    // println!("[prefix space to uppercase letter]: {}", result);

    // let word first char upper for each word
    // step 2 - Capitalize the first character and lowercase the rest for each word
    let words_pattern = r"(?:[\w]+)";
    let words_first_upper = |_index: usize, match_str: &str| -> String {
        // str_case_switch_when_enable(&match_str, index == 0)
        str_first_upper(&match_str, None)
    };
    let result = str_pattern_replace(&result, words_pattern, words_first_upper);

    // println!("[word first upper]: {}", result);

    // step 3 - let str first char upper for sentence
    // let result = str_first_upper(&result, None);
    // println!("[sentence first upper]: {}", result);

    result
}

///
///
/// ```rs
/// assert_eq!(humanize("hello-world"), "Hello World");
/// assert_eq!(humanize("hello_world"), "Hello World");
/// assert_eq!(humanize("helloWorld"), "Hello World");
/// assert_eq!(humanize("HelloWorld"), "Hello World");
/// assert_eq!(humanize("helloWORLD"), "Hello World");
/// assert_eq!(humanize(""), "");
/// assert_eq!(humanize("--"), "");
/// assert_eq!(humanize("__"), "");
/// assert_eq!(humanize("hello--world"), "Hello World");
/// assert_eq!(humanize("hello__world"), "Hello World");
/// assert_eq!(humanize("helloWORLD Test"), "Hello World Test");
/// ```
pub fn humanize(s: &str) -> String {
    // use regexp to get words in rust: "\w+"
    // let words support containts - or _ "[\w-]+"
    // (?:^\w|[A-Z_-]|\b\w)
    // r"(?:^\w|[A-Z-a-z]|\b\w)"

    // (?:^\w|[A-Z_-]|\b\w)
    // (?:(?m)^\w|[A-Z_-]|\b\w)
    // Regex to match the patterns similar to the TypeScript regex
    let result = baseify(s);
    // Trim any trailing whitespace and return
    result.trim().to_string().replace("\n", " ") // Replace newlines with spaces
}

///
///  ```rs
///  assert_eq!(slugify("hello-world"), "hello-world");
///  assert_eq!(slugify("hello_world"), "hello-world");
///  assert_eq!(slugify("helloWorld"), "hello-world");
///  assert_eq!(slugify("HelloWorld"), "hello-world");
///  assert_eq!(slugify("helloWORLD"), "hello-world");
///  assert_eq!(slugify(""), "");
///  assert_eq!(slugify("--"), "");
///  assert_eq!(slugify("__"), "");
///  assert_eq!(slugify("hello--world"), "hello-world");
///  assert_eq!(slugify("hello__world"), "hello-world");
///  assert_eq!(slugify("helloWORLD Test"), "hello-world-test");
/// ```
pub fn slugify(s: &str) -> String {
    let humanized = humanize(s);
    humanized.to_lowercase().replace(" ", "-")
}

///
///
///  ```rs
///  assert_eq!(camelize("hello-world"), "helloWorld");
///  assert_eq!(camelize("hello_world"), "helloWorld");
///  assert_eq!(camelize("helloWorld"), "helloWorld");
///  assert_eq!(camelize("HelloWorld"), "helloWorld");
///  assert_eq!(camelize("helloWORLD"), "helloWorld");
///  assert_eq!(camelize(""), "");
///  assert_eq!(camelize("--"), "");
///  assert_eq!(camelize("__"), "");
///  assert_eq!(camelize("hello--world"), "helloWorld");
///  assert_eq!(camelize("hello__world"), "helloWorld");
///  assert_eq!(camelize("helloWORLD Test"), "helloWorldTest");
/// ```
pub fn camelize(s: &str) -> String {
    let humanized = humanize(s);

    let result = str_pattern_replace(
        &str_first_lower(&humanized),
        r" +",
        |_index: usize, _match_str: &str| "".to_string(),
    );

    // let mut result = String::new();
    // let mut first_char = true;
    // for c in humanized.chars() {
    //     if c == ' ' {
    //         continue;
    //     }
    //     if first_char {
    //         result.push(c.to_ascii_lowercase());
    //         first_char = false;
    //     } else {
    //         result.push(c.to_ascii_uppercase());
    //     }
    // }
    result
}

///
///
///  ```rs
///  assert_eq!(underscoped("hello-world"), "hello_world");
///  assert_eq!(underscoped("hello_world"), "hello_world");
///  assert_eq!(underscoped("helloWorld"), "hello_world");
///  assert_eq!(underscoped("HelloWorld"), "hello_world");
///  assert_eq!(underscoped("helloWORLD"), "hello_world");
///  assert_eq!(underscoped(""), "");
///  assert_eq!(underscoped("--"), "");
///  assert_eq!(underscoped("__"), "");
///  assert_eq!(underscoped("hello--world"), "hello_world");
///  assert_eq!(underscoped("hello__world"), "hello_world");
///  assert_eq!(underscoped("helloWORLD Test"), "hello_world_test");
///  ``````
pub fn underscoped(s: &str) -> String {
    let humanized = humanize(s);
    humanized.to_lowercase().replace(" ", "_")
}

/// transform string to class style
///
/// ```rs
///  assert_eq!(classify("hello-world"), "HelloWorld");
///  assert_eq!(classify("hello_world"), "HelloWorld");
///  assert_eq!(classify("helloWorld"), "HelloWorld");
///  assert_eq!(classify("HelloWorld"), "HelloWorld");
///  assert_eq!(classify("helloWORLD"), "HelloWorld"); //different for zero's stre in ts
///  assert_eq!(classify(""), "");
///  assert_eq!(classify("--"), "");
///  assert_eq!(classify("__"), "");
///  assert_eq!(classify("hello--world"), "HelloWorld");
///  assert_eq!(classify("hello__world"), "HelloWorld");
///  assert_eq!(classify("helloWORLD Test"), "HelloWorldTest");
/// ```
pub fn classify(s: &str) -> String {
    let humanized = humanize(s);
    let result = str_pattern_replace(
        &str_first_lower(&humanized),
        r"\w+",
        |_index: usize, _match_str: &str| str_first_upper(_match_str, Some(true)),
    );
    result.replace(" ", "")
}

///
///
/// ```rs
///  assert_eq!(swap_case("hello"), "HELLO");
///  assert_eq!(swap_case("HELLO"), "hello");
///  assert_eq!(swap_case("Hello"), "hELLO");
///  assert_eq!(swap_case(""), "");
///  assert_eq!(swap_case("HeLlO"), "hElLo");
/// ```
pub fn swap_case(s: &str) -> String {
    let mut result = String::new();
    for c in s.chars() {
        if c.is_uppercase() {
            result.push(c.to_ascii_lowercase());
        } else {
            result.push(c.to_ascii_uppercase());
        }
    }
    result
}

/// ttransform the first char to upper case (only the first word), other noop
///
/// ```rs
///  assert_eq!(capitalize("hello"), "Hello");
///  assert_eq!(capitalize("HELLO"), "HELLO");
///  assert_eq!(capitalize("Hello"), "Hello");
///  assert_eq!(capitalize(""), "");
///  assert_eq!(capitalize("hello world"), "Hello world");
/// ```
pub fn capitalize(s: &str) -> String {
    let mut result = String::new();
    let mut first_char = true;
    for c in s.chars() {
        if first_char {
            result.push(c.to_ascii_uppercase());
            first_char = false;
        } else {
            result.push(c);
        }
    }
    result
}

/// transform the firt char to upper (only the first word) , other lower
///
/// ```rs
///  assert_eq!(sentence("hello"), "Hello");
///  assert_eq!(sentence("HELLO"), "Hello");
///  assert_eq!(sentence("Hello"), "Hello");
///  assert_eq!(sentence(""), "");
///  assert_eq!(sentence("hello world"), "Hello world");
///  assert_eq!(sentence("HELLO WORLD"), "Hello world");
/// ```
pub fn sentence(s: &str) -> String {
    let mut result = String::new();
    let mut first_char = true;
    for c in s.chars() {
        if first_char {
            result.push(c.to_ascii_uppercase());
            first_char = false;
        } else {
            result.push(c.to_ascii_lowercase());
        }
    }
    result
}

/// transform the firt char to upper(for each word), other lower
///
/// ```rs
///  assert_eq!(titleize("hello"), "Hello");
///  assert_eq!(titleize("HELLO"), "Hello");
///  assert_eq!(titleize("Hello"), "Hello");
///  assert_eq!(titleize("hello world"), "Hello World");
///  assert_eq!(titleize("HELLO WORLD"), "Hello World");
///  assert_eq!(titleize(""), "");
///  assert_eq!(titleize("hello--world"), "Hello World");
///  assert_eq!(titleize("hello__world"), "Hello World");
/// ```
pub fn titleize(s: &str) -> String {
    let humanized = humanize(s);
    let mut result = String::new();
    let words = humanized.split_whitespace();
    for word in words {
        let capitalized_word = word.chars().next().unwrap().to_ascii_uppercase().to_string()
            + &word[1..].to_ascii_lowercase();
        result.push_str(&capitalized_word);
        result.push(' ');
    }
    result.trim_end().to_string()
}

pub fn pad_start(s: &str, len: usize, filled: char) -> String {
    let mut result = s.to_string();
    while result.len() < len {
        result.insert(0, filled);
    }
    result
}

pub fn pad_end(s: &str, len: usize, filled: char) -> String {
    let mut result = s.to_string();
    while result.len() < len {
        result.push(filled);
    }
    result
}

#[cfg(test)]
mod lib_test;