Crate strs_tools 

strs_tools

Advanced string manipulation tools with SIMD acceleration and intelligent parsing.

Why strs_tools?

While Rust’s standard library provides basic string operations, strs_tools offers sophisticated string manipulation capabilities that handle real-world complexity:

• Smart Splitting: Split strings with quote awareness, escape handling, and delimiter preservation
• Intelligent Parsing: Parse command-like strings and extract key-value parameters
• Fast Performance: Optional SIMD acceleration for high-throughput text processing
• Memory Efficient: Zero-allocation operations where possible using Cow<str>

Quick Start

cargo add strs_tools

Examples

Advanced String Splitting

Unlike standard str.split(), handles quotes and preserves context:

use strs_tools::string;

// Basic splitting with delimiter preservation
let text = "hello world test";
let result : Vec< String > = string::split()
.src( text )
.delimiter( " " )
.preserving_delimiters( true )  // Keep delimiters
.perform()
.map( String::from )
.collect();

assert_eq!( result, vec![ "hello", " ", "world", " ", "test" ] );

// Quote-aware splitting (perfect for parsing commands)
let command = r#"run --file "my file.txt" --verbose"#;
let parts : Vec< String > = string::split()
.src( command )
.delimiter( " " )
.quoting( true )     // Handle quotes intelligently
.perform()
.map( String::from )
.collect();
// Results: ["run", "--file", "my file.txt", "--verbose"]

Text Indentation

Add consistent indentation to multi-line text:

use strs_tools::string;

let code = "fn main() {\n    println!(\"Hello\");\n}";
let indented = string::indentation::indentation( "  ", code, "" );
// Result: "  fn main() {\n      println!(\"Hello\");\n  }"

Command Parsing

Parse command-line style strings into structured data:

use strs_tools::string;

let input = "deploy --env production --force --config ./deploy.toml";
// Command parsing functionality under development
println!( "Command: {}", input );
// Note: Full parse_request API is still being finalized

Number Parsing

Robust number parsing with multiple format support:

let values = [ "42", "3.14", "1e6" ];
for val in values
{
  if let Ok( num ) = val.parse::< f64 >()
  {
    println!( "{} = {}", val, num );
  }
}

Performance Features

Enable SIMD acceleration for demanding applications:

[dependencies]
strs_tools = { version = "0.30", features = ["simd"] }

SIMD features provide significant speedups for:

• Large text processing
• Pattern matching across multiple delimiters
• Bulk string operations

Feature Selection

Choose only the functionality you need:

[dependencies]
strs_tools = { 
    version = "0.30", 
    features = ["string_split", "string_parse_request"], 
    default-features = false 
}

Available features:

• string_split - Advanced splitting with quotes and escaping
• string_indentation - Text indentation tools
• string_isolate - String isolation by delimiters
• string_parse_request - Command parsing utilities
• string_parse_number - Number parsing from strings
• simd - SIMD acceleration (recommended for performance)

When to Use strs_tools

Perfect for:

• CLI applications parsing complex commands
• Configuration file processors
• Text processing tools and parsers
• Data extraction from formatted text
• Applications requiring high-performance string operations

Alternatives:

• Use standard str methods for simple splitting and basic operations
• Consider regex crate for complex pattern matching
• Use clap or structopt for full CLI argument parsing frameworks

Examples

Explore comprehensive examples showing real-world usage:

git clone https://github.com/Wandalen/wTools
cd wTools/module/core/strs_tools

# Run examples by number
cargo run --example 001_basic_usage
cargo run --example 002_advanced_splitting
cargo run --example 003_text_indentation
cargo run --example 004_command_parsing
cargo run --example 005_string_isolation
cargo run --example 006_number_parsing
cargo run --example 007_performance_and_simd --features simd

Documentation

• API Documentation
• Architecture Details
• Performance Benchmarks
• Migration Guide

Rule Compliance & Architectural Notes

This crate has been systematically updated to comply with the Design and Codestyle Rulebooks. Key compliance achievements and ongoing considerations :

Completed Compliance Work :

1. Documentation Strategy : Uses #![ doc = include_str!(...) ] to include readme.md instead of duplicating documentation. This is the mandated approach for all entry files.

2. Workspace Dependencies : All external dependencies now inherit from workspace with { workspace = true }. SIMD optimization deps (memchr, aho-corasick, bytecount, lexical) were moved to workspace level for version consistency.

3. Attribute Formatting : All attributes use proper spacing per Universal Formatting Rule : #[ cfg( feature = "enabled" ) ] instead of #[ cfg( feature = "enabled" ) ]

4. Manual Namespace Architecture : Uses the standard wTools manual namespace pattern (private/own/orphan/exposed/prelude) for precise API control and stable public interfaces.

Critical Architectural Decisions :

• Feature Gating : All functionality is gated behind the “enabled” feature for granular control over compilation and dependencies.

• Error Handling : Uses error_tools exclusively - no anyhow or thiserror dependencies per Design Rulebook requirements.

• Testing Isolation : All tests are in tests/ directory, never in src/, following the mandatory testing architecture pattern.

Re-exports

pub use super::string;

pub use super::simd;

pub use orphan::*;

Modules

exposed

Exposed namespace of the module.

orphan

Parented namespace of the module.

own

Own namespace of the module.

prelude

Namespace of the module to include with use module::*.

simd

SIMD-optimized string operations. High-performance SIMD string operations module.

string

String tools.