//! Pacakage inflect provides utility functions to inflect strings.
#![cfg_attr(feature="clippy", feature(plugin))]
#![cfg_attr(feature="clippy", plugin(clippy))]

use std::ascii::AsciiExt;

pub trait StringExt {
    fn to_upper_camel(&self) -> String;
    fn to_lower_camel(&self) -> String;
}

impl<'a> StringExt for &'a str {
    fn to_upper_camel(&self) -> String {
        UpperCamel::convert_to(self)
    }
    fn to_lower_camel(&self) -> String {
        LowerCamel::convert_to(self)
    }
}

pub trait CaseFormat {
    fn convert_to(src: &str) -> String;
}

/// Case Format
/// e.g) "CaseFormat", "UpperCamel"
pub struct UpperCamel;

impl CaseFormat for UpperCamel {
    fn convert_to(src: &str) -> String {
        to_camel_case(src, true)
    }
}

/// Case Format
/// e.g) "caseFormat", "upperCamel"
pub struct LowerCamel;

impl CaseFormat for LowerCamel {
    fn convert_to(src: &str) -> String {
        to_camel_case(src, false)
    }
}


#[inline]
fn to_camel_case(src: &str, first_upper: bool) -> String {
    if src.len() == 0 {
        return String::new();
    }

    let mut string = String::with_capacity(src.len());
    let mut chars = src.chars();
    // safe
    if first_upper {
        string.push(chars.next().unwrap().to_ascii_uppercase());
    } else {
        string.push(chars.next().unwrap().to_ascii_lowercase());
    }

    'outer: while let Some(ch) = chars.next() {
        match ch {
            '-' | '_' | ' ' => {
                if let Some(n) = chars.next() {
                    string.push(n.to_ascii_uppercase());
                } else {
                    // if string ends with this character, just skip it.
                    break 'outer;
                }
            }
            _ => string.push(ch),
        }
    }

    string
}

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

    #[test]
    fn to_upper_camel() {
        let convert_to = UpperCamel::convert_to;
        assert_eq!("Foo", convert_to("foo"));
        assert_eq!("FooBar", convert_to("foo-bar"));
        assert_eq!("FooBar", convert_to("foo bar"));
        assert_eq!("FooBar", convert_to("foo_bar"));
        assert_eq!("FooBar", convert_to("fooBar"));
    }

    #[test]
    fn to_lower_camel() {
        let convert_to = LowerCamel::convert_to;
        assert_eq!("foo", convert_to("Foo"));
        assert_eq!("fooBar", convert_to("foo-bar"));
        assert_eq!("fooBar", convert_to("foo bar"));
        assert_eq!("fooBar", convert_to("foo_bar"));
        assert_eq!("fooBar", convert_to("FooBar"));
    }
}