rstring

A comprehensive string manipulation library for Rust, inspired by Java's Apache Commons Lang StringUtils.

Provides 100+ utility methods as extension traits on str, covering validation, case conversion, padding, searching, substring extraction, and more. All Unicode-aware and with zero dependencies.

Installation

Add to your Cargo.toml:

[dependencies]
rstring = "0.1"

Quick Start

Import the traits you need and call methods directly on any string type:

use rstring::{StringChecks, StringCase, StringPad};

// Validation
assert!("  ".is_blank());
assert!("abc123".is_alphanumeric());

// Case conversion
assert_eq!("hello".capitalize(), "Hello");
assert_eq!("Hello World".swap_case(), "hELLO wORLD");

// Padding
assert_eq!("7".left_pad_with(3, '0'), "007");
assert_eq!("bat".center(7), "  bat  ");

You can also import everything at once:

use rstring::*;

Modules

checks — String Validation

Predicates that test string content

use rstring::StringChecks;

assert!("".is_blank());
assert!("12345".is_numeric());
assert!("abc".is_alpha());
assert!("abc123".is_alphanumeric());
assert!("Hello World".is_mixed_case());
assert!(" \t\n".is_whitespace());

case — Case Conversion

use rstring::StringCase;

assert_eq!("hello".capitalize(), "Hello");
assert_eq!("Hello".uncapitalize(), "hello");
assert_eq!("Hello World".swap_case(), "hELLO wORLD");

contains — Containment Checks

use rstring::StringContains;

assert!("abc".contains_any_char(&['a', 'z']));
assert!("Hello".contains_ignore_case("hello"));
assert!("abc".contains_only("abcd"));
assert!("abc".contains_none_char(&['x', 'y', 'z']));

index — Searching and Counting

use rstring::StringIndex;

assert_eq!("zzabyycdxx".index_of_any_char(&['a', 'b']), Some(2));
assert_eq!("ababab".ordinal_index_of("ab", 3), Some(4));
assert_eq!("abba".count_matches("a"), 2);
assert_eq!("Hello".index_of_ignore_case("hello"), Some(0));

substring — Substring Extraction

Safe substring methods that never panic — they return what they can or None.

use rstring::StringSubstring;

assert_eq!("abc".left(2), "ab");
assert_eq!("abc".right(2), "bc");
assert_eq!("abc".mid(1, 2), "bc");

assert_eq!("abc-def".substring_before("-"), Some("abc"));
assert_eq!("abc-def".substring_after("-"), Some("def"));
assert_eq!("[a]and[b]".substrings_between("[", "]"), vec!["a", "b"]);

pad — Padding and Repeating

use rstring::StringPad;

assert_eq!("1".left_pad(3), "  1");
assert_eq!("1".left_pad_with(3, '0'), "001");
assert_eq!("bat".center(7), "  bat  ");
assert_eq!("ab".repeat_str(3), "ababab");
assert_eq!("ab".repeat_with_separator(", ", 3), "ab, ab, ab");

Also provides a standalone function: rstring::pad::repeat_char(c, n).

affixes — Prefix and Suffix Operations

Returns Cow<str> to avoid allocation when the string is unchanged.

use rstring::StringAffixes;

assert_eq!(
    "domain.com".append_if_missing("/"),
    "domain.com/"
);
assert_eq!(
    "domain.com/".append_if_missing("/"),
    "domain.com/"
);
assert_eq!(
    "domain.com".prepend_if_missing("https://"),
    "https://domain.com"
);

remove — Character and Substring Removal

Methods returning a slice use &str; those requiring a new string use Cow<str>.

use rstring::StringRemove;

assert_eq!("www.domain.com".remove_start("www."), "domain.com");
assert_eq!("file.txt".remove_end(".txt"), "file");
assert_eq!("queued".remove_char('u'), "qeed");
assert_eq!("  a b  c  ".delete_whitespace(), "abc");

reverse — Reversal and Rotation

use rstring::StringReverse;

assert_eq!("bat".reverse_str(), "tab");
assert_eq!("www.domain.com".reverse_delimited('.'), "com.domain.www");
assert_eq!("abcdefg".rotate(2), "fgabcde");

wrap — Wrapping and Unwrapping

use rstring::StringWrap;

assert_eq!("abc".wrap_with_char('\''), "'abc'");
assert_eq!("abc".wrap_if_missing_char('\''), "'abc'");
assert_eq!("'abc'".unwrap_with_char('\''), "abc");

abbreviate — String Abbreviation

use rstring::StringAbbreviate;

assert_eq!(
    "Much too long text".abbreviate(10).unwrap(),
    "Much to..."
);
assert_eq!(
    "Too long".abbreviate_middle("-", 6),
    "To-ong"
);

Design Principles

• Extension traits on str — Methods work on &str, String, Box<str>, and any type that derefs to str
• No std duplicates — Methods already in Rust's standard library (is_empty, contains, starts_with, trim, to_lowercase, etc.) are not reimplemented
• Smart return types — Returns &str for slices, Cow<str> when allocation may be avoidable, String when a new string is almost always created
• Unicode-aware — All methods handle Unicode correctly. Case-insensitive methods use full Unicode case folding. ASCII-only variants (_ignore_ascii_case) are provided for performance-sensitive code
• Zero dependencies — No external crates required

License

MIT