Add benches

[daxartio]

I compared this crate with ChatGPT's code. And ChatGPT's code was faster than this one.

Maybe we need to optimize the algorithm for converting a case.

[Slackadays]

What was ChatGPT's code?

[daxartio]

Sure!

#![feature(test)]

extern crate test;

use convert_case::{Case, Casing};

fn to_camel(s: &str) -> String {
    let mut result = String::with_capacity(s.len());
    let mut capitalize_next = false;
    for c in s.chars() {
        if c == ' ' || c == '_' || c == '-' {
            capitalize_next = true;
        } else {
            if capitalize_next {
                result.push(c.to_ascii_uppercase());
                capitalize_next = false;
            } else {
                result.push(c.to_ascii_lowercase());
            }
        }
    }
    result
}

fn to_snake(s: &str) -> String {
    let mut result = String::with_capacity(s.len());
    let mut upper_count = 0;
    for (i, c) in s.chars().enumerate() {
        if c.is_uppercase() {
            upper_count += 1;
            if i > 0 && upper_count < 2 {
                result.push('_');
            }
            result.push(c.to_ascii_lowercase());
        } else {
            if upper_count > 1 {
                if let Some(last_c) = result.pop() {
                    result.push('_');
                    result.push(last_c);
                }
            }
            upper_count = 0;
            result.push(c);
        }
    }
    result
}

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

    #[test]
    fn it_works() {
        assert_eq!("ronnieJamesDio", "Ronnie_James_dio".to_case(Case::Camel));
        assert_eq!("ronnie_james_dio", "ronnieJamesDio".to_case(Case::Snake));

        assert_eq!("ronnieJamesDio", to_camel("Ronnie_James_dio"));
        assert_eq!("ronnie_james_dio", to_snake("ronnieJamesDio"));
    }

    #[bench]
    fn bench_to_camel1(b: &mut Bencher) {
        b.iter(|| "Ronnie_James_dio".to_case(Case::Camel));
    }

    #[bench]
    fn bench_to_camel2(b: &mut Bencher) {
        b.iter(|| to_camel("Ronnie_James_dio"));
    }

    #[bench]
    fn bench_to_snake1(b: &mut Bencher) {
        b.iter(|| "ronnieJamesDio".to_case(Case::Snake));
    }

    #[bench]
    fn bench_to_snake2(b: &mut Bencher) {
        b.iter(|| to_snake("ronnieJamesDio"));
    }
}

running 5 tests
test tests::it_works ... ignored
test tests::bench_to_camel1 ... bench:      22,035 ns/iter (+/- 7,051)
test tests::bench_to_camel2 ... bench:          85 ns/iter (+/- 27)
test tests::bench_to_snake1 ... bench:      19,016 ns/iter (+/- 1,645)
test tests::bench_to_snake2 ... bench:         226 ns/iter (+/- 43)

test result: ok. 0 passed; 0 failed; 1 ignored; 4 measured; 0 filtered out; finished in 13.33s

[BernardIgiri]

If this project needs help, I can work to submit a few PR's. I already have a PR in a related project: stringcase/ccase#3

[ForkingFrenzy]

Coming here to say there might be a performance issue with convert_case.
I use vector.dev, which depends on convert_case. Everytime we use reference the convert_case crate in the vrl the performance is a lot slower than other functions.