https://github.com/dashxhq/sanitizer
Dead easy sanitizing for rust structs
https://github.com/dashxhq/sanitizer
rust sanitize structs
Last synced: 15 days ago
JSON representation
Dead easy sanitizing for rust structs
- Host: GitHub
- URL: https://github.com/dashxhq/sanitizer
- Owner: dashxhq
- License: mit
- Created: 2020-11-30T06:20:29.000Z (over 4 years ago)
- Default Branch: develop
- Last Pushed: 2024-08-11T09:13:25.000Z (9 months ago)
- Last Synced: 2025-03-25T06:06:15.031Z (about 1 month ago)
- Topics: rust, sanitize, structs
- Language: Rust
- Homepage:
- Size: 207 KB
- Stars: 10
- Watchers: 0
- Forks: 3
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# sanitizer
Inspired by the [validator](https://github.com/Keats/validator) crate. The Sanitizer crate is a collection of
methods and a macro to sanitize struct fields, leveraging the macros of rust, it follows the elegant approach by
the validator crate.
# Overview
```rust
[dependencies]
sanitizer = { version = "0.1", features = ["derive"] }
```
Then to use the crate
```rust
use sanitizer::prelude::*;
#[derive(Debug, Sanitize)]
struct SignupData {
#[sanitize(trim, lower_case)]
mail: String,
#[sanitize(clamp(1, 60))]
age: u8,
#[sanitize]
user: User,
}
#[derive(Debug, Sanitize)]
struct User {
id: u64,
#[sanitize(trim, clamp(50))]
name: String,
}
fn main() {
let instance = SignupData::new();
instance.sanitize();
}
```
If you do not want to use the derive macro, then the sanitizer crate provides structures and methods for sanitizing
ints
```rust
let int: u8 = 50;
let mut instance = IntSanitizer::from(int);
instance.clamp(99, 101);
assert_eq!(99, instance.get());
```
and strings
```rust
let mut sanitize = StringSanitizer::from(" some_string12 ");
sanitize.trim().numeric();
assert_eq!("12", sanitize.get());
```
# Sanitizers
### trim
Removes whitespace from ends.
### numeric
Removes any character that is not a numeric.
### alphanumeric
Removes any character that is not an alphanumeric.
### lower_case
Converts string input to lowercase.
### upper_case
Converts string input to UPPERCASE.
### camel_case
Converts string input to camelCase.
### snake_case
Converts string input to snake_case.
### screaming_snake_case
Converts string input to SCREAMING_SNAKE_CASE using the [Inflector](https://github.com/whatisinternet/Inflector) crate.
### e164
Converts string input to E164 International Phone Number format. This panics if the phone number is not a valid one.
### clamp(min, max)
Limit an valid integer field with the given min and max.
### clamp(max)
Limit a string input length to the following number
### custom(function)
Use a custom function to sanitize a field differently. For example
```rust
#[derive(Sanitize)]
struct SanitizerTest {
#[sanitize(custom(func_string))]
field_string: String,
}
fn func_string(field: &str) -> String {
let mut sanitizer = StringSanitizer::from(field);
sanitizer.trim();
sanitizer.get()
}
#[test]
fn sanitizer_check_custom_functions() {
let mut instance = SanitizerTest {
field_string: String::from("Hello "),
};
instance.sanitize();
assert_eq!(instance.field_string, String::from("Hello"));
}
```
### nesting
```rust
#[derive(Sanitize)]
struct First {
#[sanitize(trim)]
name: String,
#[sanitize]
info: OtherInfo,
}
#[derive(Sanitize)]
struct OtherInfo {
#[sanitize(numeric)]
id: String,
#[sanitize(lower_case, trim)]
email: String,
}
```
The `sanitize` method of `First` will call the sanitizer method of `OtherInfo` automatically,
if you would like to individually snaitize `OtherInfo` then you can just call `snaitize` on one of its instance.
# LICENSE
dashxhq/sanitizer is licensed under the MIT License.