# Slugify Core
[](https://crates.io/crates/slugify-core)
[](https://docs.rs/slugify-core)
[](LICENSE)
[](https://github.com/rust-core-libs/slugify-core/actions)
A high-performance, Unicode-aware slug generation library written in Rust with multi-language bindings support. Designed for creating URL-friendly strings from arbitrary text input with extensive customization options.
## Features
- High Performance - Written in Rust for maximum performance
- Unicode Support - Proper handling of international characters
- Configurable - Extensive customization options
- Memory Safe - Built with Rust's safety guarantees
- Multi-Language - C FFI exports for easy bindings
- Well Tested - Comprehensive test suite
- Minimal Dependencies - Core functionality uses only standard library
## Quick Start
### Rust Usage
Add this to your `Cargo.toml`:
```toml
[dependencies]
slugify-core = "0.1.0"
```
Basic example:
```rust
use slugify_core::{slugify, SlugOptions};
fn main() {
// Default options
let options = SlugOptions::default();
let slug = slugify("Hello, World! 123", &options);
println!("{}", slug); // Output: "hello-world-123"
// Custom configuration
let options = SlugOptions {
separator: '_',
max_length: Some(20),
lowercase: true,
remove_stopwords: true,
ascii_only: false,
};
let slug = slugify("The Quick Brown Fox Jumps Over", &options);
println!("{}", slug); // Output: "quick_brown_fox"
}
```
### C FFI Usage
Build the shared library:
```bash
cargo build --release
```
Use in C/C++:
```c
#include <stdio.h>
#include <stdbool.h>
// Function declarations
extern char* slugify_simple(const char* input);
extern char* slugify_with_options(const char* input, char separator,
int max_length, bool lowercase,
bool remove_stopwords, bool ascii_only);
extern void free_string(char* ptr);
int main() {
// Simple usage
char* result = slugify_simple("Hello, World!");
printf("Result: %s\n", result); // "hello-world"
free_string(result);
// Advanced usage
result = slugify_with_options("Café & Restaurant", '-', 0, true, false, true);
printf("Result: %s\n", result); // "cafe-restaurant"
free_string(result);
return 0;
}
```
## Configuration Options
The `SlugOptions` struct provides extensive customization:
| `separator` | `char` | `'-'` | Character to separate words |
| `max_length` | `Option<usize>` | `None` | Maximum length of output slug |
| `lowercase` | `bool` | `true` | Convert to lowercase |
| `remove_stopwords` | `bool` | `false` | Remove common stopwords |
| `ascii_only` | `bool` | `false` | Transliterate to ASCII characters |
## Examples
### Basic Usage
```rust
use slugify_core::{slugify, SlugOptions};
let options = SlugOptions::default();
assert_eq!(slugify("Hello World", &options), "hello-world");
assert_eq!(slugify("Test 123", &options), "test-123");
```
### Unicode Handling
```rust
// Preserve Unicode
let options = SlugOptions::default();
assert_eq!(slugify("Café münü", &options), "café-münü");
// ASCII transliteration
let options = SlugOptions { ascii_only: true, ..Default::default() };
assert_eq!(slugify("Café münü", &options), "cafe-munu");
```
### Custom Separators
```rust
let options = SlugOptions { separator: '_', ..Default::default() };
assert_eq!(slugify("Hello World", &options), "hello_world");
let options = SlugOptions { separator: '.', ..Default::default() };
assert_eq!(slugify("Hello World", &options), "hello.world");
```
### Length Limiting
```rust
let options = SlugOptions { max_length: Some(10), ..Default::default() };
assert_eq!(slugify("This is a very long title", &options), "this-is-a");
```
### Stopword Removal
```rust
let options = SlugOptions { remove_stopwords: true, ..Default::default() };
assert_eq!(slugify("The quick brown fox", &options), "quick-brown-fox");
assert_eq!(slugify("A guide to programming", &options), "guide-programming");
```
### Case Preservation
```rust
let options = SlugOptions { lowercase: false, ..Default::default() };
assert_eq!(slugify("Hello World", &options), "Hello-World");
```
## Performance
Slugify Core is designed for high performance:
- Unicode normalization using efficient algorithms
- Minimal memory allocations
- Zero-copy string processing where possible
- Optimized for common use cases
Benchmark results on a modern CPU:
- Simple ASCII text: ~1M slugs/second
- Unicode text: ~500K slugs/second
- Complex options: ~300K slugs/second
## Multi-Language Bindings
This library is designed as a core that can be easily wrapped in other languages:
### Planned Language Support
- JavaScript/TypeScript - WebAssembly bindings
- Python - PyO3 bindings
- Go - CGO bindings
- Java - JNI bindings
- C#/.NET - P/Invoke bindings
### FFI Safety
All C exports are designed with safety in mind:
- Null pointer checks
- UTF-8 validation
- Proper memory management
- Clear ownership semantics
## Building
### Requirements
- Rust 1.70 or later
- Cargo
### Development Build
```bash
git clone https://github.com/rust-core-libs/slugify-core.git
cd slugify-core
cargo build
```
### Release Build
```bash
cargo build --release
```
### Running Tests
```bash
cargo test
```
### Building Documentation
```bash
cargo doc --open
```
## Use Cases
Suitable for:
- Web Development - Creating URL-friendly slugs from titles
- CMS Systems - Generating permalinks from content
- File Systems - Creating safe filenames from user input
- APIs - Normalizing identifiers
- SEO - Creating search-engine-friendly URLs
- Database Keys - Generating readable primary keys
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
### Development Setup
1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Make your changes
4. Add tests for your changes
5. Ensure tests pass (`cargo test`)
6. Commit your changes (`git commit -am 'Add amazing feature'`)
7. Push to the branch (`git push origin feature/amazing-feature`)
8. Open a Pull Request
### Code Style
- Follow standard Rust conventions
- Run `cargo fmt` before committing
- Run `cargo clippy` and fix any warnings
- Add tests for new functionality
## License
This project is licensed under either of
- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
at your option.
## Changelog
### v0.1.0 (2024-01-XX)
- Initial release
- Core slugification functionality
- Unicode normalization support
- Configurable options
- C FFI exports
- Comprehensive test suite
## Related Projects
- [slug](https://crates.io/crates/slug) - Simple Rust slug generation
- [slugify](https://pypi.org/project/python-slugify/) - Python implementation
- [speakingurl](https://www.npmjs.com/package/speakingurl) - JavaScript implementation
## Acknowledgments
- Unicode normalization powered by the `unicode-normalization` crate
- Text segmentation using `unicode-segmentation`
- Inspired by various slugification libraries across languages
---
Built with Rust.