Snap for 9713123 from 502aa96b5225a863bf16c56b5e3854deabc868cf to simpleperf-release
Change-Id: I057ac8e11af269bbed461cf61ea5c3b3c0a95f84
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
deleted file mode 100644
index e73255e..0000000
--- a/.cargo_vcs_info.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
- "git": {
- "sha1": "a4a95eac75043f4bffb127c7c8ec886b5b106053"
- }
-}
diff --git a/Android.bp b/Android.bp
deleted file mode 100644
index 79e8709..0000000
--- a/Android.bp
+++ /dev/null
@@ -1,40 +0,0 @@
-// This file is generated by cargo2android.py --config cargo2android.json.
-// Do not modify this file as changes will be overridden on upgrade.
-
-
-
-package {
- default_applicable_licenses: ["external_rust_crates_inflector_license"],
-}
-
-// Added automatically by a large-scale-change
-// See: http://go/android-license-faq
-license {
- name: "external_rust_crates_inflector_license",
- visibility: [":__subpackages__"],
- license_kinds: [
- "SPDX-license-identifier-BSD",
- ],
- license_text: [
- "LICENSE.md",
- ],
-}
-
-rust_library_host {
- name: "libinflector",
- crate_name: "inflector",
- cargo_env_compat: true,
- cargo_pkg_version: "0.11.4",
- srcs: ["src/lib.rs"],
- edition: "2015",
- features: [
- "default",
- "heavyweight",
- "lazy_static",
- "regex",
- ],
- rustlibs: [
- "liblazy_static",
- "libregex",
- ],
-}
diff --git a/Cargo.toml b/Cargo.toml
deleted file mode 100644
index 553f00f..0000000
--- a/Cargo.toml
+++ /dev/null
@@ -1,42 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g. crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-name = "Inflector"
-version = "0.11.4"
-authors = ["Josh Teeter<joshteeter@gmail.com>"]
-include = ["**/*.rs", "Cargo.toml", "README.md"]
-description = "Adds String based inflections for Rust. Snake, kebab, camel, sentence, class, title and table cases as well as ordinalize, deordinalize, demodulize, foreign key, and pluralize/singularize are supported as both traits and pure functions acting on String types.\n"
-homepage = "https://github.com/whatisinternet/inflector"
-documentation = "https://docs.rs/Inflector"
-readme = "README.md"
-keywords = ["pluralize", "Inflector", "camel", "snake", "inflection"]
-categories = ["text-processing", "value-formatting"]
-license = "BSD-2-Clause"
-repository = "https://github.com/whatisinternet/inflector"
-
-[lib]
-name = "inflector"
-[dependencies.lazy_static]
-version = "1.2.0"
-optional = true
-
-[dependencies.regex]
-version = "1.1"
-optional = true
-
-[features]
-default = ["heavyweight"]
-heavyweight = ["regex", "lazy_static"]
-unstable = []
-[badges.travis-ci]
-repository = "whatisinternet/Inflector"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
deleted file mode 100644
index 9458157..0000000
--- a/Cargo.toml.orig
+++ /dev/null
@@ -1,34 +0,0 @@
-[package]
-name = "Inflector"
-version = "0.11.4"
-authors = ["Josh Teeter<joshteeter@gmail.com>"]
-include = [
- "**/*.rs",
- "Cargo.toml",
- "README.md"
-]
-readme = "README.md"
-repository = "https://github.com/whatisinternet/inflector"
-documentation = "https://docs.rs/Inflector"
-homepage = "https://github.com/whatisinternet/inflector"
-license="BSD-2-Clause"
-description = """
-Adds String based inflections for Rust. Snake, kebab, camel, sentence, class, title and table cases as well as ordinalize, deordinalize, demodulize, foreign key, and pluralize/singularize are supported as both traits and pure functions acting on String types.
-"""
-keywords = ["pluralize", "Inflector", "camel", "snake", "inflection"]
-categories = ["text-processing", "value-formatting"]
-
-[badges]
-travis-ci = { repository = "whatisinternet/Inflector" }
-
-[features]
-default = ['heavyweight']
-unstable = []
-heavyweight = ['regex', 'lazy_static']
-
-[lib]
-name = "inflector"
-
-[dependencies]
-regex = {version = "1.1", optional = true}
-lazy_static = {version = "1.2.0", optional = true}
diff --git a/LICENSE b/LICENSE
deleted file mode 120000
index f0c4298..0000000
--- a/LICENSE
+++ /dev/null
@@ -1 +0,0 @@
-LICENSE.md
\ No newline at end of file
diff --git a/LICENSE.md b/LICENSE.md
deleted file mode 100644
index 937b1bd..0000000
--- a/LICENSE.md
+++ /dev/null
@@ -1,22 +0,0 @@
-Copyright 2017 Josh Teeter
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
-and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/METADATA b/METADATA
deleted file mode 100644
index 9cf6c81..0000000
--- a/METADATA
+++ /dev/null
@@ -1,19 +0,0 @@
-name: "Inflector"
-description: "Adds String based inflections for Rust. Snake, kebab, camel, sentence, class, title and table cases as well as ordinalize, deordinalize, demodulize, foreign key, and pluralize/singularize are supported as both traits and pure functions acting on String types."
-third_party {
- url {
- type: HOMEPAGE
- value: "https://crates.io/crates/Inflector"
- }
- url {
- type: ARCHIVE
- value: "https://static.crates.io/crates/Inflector/Inflector-0.11.4.crate"
- }
- version: "0.11.4"
- license_type: NOTICE
- last_upgrade_date {
- year: 2023
- month: 2
- day: 14
- }
-}
diff --git a/MODULE_LICENSE_BSD_LIKE b/MODULE_LICENSE_BSD_LIKE
deleted file mode 100644
index e69de29..0000000
--- a/MODULE_LICENSE_BSD_LIKE
+++ /dev/null
diff --git a/OWNERS b/OWNERS
deleted file mode 100644
index 45dc4dd..0000000
--- a/OWNERS
+++ /dev/null
@@ -1 +0,0 @@
-include platform/prebuilts/rust:master:/OWNERS
diff --git a/README.android b/README.android
deleted file mode 100644
index 366abc2..0000000
--- a/README.android
+++ /dev/null
@@ -1,13 +0,0 @@
-Steps taken to download this crate:
-
-1. `get_rust_pkg.py -add3prf Inflector`. This results in an error about missing license.
-
- ```
- FileNotFoundError: No license file has been found.
- ```
-
-2. Because LICENSE.md is not uploaded to the sources for crates.io, we download it from the
- corresponding GitHub repository: `cd Inflector-VERSION && wget https://raw.githubusercontent.com/whatisinternet/Inflector/master/LICENSE.md`
-3. Run `add3prf.py`
-4. Continue with the import review process.
-
diff --git a/README.md b/README.md
deleted file mode 100644
index db8de09..0000000
--- a/README.md
+++ /dev/null
@@ -1,136 +0,0 @@
-# Rust Inflector
-
-
-[](https://travis-ci.org/whatisinternet/Inflector) [](https://crates.io/crates/inflector)[](https://crates.io/crates/inflector)
-
-
-Adds String based inflections for Rust. Snake, kebab, train, camel,
-sentence, class, and title cases as well as ordinalize,
-deordinalize, demodulize, deconstantize, foreign key, table case, and pluralize/singularize are supported as both traits and pure functions
-acting on &str and String types.
-
------
-## Documentation:
-
-Documentation can be found here at the README or via rust docs below.
-
-[Rust docs with examples](https://docs.rs/Inflector)
-
------
-
-## Installation:
-
-### As a [crate](http://crates.io)
-
-```toml
-[dependencies]
-Inflector = "*"
-```
-
-### Compile yourself:
-
-1. Install [Rust and cargo](http://doc.crates.io/)
-2. git clone https://github.com/whatisinternet/Inflector
-3. Library: cd inflector && cargo build --release --lib
-4. You can find the library in target/release
-
-## Usage / Example:
-
-```rust
-...
-// to use methods like String.to_lower_case();
-extern crate inflector;
-use inflector::Inflector;
-...
-fn main() {
-...
- let camel_case_string: String = "some_string".to_camel_case();
-...
-}
-
-```
-
-Or
-
-```rust
-...
-// to use methods like to_snake_case(&str);
-extern crate inflector;
-
-// use inflector::cases::classcase::to_class_case;
-// use inflector::cases::classcase::is_class_case;
-
-// use inflector::cases::camelcase::to_camel_case;
-// use inflector::cases::camelcase::is_camel_case;
-
-// use inflector::cases::pascalcase::to_pascal_case;
-// use inflector::cases::pascalcase::is_pascal_case;
-
-// use inflector::cases::screamingsnakecase::to_screamingsnake_case;
-// use inflector::cases::screamingsnakecase::is_screamingsnake_case;
-
-// use inflector::cases::snakecase::to_snake_case;
-// use inflector::cases::snakecase::is_snake_case;
-
-// use inflector::cases::kebabcase::to_kebab_case;
-// use inflector::cases::kebabcase::is_kebab_case;
-
-// use inflector::cases::traincase::to_train_case;
-// use inflector::cases::traincase::is_train_case;
-
-// use inflector::cases::sentencecase::to_sentence_case;
-// use inflector::cases::sentencecase::is_sentence_case;
-
-// use inflector::cases::titlecase::to_title_case;
-// use inflector::cases::titlecase::is_title_case;
-
-// use inflector::cases::tablecase::to_table_case;
-// use inflector::cases::tablecase::is_table_case;
-
-// use inflector::numbers::ordinalize::ordinalize;
-// use inflector::numbers::deordinalize::deordinalize;
-
-// use inflector::suffix::foreignkey::to_foreign_key;
-// use inflector::suffix::foreignkey::is_foreign_key;
-
-// use inflector::string::demodulize::demodulize;
-// use inflector::string::deconstantize::deconstantize;
-
-// use inflector::string::pluralize::to_plural;
-// use inflector::string::singularize::to_singular;
-...
-fn main() {
-...
- let camel_case_string: String = to_camel_case("some_string");
-...
-}
-
-```
-
-## Advanced installation and usage:
-
-If the project doesn't require singularize, pluralize, class, table, demodulize,
-deconstantize. Then in your `cargo.toml` you may wish to specify:
-
-```toml
-[dependencies.Inflector]
-version = "*"
-default-features = false
-```
-
-Or
-
-```toml
-Inflector = {version="*", default-features=false}
-
-```
-
-To test this crate locally with features off try:
-
-```shell
-cargo test --no-default-features
-```
-
-## [Contributing](CONTRIBUTING.md)
-
-This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
diff --git a/cargo2android.json b/cargo2android.json
deleted file mode 100644
index 958632b..0000000
--- a/cargo2android.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
- "run": true
-}
\ No newline at end of file
diff --git a/src/cases/camelcase/mod.rs b/src/cases/camelcase/mod.rs
deleted file mode 100644
index b09ddc6..0000000
--- a/src/cases/camelcase/mod.rs
+++ /dev/null
@@ -1,370 +0,0 @@
-#![deny(warnings)]
-use cases::case::*;
-
-/// Converts a `&str` to camelCase `String`
-///
-/// ```
-/// use inflector::cases::camelcase::to_camel_case;
-/// let mock_string: &str = "fooBar";
-/// let expected_string: String = "fooBar".to_string();
-/// let asserted_string: String = to_camel_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::to_camel_case;
-/// let mock_string: &str = "FOO_BAR";
-/// let expected_string: String = "fooBar".to_string();
-/// let asserted_string: String = to_camel_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::to_camel_case;
-/// let mock_string: &str = "Foo Bar";
-/// let expected_string: String = "fooBar".to_string();
-/// let asserted_string: String = to_camel_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::to_camel_case;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "fooBar".to_string();
-/// let asserted_string: String = to_camel_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::to_camel_case;
-/// let mock_string: &str = "Foo bar";
-/// let expected_string: String = "fooBar".to_string();
-/// let asserted_string: String = to_camel_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::to_camel_case;
-/// let mock_string: &str = "foo-bar";
-/// let expected_string: String = "fooBar".to_string();
-/// let asserted_string: String = to_camel_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::to_camel_case;
-/// let mock_string: &str = "FooBar";
-/// let expected_string: String = "fooBar".to_string();
-/// let asserted_string: String = to_camel_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::to_camel_case;
-/// let mock_string: &str = "FooBar3";
-/// let expected_string: String = "fooBar3".to_string();
-/// let asserted_string: String = to_camel_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::to_camel_case;
-/// let mock_string: &str = "Foo-Bar";
-/// let expected_string: String = "fooBar".to_string();
-/// let asserted_string: String = to_camel_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn to_camel_case(non_camelized_string: &str) -> String {
- let options = CamelOptions {
- new_word: false,
- last_char: ' ',
- first_word: false,
- injectable_char: ' ',
- has_seperator: false,
- inverted: false,
- };
- to_case_camel_like(&non_camelized_string, options)
-}
-
-/// Determines if a `&str` is camelCase bool``
-///
-/// ```
-/// use inflector::cases::camelcase::is_camel_case;
-/// let mock_string: &str = "Foo";
-/// let asserted_bool: bool = is_camel_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::is_camel_case;
-/// let mock_string: &str = "foo";
-/// let asserted_bool: bool = is_camel_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::is_camel_case;
-/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
-/// let asserted_bool: bool = is_camel_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::is_camel_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_camel_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::is_camel_case;
-/// let mock_string: &str = "fooBarIsAReallyReally3LongString";
-/// let asserted_bool: bool = is_camel_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::is_camel_case;
-/// let mock_string: &str = "fooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_camel_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::is_camel_case;
-/// let mock_string: &str = "FOO_BAR_STRING_THAT_IS_REALLY_REALLY_LONG";
-/// let asserted_bool: bool = is_camel_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::is_camel_case;
-/// let mock_string: &str = "foo_bar_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_camel_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::is_camel_case;
-/// let mock_string: &str = "Foo bar string that is really really long";
-/// let asserted_bool: bool = is_camel_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::camelcase::is_camel_case;
-/// let mock_string: &str = "Foo Bar Is A Really Really Long String";
-/// let asserted_bool: bool = is_camel_case(mock_string);
-/// assert!(asserted_bool == false);
-/// ```
-pub fn is_camel_case(test_string: &str) -> bool {
- to_camel_case(&test_string.clone()) == test_string
-}
-
-#[cfg(all(feature = "unstable", test))]
-mod benchmarks {
- extern crate test;
- use self::test::Bencher;
-
- #[bench]
- fn bench_camel0(b: &mut Bencher) {
- b.iter(|| {
- let test_string = "Foo bar";
- super::to_camel_case(test_string)
- });
- }
-
- #[bench]
- fn bench_camel1(b: &mut Bencher) {
- b.iter(|| {
- let test_string = "foo_bar";
- super::to_camel_case(test_string)
- });
- }
-
- #[bench]
- fn bench_camel2(b: &mut Bencher) {
- b.iter(|| {
- let test_string = "fooBar";
- super::to_camel_case(test_string)
- });
- }
-
- #[bench]
- fn bench_is_camel(b: &mut Bencher) {
- b.iter(|| {
- let test_string: &str = "Foo bar";
- super::is_camel_case(test_string)
- });
- }
-}
-
-#[cfg(test)]
-mod tests {
- use ::to_camel_case;
- use ::is_camel_case;
-
- #[test]
- fn from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- let expected: String = "fooBar".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- let expected: String = "fooBar".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- let expected: String = "fooBar".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- let expected: String = "fooBar".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- let expected: String = "fooBar".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- let expected: String = "fooBar".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- let expected: String = "fooBar".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- let expected: String = "fooBar".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_case_with_loads_of_space() {
- let convertable_string: String = "foo bar".to_owned();
- let expected: String = "fooBar".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn a_name_with_a_dot() {
- let convertable_string: String = "Robert C. Martin".to_owned();
- let expected: String = "robertCMartin".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn random_text_with_bad_chars() {
- let convertable_string: String = "Random text with *(bad) chars".to_owned();
- let expected: String = "randomTextWithBadChars".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn trailing_bad_chars() {
- let convertable_string: String = "trailing bad_chars*(()())".to_owned();
- let expected: String = "trailingBadChars".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn leading_bad_chars() {
- let convertable_string: String = "-!#$%leading bad chars".to_owned();
- let expected: String = "leadingBadChars".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn wrapped_in_bad_chars() {
- let convertable_string: String = "-!#$%wrapped in bad chars&*^*&(&*^&(<><?>><?><>))".to_owned();
- let expected: String = "wrappedInBadChars".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn has_a_sign() {
- let convertable_string: String = "has a + sign".to_owned();
- let expected: String = "hasASign".to_owned();
- assert_eq!(to_camel_case(&convertable_string), expected)
- }
-
- #[test]
- fn is_correct_from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- assert_eq!(is_camel_case(&convertable_string), true)
- }
-
- #[test]
- fn is_correct_from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- assert_eq!(is_camel_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- assert_eq!(is_camel_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- assert_eq!(is_camel_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- assert_eq!(is_camel_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- assert_eq!(is_camel_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- assert_eq!(is_camel_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- assert_eq!(is_camel_case(&convertable_string), false)
- }
-}
-
diff --git a/src/cases/case/mod.rs b/src/cases/case/mod.rs
deleted file mode 100644
index bb4c3d2..0000000
--- a/src/cases/case/mod.rs
+++ /dev/null
@@ -1,303 +0,0 @@
-#![deny(warnings)]
-#[allow(unknown_lints)]
-#[allow(unused_imports)]
-use std::ascii::*;
-
-pub struct CamelOptions {
- pub new_word: bool,
- pub last_char: char,
- pub first_word: bool,
- pub injectable_char: char,
- pub has_seperator: bool,
- pub inverted: bool,
-}
-
-pub fn to_case_snake_like(convertable_string: &str, replace_with: &str, case: &str) -> String {
- let mut first_character: bool = true;
- let mut result: String = String::with_capacity(convertable_string.len() * 2);
- for char_with_index in trim_right(convertable_string).char_indices() {
- if char_is_seperator(&char_with_index.1) {
- if !first_character {
- first_character = true;
- result.push(replace_with.chars().nth(0).unwrap_or('_'));
- }
- } else if requires_seperator(char_with_index, first_character, &convertable_string) {
- first_character = false;
- result = snake_like_with_seperator(result, replace_with, &char_with_index.1, case)
- } else {
- first_character = false;
- result = snake_like_no_seperator(result, &char_with_index.1, case)
- }
- }
- result
-}
-
-pub fn to_case_camel_like(convertable_string: &str, camel_options: CamelOptions) -> String {
- let mut new_word: bool = camel_options.new_word;
- let mut first_word: bool = camel_options.first_word;
- let mut last_char: char = camel_options.last_char;
- let mut found_real_char: bool = false;
- let mut result: String = String::with_capacity(convertable_string.len() * 2);
- for character in trim_right(convertable_string).chars() {
- if char_is_seperator(&character) && found_real_char {
- new_word = true;
- } else if !found_real_char && is_not_alphanumeric(character) {
- continue;
- } else if character.is_numeric() {
- found_real_char = true;
- new_word = true;
- result.push(character);
- } else if last_char_lower_current_is_upper_or_new_word(new_word, last_char, character) {
- found_real_char = true;
- new_word = false;
- result = append_on_new_word(result, first_word, character, &camel_options);
- first_word = false;
- } else {
- found_real_char = true;
- last_char = character;
- result.push(character.to_ascii_lowercase());
- }
- }
- result
-}
-
-#[inline]
-fn append_on_new_word(mut result: String, first_word: bool, character: char, camel_options: &CamelOptions) -> String {
- if not_first_word_and_has_seperator(first_word, camel_options.has_seperator) {
- result.push(camel_options.injectable_char);
- }
- if first_word_or_not_inverted(first_word, camel_options.inverted) {
- result.push(character.to_ascii_uppercase());
- } else {
- result.push(character.to_ascii_lowercase());
- }
- result
-}
-
-fn not_first_word_and_has_seperator(first_word: bool, has_seperator: bool) -> bool {
- has_seperator && !first_word
-}
-
-fn first_word_or_not_inverted(first_word: bool, inverted: bool) -> bool {
- !inverted || first_word
-}
-
-
-fn last_char_lower_current_is_upper_or_new_word(new_word: bool, last_char: char, character: char) -> bool{
- new_word ||
- ((last_char.is_lowercase() && character.is_uppercase()) &&
- (last_char != ' '))
-}
-
-fn char_is_seperator(character: &char) -> bool {
- is_not_alphanumeric(*character)
-}
-
-fn trim_right(convertable_string: &str) -> &str {
- convertable_string.trim_end_matches(is_not_alphanumeric)
-}
-
-fn is_not_alphanumeric(character: char) -> bool {
- !character.is_alphanumeric()
-}
-
-#[inline]
-fn requires_seperator(char_with_index: (usize, char), first_character: bool, convertable_string: &str) -> bool {
- !first_character &&
- char_is_uppercase(char_with_index.1) &&
- next_or_previous_char_is_lowercase(convertable_string, char_with_index.0)
-}
-
-#[inline]
-fn snake_like_no_seperator(mut accumlator: String, current_char: &char, case: &str) -> String {
- if case == "lower" {
- accumlator.push(current_char.to_ascii_lowercase());
- accumlator
- } else {
- accumlator.push(current_char.to_ascii_uppercase());
- accumlator
- }
-}
-
-#[inline]
-fn snake_like_with_seperator(mut accumlator: String, replace_with: &str, current_char: &char, case: &str) -> String {
- if case == "lower" {
- accumlator.push(replace_with.chars().nth(0).unwrap_or('_'));
- accumlator.push(current_char.to_ascii_lowercase());
- accumlator
- } else {
- accumlator.push(replace_with.chars().nth(0).unwrap_or('_'));
- accumlator.push(current_char.to_ascii_uppercase());
- accumlator
- }
-}
-
-fn next_or_previous_char_is_lowercase(convertable_string: &str, char_with_index: usize) -> bool {
- convertable_string.chars().nth(char_with_index + 1).unwrap_or('A').is_lowercase() ||
- convertable_string.chars().nth(char_with_index - 1).unwrap_or('A').is_lowercase()
-}
-
-fn char_is_uppercase(test_char: char) -> bool {
- test_char == test_char.to_ascii_uppercase()
-}
-
-#[test]
-fn test_trim_bad_chars() {
- assert_eq!("abc", trim_right("abc----^"))
-}
-
-#[test]
-fn test_trim_bad_chars_when_none_are_bad() {
- assert_eq!("abc", trim_right("abc"))
-}
-
-#[test]
-fn test_is_not_alphanumeric_on_is_alphanumeric() {
- assert!(!is_not_alphanumeric('a'))
-}
-
-#[test]
-fn test_is_not_alphanumeric_on_is_not_alphanumeric() {
- assert!(is_not_alphanumeric('_'))
-}
-
-
-#[test]
-fn test_char_is_uppercase_when_it_is() {
- assert_eq!(char_is_uppercase('A'), true)
-}
-
-#[test]
-fn test_char_is_uppercase_when_it_is_not() {
- assert_eq!(char_is_uppercase('a'), false)
-}
-
-#[test]
-fn test_next_or_previous_char_is_lowercase_true() {
- assert_eq!(next_or_previous_char_is_lowercase("TestWWW", 3), true)
-}
-
-#[test]
-fn test_next_or_previous_char_is_lowercase_false() {
- assert_eq!(next_or_previous_char_is_lowercase("TestWWW", 5), false)
-}
-
-#[test]
-fn snake_like_with_seperator_lowers() {
- assert_eq!(snake_like_with_seperator("".to_owned(), "^", &'c', "lower"), "^c".to_string())
-}
-
-#[test]
-fn snake_like_with_seperator_upper() {
- assert_eq!(snake_like_with_seperator("".to_owned(), "^", &'c', "upper"), "^C".to_string())
-}
-
-#[test]
-fn snake_like_no_seperator_lower() {
- assert_eq!(snake_like_no_seperator("".to_owned(), &'C', "lower"), "c".to_string())
-}
-
-#[test]
-fn snake_like_no_seperator_upper() {
- assert_eq!(snake_like_no_seperator("".to_owned(), &'c', "upper"), "C".to_string())
-}
-
-#[test]
-fn requires_seperator_upper_not_first_wrap_is_safe_current_upper() {
- assert_eq!(requires_seperator((2, 'C'), false, "test"), true)
-}
-
-#[test]
-fn requires_seperator_upper_not_first_wrap_is_safe_current_lower() {
- assert_eq!(requires_seperator((2, 'c'), false, "test"), false)
-}
-
-#[test]
-fn requires_seperator_upper_first_wrap_is_safe_current_upper() {
- assert_eq!(requires_seperator((0, 'T'), true, "Test"), false)
-}
-
-#[test]
-fn requires_seperator_upper_first_wrap_is_safe_current_lower() {
- assert_eq!(requires_seperator((0, 't'), true, "Test"), false)
-}
-
-#[test]
-fn requires_seperator_upper_first_wrap_is_safe_current_lower_next_is_too() {
- assert_eq!(requires_seperator((0, 't'), true, "test"), false)
-}
-
-#[test]
-fn test_char_is_seperator_dash() {
- assert_eq!(char_is_seperator(&'-'), true)
-}
-
-#[test]
-fn test_char_is_seperator_underscore() {
- assert_eq!(char_is_seperator(&'_'), true)
-}
-
-#[test]
-fn test_char_is_seperator_space() {
- assert_eq!(char_is_seperator(&' '), true)
-}
-
-#[test]
-fn test_char_is_seperator_when_not() {
- assert_eq!(char_is_seperator(&'A'), false)
-}
-
-#[test]
-fn test_last_char_lower_current_is_upper_or_new_word_with_new_word() {
- assert_eq!(last_char_lower_current_is_upper_or_new_word(true, ' ', '-'), true)
-}
-
-#[test]
-fn test_last_char_lower_current_is_upper_or_new_word_last_char_space() {
- assert_eq!(last_char_lower_current_is_upper_or_new_word(false, ' ', '-'), false)
-}
-
-#[test]
-fn test_last_char_lower_current_is_upper_or_new_word_last_char_lower_current_upper() {
- assert_eq!(last_char_lower_current_is_upper_or_new_word(false, 'a', 'A'), true)
-}
-
-#[test]
-fn test_last_char_lower_current_is_upper_or_new_word_last_char_upper_current_upper() {
- assert_eq!(last_char_lower_current_is_upper_or_new_word(false, 'A', 'A'), false)
-}
-
-#[test]
-fn test_last_char_lower_current_is_upper_or_new_word_last_char_upper_current_lower() {
- assert_eq!(last_char_lower_current_is_upper_or_new_word(false, 'A', 'a'), false)
-}
-
-#[test]
-fn test_first_word_or_not_inverted_with_first_word() {
- assert_eq!(first_word_or_not_inverted(true, false), true)
-}
-
-#[test]
-fn test_first_word_or_not_inverted_not_first_word_not_inverted() {
- assert_eq!(first_word_or_not_inverted(false, false), true)
-}
-
-#[test]
-fn test_first_word_or_not_inverted_not_first_word_is_inverted() {
- assert_eq!(first_word_or_not_inverted(false, true), false)
-}
-
-#[test]
-fn test_not_first_word_and_has_seperator_is_first_and_not_seperator() {
- assert_eq!(not_first_word_and_has_seperator(true, false), false)
-}
-
-#[test]
-fn test_not_first_word_and_has_seperator_not_first_and_not_seperator() {
- assert_eq!(not_first_word_and_has_seperator(false, false), false)
-}
-
-#[test]
-fn test_not_first_word_and_has_seperator_not_first_and_has_seperator() {
- assert_eq!(not_first_word_and_has_seperator(false, true), true)
-}
diff --git a/src/cases/classcase/mod.rs b/src/cases/classcase/mod.rs
deleted file mode 100644
index e0b6ef6..0000000
--- a/src/cases/classcase/mod.rs
+++ /dev/null
@@ -1,393 +0,0 @@
-#![deny(warnings)]
-use cases::case::*;
-#[cfg(feature = "heavyweight")]
-use string::singularize::to_singular;
-#[cfg(feature = "heavyweight")]
-/// Converts a `&str` to `ClassCase` `String`
-///
-/// ```
-/// use inflector::cases::classcase::to_class_case;
-/// let mock_string: &str = "FooBar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_class_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::to_class_case;
-/// let mock_string: &str = "FooBars";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_class_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::to_class_case;
-/// let mock_string: &str = "Foo Bar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_class_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::to_class_case;
-/// let mock_string: &str = "foo-bar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_class_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::to_class_case;
-/// let mock_string: &str = "fooBar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_class_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::to_class_case;
-/// let mock_string: &str = "FOO_BAR";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_class_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::to_class_case;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_class_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::to_class_case;
-/// let mock_string: &str = "foo_bars";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_class_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::to_class_case;
-/// let mock_string: &str = "Foo bar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_class_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn to_class_case(non_class_case_string: &str) -> String {
- let options = CamelOptions {
- new_word: true,
- last_char: ' ',
- first_word: false,
- injectable_char: ' ',
- has_seperator: false,
- inverted: false,
- };
- let class_plural = to_case_camel_like(non_class_case_string, options);
- let split: (&str, &str) =
- class_plural.split_at(class_plural.rfind(char::is_uppercase).unwrap_or(0));
- format!("{}{}", split.0, to_singular(split.1))
-}
-
-#[cfg(feature = "heavyweight")]
-/// Determines if a `&str` is `ClassCase` `bool`
-///
-/// ```
-/// use inflector::cases::classcase::is_class_case;
-/// let mock_string: &str = "Foo";
-/// let asserted_bool: bool = is_class_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::is_class_case;
-/// let mock_string: &str = "foo";
-/// let asserted_bool: bool = is_class_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::is_class_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongStrings";
-/// let asserted_bool: bool = is_class_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-///
-/// ```
-/// use inflector::cases::classcase::is_class_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_class_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::is_class_case;
-/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
-/// let asserted_bool: bool = is_class_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::is_class_case;
-/// let mock_string: &str = "foo_bar_is_a_really_really_long_strings";
-/// let asserted_bool: bool = is_class_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-///
-/// ```
-/// use inflector::cases::classcase::is_class_case;
-/// let mock_string: &str = "fooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_class_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::is_class_case;
-/// let mock_string: &str = "FOO_BAR_STRING_THAT_IS_REALLY_REALLY_LONG";
-/// let asserted_bool: bool = is_class_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::is_class_case;
-/// let mock_string: &str = "foo_bar_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_class_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::is_class_case;
-/// let mock_string: &str = "Foo bar string that is really really long";
-/// let asserted_bool: bool = is_class_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::classcase::is_class_case;
-/// let mock_string: &str = "Foo Bar Is A Really Really Long String";
-/// let asserted_bool: bool = is_class_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-pub fn is_class_case(test_string: &str) -> bool {
- to_class_case(&test_string.clone()) == test_string
-}
-
-#[cfg(all(feature = "unstable", test))]
-#[cfg(feature = "heavyweight")]
-mod benchmarks {
- extern crate test;
- use self::test::Bencher;
-
- #[bench]
- fn bench_class_case(b: &mut Bencher) {
- b.iter(|| super::to_class_case("Foo bar"));
- }
-
- #[bench]
- fn bench_is_class(b: &mut Bencher) {
- b.iter(|| super::is_class_case("Foo bar"));
- }
-
- #[bench]
- fn bench_class_from_snake(b: &mut Bencher) {
- b.iter(|| super::to_class_case("foo_bar"));
- }
-}
-
-#[cfg(test)]
-#[cfg(feature = "heavyweight")]
-mod tests {
- use ::to_class_case;
- use ::is_class_case;
-
- #[test]
- fn from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_screaming_class_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_table_case() {
- let convertable_string: String = "foo_bars".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_case_with_loads_of_space() {
- let convertable_string: String = "foo bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn a_name_with_a_dot() {
- let convertable_string: String = "Robert C. Martin".to_owned();
- let expected: String = "RobertCMartin".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn random_text_with_bad_chars() {
- let convertable_string: String = "Random text with *(bad) chars".to_owned();
- let expected: String = "RandomTextWithBadChar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn trailing_bad_chars() {
- let convertable_string: String = "trailing bad_chars*(()())".to_owned();
- let expected: String = "TrailingBadChar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn leading_bad_chars() {
- let convertable_string: String = "-!#$%leading bad chars".to_owned();
- let expected: String = "LeadingBadChar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn wrapped_in_bad_chars() {
- let convertable_string: String = "-!#$%wrapped in bad chars&*^*&(&*^&(<><?>><?><>))".to_owned();
- let expected: String = "WrappedInBadChar".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn has_a_sign() {
- let convertable_string: String = "has a + sign".to_owned();
- let expected: String = "HasASign".to_owned();
- assert_eq!(to_class_case(&convertable_string), expected)
- }
-
- #[test]
- fn is_correct_from_class_case() {
- let convertable_string: String = "fooBar".to_owned();
- assert_eq!(is_class_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- assert_eq!(is_class_case(&convertable_string), true)
- }
-
- #[test]
- fn is_correct_from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- assert_eq!(is_class_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- assert_eq!(is_class_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- assert_eq!(is_class_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- assert_eq!(is_class_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- assert_eq!(is_class_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- assert_eq!(is_class_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_table_case() {
- let convertable_string: String = "FooBar".to_owned();
- assert_eq!(is_class_case(&convertable_string), true)
- }
-}
-
diff --git a/src/cases/kebabcase/mod.rs b/src/cases/kebabcase/mod.rs
deleted file mode 100644
index d79f273..0000000
--- a/src/cases/kebabcase/mod.rs
+++ /dev/null
@@ -1,262 +0,0 @@
-#![deny(warnings)]
-use cases::case::*;
-/// Determines if a `&str` is `kebab-case`
-///
-/// ```
-/// use inflector::cases::kebabcase::is_kebab_case;
-/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
-/// let asserted_bool: bool = is_kebab_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::is_kebab_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_kebab_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::is_kebab_case;
-/// let mock_string: &str = "fooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_kebab_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::is_kebab_case;
-/// let mock_string: &str = "FOO_BAR_STRING_THAT_IS_REALLY_REALLY_LONG";
-/// let asserted_bool: bool = is_kebab_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::is_kebab_case;
-/// let mock_string: &str = "foo_bar_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_kebab_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::is_kebab_case;
-/// let mock_string: &str = "Foo bar string that is really really long";
-/// let asserted_bool: bool = is_kebab_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::is_kebab_case;
-/// let mock_string: &str = "Foo Bar Is A Really Really Long String";
-/// let asserted_bool: bool = is_kebab_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-pub fn is_kebab_case(test_string: &str) -> bool {
- test_string == to_kebab_case(test_string.clone())
-}
-
-/// Converts a `&str` to `kebab-case` `String`
-///
-/// ```
-/// use inflector::cases::kebabcase::to_kebab_case;
-/// let mock_string: &str = "foo-bar";
-/// let expected_string: String = "foo-bar".to_string();
-/// let asserted_string: String = to_kebab_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::to_kebab_case;
-/// let mock_string: &str = "FOO_BAR";
-/// let expected_string: String = "foo-bar".to_string();
-/// let asserted_string: String = to_kebab_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::to_kebab_case;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "foo-bar".to_string();
-/// let asserted_string: String = to_kebab_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::to_kebab_case;
-/// let mock_string: &str = "Foo Bar";
-/// let expected_string: String = "foo-bar".to_string();
-/// let asserted_string: String = to_kebab_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::to_kebab_case;
-/// let mock_string: &str = "Foo bar";
-/// let expected_string: String = "foo-bar".to_string();
-/// let asserted_string: String = to_kebab_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::to_kebab_case;
-/// let mock_string: &str = "FooBar";
-/// let expected_string: String = "foo-bar".to_string();
-/// let asserted_string: String = to_kebab_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::kebabcase::to_kebab_case;
-/// let mock_string: &str = "fooBar";
-/// let expected_string: String = "foo-bar".to_string();
-/// let asserted_string: String = to_kebab_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn to_kebab_case(non_kebab_case_string: &str) -> String {
- to_case_snake_like(non_kebab_case_string, "-", "lower")
-}
-
-#[cfg(all(feature = "unstable", test))]
-mod benchmarks {
- extern crate test;
- use self::test::Bencher;
-
- #[bench]
- fn bench_kebab(b: &mut Bencher) {
- b.iter(|| super::to_kebab_case("Foo bar"));
- }
-
- #[bench]
- fn bench_is_kebab(b: &mut Bencher) {
- b.iter(|| super::is_kebab_case("Foo bar"));
- }
-
- #[bench]
- fn bench_kebab_from_snake(b: &mut Bencher) {
- b.iter(|| super::to_kebab_case("test_test_test"));
- }
-}
-
-#[cfg(test)]
-mod tests {
- use ::to_kebab_case;
- use ::is_kebab_case;
-
- #[test]
- fn from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- let expected: String = "foo-bar".to_owned();
- assert_eq!(to_kebab_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- let expected: String = "foo-bar".to_owned();
- assert_eq!(to_kebab_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- let expected: String = "foo-bar".to_owned();
- assert_eq!(to_kebab_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- let expected: String = "foo-bar".to_owned();
- assert_eq!(to_kebab_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- let expected: String = "foo-bar".to_owned();
- assert_eq!(to_kebab_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- let expected: String = "foo-bar".to_owned();
- assert_eq!(to_kebab_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- let expected: String = "foo-bar".to_owned();
- assert_eq!(to_kebab_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- let expected: String = "foo-bar".to_owned();
- assert_eq!(to_kebab_case(&convertable_string), expected)
- }
-
- #[test]
- fn is_correct_from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- assert_eq!(is_kebab_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- assert_eq!(is_kebab_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- assert_eq!(is_kebab_case(&convertable_string), true)
- }
-
- #[test]
- fn is_correct_from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- assert_eq!(is_kebab_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- assert_eq!(is_kebab_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- assert_eq!(is_kebab_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- assert_eq!(is_kebab_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- assert_eq!(is_kebab_case(&convertable_string), false)
- }
-}
-
diff --git a/src/cases/mod.rs b/src/cases/mod.rs
deleted file mode 100644
index dfa772e..0000000
--- a/src/cases/mod.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-mod case;
-/// Provides conversion to and detection of class case strings.
-///
-/// This version singularizes strings.
-///
-/// Example string `ClassCase`
-pub mod classcase;
-
-/// Provides conversion to and detection of camel case strings.
-///
-/// Example string `camelCase`
-pub mod camelcase;
-
-/// Provides conversion to and detection of snake case strings.
-///
-/// Example string `snake_case`
-pub mod snakecase;
-
-/// Provides conversion to and detection of screaming snake case strings.
-///
-/// Example string `SCREAMING_SNAKE_CASE`
-pub mod screamingsnakecase;
-
-/// Provides conversion to and detection of kebab case strings.
-///
-/// Example string `kebab-case`
-pub mod kebabcase;
-
-/// Provides conversion to and detection of train case strings.
-///
-/// Example string `Train-Case`
-pub mod traincase;
-
-/// Provides conversion to and detection of sentence case strings.
-///
-/// Example string `Sentence case`
-pub mod sentencecase;
-
-/// Provides conversion to and detection of title case strings.
-///
-/// Example string `Title Case`
-pub mod titlecase;
-
-/// Provides conversion to and detection of table case strings.
-///
-/// Example string `table_cases`
-pub mod tablecase;
-
-/// Provides conversion to pascal case strings.
-///
-/// Example string `PascalCase`
-pub mod pascalcase;
diff --git a/src/cases/pascalcase/mod.rs b/src/cases/pascalcase/mod.rs
deleted file mode 100644
index 248f91a..0000000
--- a/src/cases/pascalcase/mod.rs
+++ /dev/null
@@ -1,360 +0,0 @@
-#![deny(warnings)]
-use cases::case::*;
-/// Converts a `&str` to pascalCase `String`
-///
-/// ```
-/// use inflector::cases::pascalcase::to_pascal_case;
-/// let mock_string: &str = "fooBar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_pascal_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::to_pascal_case;
-/// let mock_string: &str = "FOO_BAR";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_pascal_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::to_pascal_case;
-/// let mock_string: &str = "Foo Bar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_pascal_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::to_pascal_case;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_pascal_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::to_pascal_case;
-/// let mock_string: &str = "Foo bar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_pascal_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::to_pascal_case;
-/// let mock_string: &str = "foo-bar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_pascal_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::to_pascal_case;
-/// let mock_string: &str = "FooBar";
-/// let expected_string: String = "FooBar".to_string();
-/// let asserted_string: String = to_pascal_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::to_pascal_case;
-/// let mock_string: &str = "FooBar3";
-/// let expected_string: String = "FooBar3".to_string();
-/// let asserted_string: String = to_pascal_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn to_pascal_case(non_pascalized_string: &str) -> String {
- let options = CamelOptions {
- new_word: true,
- last_char: ' ',
- first_word: false,
- injectable_char: ' ',
- has_seperator: false,
- inverted: false,
- };
- to_case_camel_like(non_pascalized_string, options)
-}
-
-/// Determines if a `&str` is pascalCase bool``
-///
-/// ```
-/// use inflector::cases::pascalcase::is_pascal_case;
-/// let mock_string: &str = "Foo";
-/// let asserted_bool: bool = is_pascal_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::is_pascal_case;
-/// let mock_string: &str = "foo";
-/// let asserted_bool: bool = is_pascal_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::is_pascal_case;
-/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
-/// let asserted_bool: bool = is_pascal_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::is_pascal_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_pascal_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::is_pascal_case;
-/// let mock_string: &str = "FooBarIsAReallyReally3LongString";
-/// let asserted_bool: bool = is_pascal_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::is_pascal_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_pascal_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::is_pascal_case;
-/// let mock_string: &str = "FOO_BAR_STRING_THAT_IS_REALLY_REALLY_LONG";
-/// let asserted_bool: bool = is_pascal_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::is_pascal_case;
-/// let mock_string: &str = "foo_bar_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_pascal_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::is_pascal_case;
-/// let mock_string: &str = "Foo bar string that is really really long";
-/// let asserted_bool: bool = is_pascal_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-///
-/// ```
-/// ```
-/// use inflector::cases::pascalcase::is_pascal_case;
-/// let mock_string: &str = "Foo Bar Is A Really Really Long String";
-/// let asserted_bool: bool = is_pascal_case(mock_string);
-/// assert!(asserted_bool == false);
-/// ```
-pub fn is_pascal_case(test_string: &str) -> bool {
- to_pascal_case(test_string.clone()) == test_string
-}
-
-#[cfg(all(feature = "unstable", test))]
-mod benchmarks {
- extern crate test;
- use self::test::Bencher;
-
- #[bench]
- fn bench_pascal0(b: &mut Bencher) {
- b.iter(|| {
- let test_string = "Foo bar";
- super::to_pascal_case(test_string)
- });
- }
-
- #[bench]
- fn bench_pascal1(b: &mut Bencher) {
- b.iter(|| {
- let test_string = "foo_bar";
- super::to_pascal_case(test_string)
- });
- }
-
- #[bench]
- fn bench_pascal2(b: &mut Bencher) {
- b.iter(|| {
- let test_string = "fooBar";
- super::to_pascal_case(test_string)
- });
- }
-
- #[bench]
- fn bench_is_pascal(b: &mut Bencher) {
- b.iter(|| {
- let test_string: &str = "Foo bar";
- super::is_pascal_case(test_string)
- });
- }
-}
-
-#[cfg(test)]
-mod tests {
- use ::to_pascal_case;
- use ::is_pascal_case;
-
- #[test]
- fn from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_case_with_loads_of_space() {
- let convertable_string: String = "foo bar".to_owned();
- let expected: String = "FooBar".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn a_name_with_a_dot() {
- let convertable_string: String = "Robert C. Martin".to_owned();
- let expected: String = "RobertCMartin".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn random_text_with_bad_chars() {
- let convertable_string: String = "Random text with *(bad) chars".to_owned();
- let expected: String = "RandomTextWithBadChars".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn trailing_bad_chars() {
- let convertable_string: String = "trailing bad_chars*(()())".to_owned();
- let expected: String = "TrailingBadChars".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn leading_bad_chars() {
- let convertable_string: String = "-!#$%leading bad chars".to_owned();
- let expected: String = "LeadingBadChars".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn wrapped_in_bad_chars() {
- let convertable_string: String = "-!#$%wrapped in bad chars&*^*&(&*^&(<><?>><?><>))".to_owned();
- let expected: String = "WrappedInBadChars".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn has_a_sign() {
- let convertable_string: String = "has a + sign".to_owned();
- let expected: String = "HasASign".to_owned();
- assert_eq!(to_pascal_case(&convertable_string), expected)
- }
-
- #[test]
- fn is_correct_from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- assert_eq!(is_pascal_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- assert_eq!(is_pascal_case(&convertable_string), true)
- }
-
- #[test]
- fn is_correct_from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- assert_eq!(is_pascal_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- assert_eq!(is_pascal_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- assert_eq!(is_pascal_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- assert_eq!(is_pascal_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- assert_eq!(is_pascal_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- assert_eq!(is_pascal_case(&convertable_string), false)
- }
-}
diff --git a/src/cases/screamingsnakecase/mod.rs b/src/cases/screamingsnakecase/mod.rs
deleted file mode 100644
index 9bec7a5..0000000
--- a/src/cases/screamingsnakecase/mod.rs
+++ /dev/null
@@ -1,253 +0,0 @@
-#![deny(warnings)]
-use cases::case::*;
-/// Converts a `&str` to `SCREAMING_SNAKE_CASE` `String`
-///
-/// ```
-/// use inflector::cases::screamingsnakecase::to_screaming_snake_case;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "FOO_BAR".to_string();
-/// let asserted_string: String = to_screaming_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::to_screaming_snake_case;
-/// let mock_string: &str = "HTTP Foo bar";
-/// let expected_string: String = "HTTP_FOO_BAR".to_string();
-/// let asserted_string: String = to_screaming_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::to_screaming_snake_case;
-/// let mock_string: &str = "Foo bar";
-/// let expected_string: String = "FOO_BAR".to_string();
-/// let asserted_string: String = to_screaming_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::to_screaming_snake_case;
-/// let mock_string: &str = "Foo Bar";
-/// let expected_string: String = "FOO_BAR".to_string();
-/// let asserted_string: String = to_screaming_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::to_screaming_snake_case;
-/// let mock_string: &str = "FooBar";
-/// let expected_string: String = "FOO_BAR".to_string();
-/// let asserted_string: String = to_screaming_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::to_screaming_snake_case;
-/// let mock_string: &str = "fooBar";
-/// let expected_string: String = "FOO_BAR".to_string();
-/// let asserted_string: String = to_screaming_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::to_screaming_snake_case;
-/// let mock_string: &str = "fooBar3";
-/// let expected_string: String = "FOO_BAR_3".to_string();
-/// let asserted_string: String = to_screaming_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn to_screaming_snake_case(non_snake_case_string: &str) -> String {
- to_case_snake_like(non_snake_case_string, "_", "upper")
-}
-
-/// Determines of a `&str` is `SCREAMING_SNAKE_CASE`
-///
-/// ```
-/// use inflector::cases::screamingsnakecase::is_screaming_snake_case;
-/// let mock_string: &str = "Foo bar string that is really really long";
-/// let asserted_bool: bool = is_screaming_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::is_screaming_snake_case;
-/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
-/// let asserted_bool: bool = is_screaming_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::is_screaming_snake_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_screaming_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::is_screaming_snake_case;
-/// let mock_string: &str = "Foo Bar Is A Really Really Long String";
-/// let asserted_bool: bool = is_screaming_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::is_screaming_snake_case;
-/// let mock_string: &str = "fooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_screaming_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::is_screaming_snake_case;
-/// let mock_string: &str = "FOO_BAR_STRING_THAT_IS_REALLY_REALLY_LONG";
-/// let asserted_bool: bool = is_screaming_snake_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::is_screaming_snake_case;
-/// let mock_string: &str = "FOO_BAR1_STRING_THAT_IS_REALLY_REALLY_LONG";
-/// let asserted_bool: bool = is_screaming_snake_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-/// ```
-/// use inflector::cases::screamingsnakecase::is_screaming_snake_case;
-/// let mock_string: &str = "FOO_BAR_1_STRING_THAT_IS_REALLY_REALLY_LONG";
-/// let asserted_bool: bool = is_screaming_snake_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-pub fn is_screaming_snake_case(test_string: &str) -> bool {
- test_string == to_screaming_snake_case(test_string.clone())
-}
-
-
-#[cfg(all(feature = "unstable", test))]
-mod benchmarks {
- extern crate test;
- use self::test::Bencher;
-
- #[bench]
- fn bench_screaming_snake(b: &mut Bencher) {
- b.iter(|| super::to_screaming_snake_case("Foo bar"));
- }
-
- #[bench]
- fn bench_is_screaming_snake(b: &mut Bencher) {
- b.iter(|| super::is_screaming_snake_case("Foo bar"));
- }
-
-}
-
-#[cfg(test)]
-mod tests {
- use ::to_screaming_snake_case;
- use ::is_screaming_snake_case;
-
- #[test]
- fn from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- let expected: String = "FOO_BAR".to_owned();
- assert_eq!(to_screaming_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- let expected: String = "FOO_BAR".to_owned();
- assert_eq!(to_screaming_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- let expected: String = "FOO_BAR".to_owned();
- assert_eq!(to_screaming_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- let expected: String = "FOO_BAR".to_owned();
- assert_eq!(to_screaming_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- let expected: String = "FOO_BAR".to_owned();
- assert_eq!(to_screaming_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- let expected: String = "FOO_BAR".to_owned();
- assert_eq!(to_screaming_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_screaming_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- let expected: String = "FOO_BAR".to_owned();
- assert_eq!(to_screaming_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- let expected: String = "FOO_BAR".to_owned();
- assert_eq!(to_screaming_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn is_correct_from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- assert_eq!(is_screaming_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- assert_eq!(is_screaming_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- assert_eq!(is_screaming_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- assert_eq!(is_screaming_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- assert_eq!(is_screaming_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- assert_eq!(is_screaming_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_screaming_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- assert_eq!(is_screaming_snake_case(&convertable_string), true)
- }
-
- #[test]
- fn is_correct_from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- assert_eq!(is_screaming_snake_case(&convertable_string), false)
- }
-}
diff --git a/src/cases/sentencecase/mod.rs b/src/cases/sentencecase/mod.rs
deleted file mode 100644
index 5a99d21..0000000
--- a/src/cases/sentencecase/mod.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-#![deny(warnings)]
-use cases::case::*;
-/// Converts a `&str` to `Sentence case` `String`
-///
-/// ```
-/// use inflector::cases::sentencecase::to_sentence_case;
-/// let mock_string: &str = "Foo bar";
-/// let expected_string: String = "Foo bar".to_string();
-/// let asserted_string: String = to_sentence_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::to_sentence_case;
-/// let mock_string: &str = "FooBar";
-/// let expected_string: String = "Foo bar".to_string();
-/// let asserted_string: String = to_sentence_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::to_sentence_case;
-/// let mock_string: &str = "fooBar";
-/// let expected_string: String = "Foo bar".to_string();
-/// let asserted_string: String = to_sentence_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::to_sentence_case;
-/// let mock_string: &str = "FOO_BAR";
-/// let expected_string: String = "Foo bar".to_string();
-/// let asserted_string: String = to_sentence_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::to_sentence_case;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "Foo bar".to_string();
-/// let asserted_string: String = to_sentence_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::to_sentence_case;
-/// let mock_string: &str = "foo-bar";
-/// let expected_string: String = "Foo bar".to_string();
-/// let asserted_string: String = to_sentence_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn to_sentence_case(non_sentence_case_string: &str) -> String {
- let options = CamelOptions {
- new_word: true,
- last_char: ' ',
- first_word: true,
- injectable_char: ' ',
- has_seperator: true,
- inverted: true,
- };
- to_case_camel_like(non_sentence_case_string, options)
-}
-/// Determines of a `&str` is `Sentence case`
-///
-/// ```
-/// use inflector::cases::sentencecase::is_sentence_case;
-/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
-/// let asserted_bool: bool = is_sentence_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::is_sentence_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_sentence_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::is_sentence_case;
-/// let mock_string: &str = "fooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_sentence_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::is_sentence_case;
-/// let mock_string: &str = "Foo Bar Is A Really Really Long String";
-/// let asserted_bool: bool = is_sentence_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::is_sentence_case;
-/// let mock_string: &str = "FOO_BAR_STRING_THAT_IS_REALLY_REALLY_LONG";
-/// let asserted_bool: bool = is_sentence_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::is_sentence_case;
-/// let mock_string: &str = "foo_bar_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_sentence_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::is_sentence_case;
-/// let mock_string: &str = "Foo";
-/// let asserted_bool: bool = is_sentence_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::is_sentence_case;
-/// let mock_string: &str = "foo";
-/// let asserted_bool: bool = is_sentence_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::sentencecase::is_sentence_case;
-/// let mock_string: &str = "Foo bar string that is really really long";
-/// let asserted_bool: bool = is_sentence_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-pub fn is_sentence_case(test_string: &str) -> bool {
- test_string == to_sentence_case(test_string.clone())
-}
-
-#[cfg(all(feature = "unstable", test))]
-mod benchmarks {
- extern crate test;
- use self::test::Bencher;
-
- #[bench]
- fn bench_sentence(b: &mut Bencher) {
- b.iter(|| super::to_sentence_case("Foo BAR"));
- }
-
- #[bench]
- fn bench_is_sentence(b: &mut Bencher) {
- b.iter(|| super::is_sentence_case("Foo bar"));
- }
-
- #[bench]
- fn bench_sentence_from_snake(b: &mut Bencher) {
- b.iter(|| super::to_sentence_case("foo_bar"));
- }
-
-}
-
-#[cfg(test)]
-mod tests {
- use ::to_sentence_case;
- use ::is_sentence_case;
-
- #[test]
- fn from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- let expected: String = "Foo bar".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- let expected: String = "Foo bar".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- let expected: String = "Foo bar".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- let expected: String = "Foo bar".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- let expected: String = "Foo bar".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- let expected: String = "Foo bar".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- let expected: String = "Foo bar".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- let expected: String = "Foo bar".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_case_with_loads_of_space() {
- let convertable_string: String = "foo bar".to_owned();
- let expected: String = "Foo bar".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn a_name_with_a_dot() {
- let convertable_string: String = "Robert C. Martin".to_owned();
- let expected: String = "Robert c martin".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn random_text_with_bad_chars() {
- let convertable_string: String = "Random text with *(bad) chars".to_owned();
- let expected: String = "Random text with bad chars".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn trailing_bad_chars() {
- let convertable_string: String = "trailing bad_chars*(()())".to_owned();
- let expected: String = "Trailing bad chars".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn leading_bad_chars() {
- let convertable_string: String = "-!#$%leading bad chars".to_owned();
- let expected: String = "Leading bad chars".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn wrapped_in_bad_chars() {
- let convertable_string: String = "-!#$%wrapped in bad chars&*^*&(&*^&(<><?>><?><>))".to_owned();
- let expected: String = "Wrapped in bad chars".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
- #[test]
- fn has_a_sign() {
- let convertable_string: String = "has a + sign".to_owned();
- let expected: String = "Has a sign".to_owned();
- assert_eq!(to_sentence_case(&convertable_string), expected)
- }
-
-
- #[test]
- fn is_correct_from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- assert_eq!(is_sentence_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- assert_eq!(is_sentence_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- assert_eq!(is_sentence_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- assert_eq!(is_sentence_case(&convertable_string), true)
- }
-
- #[test]
- fn is_correct_from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- assert_eq!(is_sentence_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- assert_eq!(is_sentence_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- assert_eq!(is_sentence_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- assert_eq!(is_sentence_case(&convertable_string), false)
- }
-}
diff --git a/src/cases/snakecase/mod.rs b/src/cases/snakecase/mod.rs
deleted file mode 100644
index a56894b..0000000
--- a/src/cases/snakecase/mod.rs
+++ /dev/null
@@ -1,334 +0,0 @@
-#![deny(warnings)]
-use cases::case::*;
-/// Converts a `&str` to `snake_case` `String`
-///
-/// ```
-/// use inflector::cases::snakecase::to_snake_case;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "foo_bar".to_string();
-/// let asserted_string: String = to_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::to_snake_case;
-/// let mock_string: &str = "HTTP Foo bar";
-/// let expected_string: String = "http_foo_bar".to_string();
-/// let asserted_string: String = to_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::to_snake_case;
-/// let mock_string: &str = "HTTPFooBar";
-/// let expected_string: String = "http_foo_bar".to_string();
-/// let asserted_string: String = to_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::to_snake_case;
-/// let mock_string: &str = "Foo bar";
-/// let expected_string: String = "foo_bar".to_string();
-/// let asserted_string: String = to_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::to_snake_case;
-/// let mock_string: &str = "Foo Bar";
-/// let expected_string: String = "foo_bar".to_string();
-/// let asserted_string: String = to_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::to_snake_case;
-/// let mock_string: &str = "FooBar";
-/// let expected_string: String = "foo_bar".to_string();
-/// let asserted_string: String = to_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::to_snake_case;
-/// let mock_string: &str = "FOO_BAR";
-/// let expected_string: String = "foo_bar".to_string();
-/// let asserted_string: String = to_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::to_snake_case;
-/// let mock_string: &str = "fooBar";
-/// let expected_string: String = "foo_bar".to_string();
-/// let asserted_string: String = to_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::to_snake_case;
-/// let mock_string: &str = "fooBar3";
-/// let expected_string: String = "foo_bar_3".to_string();
-/// let asserted_string: String = to_snake_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn to_snake_case(non_snake_case_string: &str) -> String {
- to_case_snake_like(non_snake_case_string, "_", "lower")
-}
-
-/// Determines of a `&str` is `snake_case`
-///
-/// ```
-/// use inflector::cases::snakecase::is_snake_case;
-/// let mock_string: &str = "Foo bar string that is really really long";
-/// let asserted_bool: bool = is_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::is_snake_case;
-/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
-/// let asserted_bool: bool = is_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::is_snake_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::is_snake_case;
-/// let mock_string: &str = "Foo Bar Is A Really Really Long String";
-/// let asserted_bool: bool = is_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::is_snake_case;
-/// let mock_string: &str = "FOO_BAR_IS_A_REALLY_REALLY_LONG_STRING";
-/// let asserted_bool: bool = is_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::is_snake_case;
-/// let mock_string: &str = "fooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::is_snake_case;
-/// let mock_string: &str = "foo_bar_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_snake_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::is_snake_case;
-/// let mock_string: &str = "foo_bar1_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_snake_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::snakecase::is_snake_case;
-/// let mock_string: &str = "foo_bar_1_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_snake_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-pub fn is_snake_case(test_string: &str) -> bool {
- test_string == to_snake_case(test_string.clone())
-}
-
-#[cfg(all(feature = "unstable", test))]
-mod benchmarks {
- extern crate test;
- use self::test::Bencher;
-
- #[bench]
- fn bench_snake_from_title(b: &mut Bencher) {
- b.iter(|| super::to_snake_case("Foo bar"));
- }
-
- #[bench]
- fn bench_snake_from_camel(b: &mut Bencher) {
- b.iter(|| super::to_snake_case("fooBar"));
- }
-
- #[bench]
- fn bench_snake_from_snake(b: &mut Bencher) {
- b.iter(|| super::to_snake_case("foo_bar_bar_bar"));
- }
-
- #[bench]
- fn bench_is_snake(b: &mut Bencher) {
- b.iter(|| super::is_snake_case("Foo bar"));
- }
-
-}
-
-#[cfg(test)]
-mod tests {
- use ::to_snake_case;
- use ::is_snake_case;
-
- #[test]
- fn from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- let expected: String = "foo_bar".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- let expected: String = "foo_bar".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- let expected: String = "foo_bar".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- let expected: String = "foo_bar".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- let expected: String = "foo_bar".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- let expected: String = "foo_bar".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- let expected: String = "foo_bar".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- let expected: String = "foo_bar".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_case_with_loads_of_space() {
- let convertable_string: String = "foo bar".to_owned();
- let expected: String = "foo_bar".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn a_name_with_a_dot() {
- let convertable_string: String = "Robert C. Martin".to_owned();
- let expected: String = "robert_c_martin".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn random_text_with_bad_chars() {
- let convertable_string: String = "Random text with *(bad) chars".to_owned();
- let expected: String = "random_text_with_bad_chars".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn trailing_bad_chars() {
- let convertable_string: String = "trailing bad_chars*(()())".to_owned();
- let expected: String = "trailing_bad_chars".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn leading_bad_chars() {
- let convertable_string: String = "-!#$%leading bad chars".to_owned();
- let expected: String = "leading_bad_chars".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn wrapped_in_bad_chars() {
- let convertable_string: String = "-!#$%wrapped in bad chars&*^*&(&*^&(<><?>><?><>))".to_owned();
- let expected: String = "wrapped_in_bad_chars".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn has_a_sign() {
- let convertable_string: String = "has a + sign".to_owned();
- let expected: String = "has_a_sign".to_owned();
- assert_eq!(to_snake_case(&convertable_string), expected)
- }
-
- #[test]
- fn is_correct_from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- assert_eq!(is_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- assert_eq!(is_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- assert_eq!(is_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- assert_eq!(is_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- assert_eq!(is_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- assert_eq!(is_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- assert_eq!(is_snake_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- assert_eq!(is_snake_case(&convertable_string), true)
- }
-}
diff --git a/src/cases/tablecase/mod.rs b/src/cases/tablecase/mod.rs
deleted file mode 100644
index 7224cc4..0000000
--- a/src/cases/tablecase/mod.rs
+++ /dev/null
@@ -1,271 +0,0 @@
-#![deny(warnings)]
-#[cfg(feature = "heavyweight")]
-use string::pluralize::to_plural;
-#[cfg(feature = "heavyweight")]
-use cases::case::*;
-#[cfg(feature = "heavyweight")]
-/// Converts a `&str` to `table-case` `String`
-///
-/// ```
-/// use inflector::cases::tablecase::to_table_case;
-/// let mock_string: &str = "foo-bar";
-/// let expected_string: String = "foo_bars".to_string();
-/// let asserted_string: String = to_table_case(mock_string);
-/// assert!(asserted_string == expected_string);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::to_table_case;
-/// let mock_string: &str = "FOO_BAR";
-/// let expected_string: String = "foo_bars".to_string();
-/// let asserted_string: String = to_table_case(mock_string);
-/// assert!(asserted_string == expected_string);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::to_table_case;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "foo_bars".to_string();
-/// let asserted_string: String = to_table_case(mock_string);
-/// assert!(asserted_string == expected_string);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::to_table_case;
-/// let mock_string: &str = "Foo Bar";
-/// let expected_string: String = "foo_bars".to_string();
-/// let asserted_string: String = to_table_case(mock_string);
-/// assert!(asserted_string == expected_string);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::to_table_case;
-/// let mock_string: &str = "Foo bar";
-/// let expected_string: String = "foo_bars".to_string();
-/// let asserted_string: String = to_table_case(mock_string);
-/// assert!(asserted_string == expected_string);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::to_table_case;
-/// let mock_string: &str = "FooBar";
-/// let expected_string: String = "foo_bars".to_string();
-/// let asserted_string: String = to_table_case(mock_string);
-/// assert!(asserted_string == expected_string);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::to_table_case;
-/// let mock_string: &str = "fooBar";
-/// let expected_string: String = "foo_bars".to_string();
-/// let asserted_string: String = to_table_case(mock_string);
-/// assert!(asserted_string == expected_string);
-/// ```
-pub fn to_table_case(non_table_case_string: &str) -> String {
- let snaked: String = to_case_snake_like(non_table_case_string, "_", "lower");
- let split: (&str, &str) = snaked.split_at(snaked.rfind('_').unwrap_or(0));
- format!("{}{}", split.0, to_plural(split.1))
-}
-
-#[cfg(feature = "heavyweight")]
-/// Determines if a `&str` is `table-case`
-///
-/// ```
-/// use inflector::cases::tablecase::is_table_case;
-/// let mock_string: &str = "foo_bar_strings";
-/// let asserted_bool: bool = is_table_case(mock_string);
-/// assert!(asserted_bool == true);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::is_table_case;
-/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
-/// let asserted_bool: bool = is_table_case(mock_string);
-/// assert!(asserted_bool == false);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::is_table_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_table_case(mock_string);
-/// assert!(asserted_bool == false);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::is_table_case;
-/// let mock_string: &str = "fooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_table_case(mock_string);
-/// assert!(asserted_bool == false);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::is_table_case;
-/// let mock_string: &str = "FOO_BAR_STRING_THAT_IS_REALLY_REALLY_LONG";
-/// let asserted_bool: bool = is_table_case(mock_string);
-/// assert!(asserted_bool == false);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::is_table_case;
-/// let mock_string: &str = "foo_bar_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_table_case(mock_string);
-/// assert!(asserted_bool == false);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::is_table_case;
-/// let mock_string: &str = "Foo bar string that is really really long";
-/// let asserted_bool: bool = is_table_case(mock_string);
-/// assert!(asserted_bool == false);
-/// ```
-///
-/// ```
-/// use inflector::cases::tablecase::is_table_case;
-/// let mock_string: &str = "Foo Bar Is A Really Really Long String";
-/// let asserted_bool: bool = is_table_case(mock_string);
-/// assert!(asserted_bool == false);
-/// ```
-pub fn is_table_case(test_string: &str) -> bool {
- to_table_case(&test_string.clone()) == test_string
-}
-
-#[cfg(all(feature = "unstable", test))]
-#[cfg(feature = "heavyweight")]
-mod benchmarks {
- extern crate test;
- use self::test::Bencher;
-
- #[bench]
- fn bench_table_case(b: &mut Bencher) {
- b.iter(|| super::to_table_case("Foo bar"));
- }
-
- #[bench]
- fn bench_is_table_case(b: &mut Bencher) {
- b.iter(|| super::is_table_case("Foo bar"));
- }
-}
-
-#[cfg(test)]
-#[cfg(feature = "heavyweight")]
-mod tests {
- use ::to_table_case;
- use ::is_table_case;
-
- #[test]
- fn from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- let expected: String = "foo_bars".to_owned();
- assert_eq!(to_table_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- let expected: String = "foo_bars".to_owned();
- assert_eq!(to_table_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- let expected: String = "foo_bars".to_owned();
- assert_eq!(to_table_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- let expected: String = "foo_bars".to_owned();
- assert_eq!(to_table_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- let expected: String = "foo_bars".to_owned();
- assert_eq!(to_table_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- let expected: String = "foo_bars".to_owned();
- assert_eq!(to_table_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- let expected: String = "foo_bars".to_owned();
- assert_eq!(to_table_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- let expected: String = "foo_bars".to_owned();
- assert_eq!(to_table_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_table_case() {
- let convertable_string: String = "foo_bars".to_owned();
- let expected: String = "foo_bars".to_owned();
- assert_eq!(to_table_case(&convertable_string), expected)
- }
-
- #[test]
- fn is_correct_from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- assert_eq!(is_table_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- assert_eq!(is_table_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- assert_eq!(is_table_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- assert_eq!(is_table_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- assert_eq!(is_table_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- assert_eq!(is_table_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- assert_eq!(is_table_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- assert_eq!(is_table_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_table_case() {
- let convertable_string: String = "foo_bars".to_owned();
- assert_eq!(is_table_case(&convertable_string), true)
- }
-}
diff --git a/src/cases/titlecase/mod.rs b/src/cases/titlecase/mod.rs
deleted file mode 100644
index eb0de25..0000000
--- a/src/cases/titlecase/mod.rs
+++ /dev/null
@@ -1,308 +0,0 @@
-#![deny(warnings)]
-use cases::case::*;
-/// Converts a `&str` to `Title Case` `String`
-///
-/// ```
-/// use inflector::cases::titlecase::to_title_case;
-/// let mock_string: &str = "Foo bar";
-/// let expected_string: String = "Foo Bar".to_string();
-/// let asserted_string: String = to_title_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::to_title_case;
-/// let mock_string: &str = "FooBar";
-/// let expected_string: String = "Foo Bar".to_string();
-/// let asserted_string: String = to_title_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::to_title_case;
-/// let mock_string: &str = "fooBar";
-/// let expected_string: String = "Foo Bar".to_string();
-/// let asserted_string: String = to_title_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::to_title_case;
-/// let mock_string: &str = "FOO_BAR";
-/// let expected_string: String = "Foo Bar".to_string();
-/// let asserted_string: String = to_title_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::to_title_case;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "Foo Bar".to_string();
-/// let asserted_string: String = to_title_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::to_title_case;
-/// let mock_string: &str = "foo-bar";
-/// let expected_string: String = "Foo Bar".to_string();
-/// let asserted_string: String = to_title_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn to_title_case(non_title_case_string: &str) -> String {
- let options = CamelOptions {
- new_word: true,
- last_char: ' ',
- first_word: true,
- injectable_char: ' ',
- has_seperator: true,
- inverted: false,
- };
- to_case_camel_like(non_title_case_string, options)
-}
-
-/// Determines if a `&str` is `Title Case`
-///
-/// ```
-/// use inflector::cases::titlecase::is_title_case;
-/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
-/// let asserted_bool: bool = is_title_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::is_title_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_title_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::is_title_case;
-/// let mock_string: &str = "fooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_title_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::is_title_case;
-/// let mock_string: &str = "FOO_BAR_STRING_THAT_IS_REALLY_REALLY_LONG";
-/// let asserted_bool: bool = is_title_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::is_title_case;
-/// let mock_string: &str = "foo_bar_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_title_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::is_title_case;
-/// let mock_string: &str = "Foo bar string that is really really long";
-/// let asserted_bool: bool = is_title_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::is_title_case;
-/// let mock_string: &str = "foo";
-/// let asserted_bool: bool = is_title_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::cases::titlecase::is_title_case;
-/// let mock_string: &str = "Foo Bar String That Is Really Really Long";
-/// let asserted_bool: bool = is_title_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-pub fn is_title_case(test_string: &str) -> bool {
- test_string == to_title_case(test_string.clone())
-}
-
-#[cfg(all(feature = "unstable", test))]
-mod benchmarks {
- extern crate test;
- use self::test::Bencher;
-
- #[bench]
- fn bench_title(b: &mut Bencher) {
- b.iter(|| super::to_title_case("Foo BAR"));
- }
-
- #[bench]
- fn bench_is_title(b: &mut Bencher) {
- b.iter(|| super::is_title_case("Foo bar"));
- }
-
- #[bench]
- fn bench_title_from_snake(b: &mut Bencher) {
- b.iter(|| super::to_title_case("foo_bar"));
- }
-
-}
-
-
-#[cfg(test)]
-mod tests {
- use ::to_title_case;
- use ::is_title_case;
-
- #[test]
- fn from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- let expected: String = "Foo Bar".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- let expected: String = "Foo Bar".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- let expected: String = "Foo Bar".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- let expected: String = "Foo Bar".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- let expected: String = "Foo Bar".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- let expected: String = "Foo Bar".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- let expected: String = "Foo Bar".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- let expected: String = "Foo Bar".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_case_with_loads_of_space() {
- let convertable_string: String = "foo bar".to_owned();
- let expected: String = "Foo Bar".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn a_name_with_a_dot() {
- let convertable_string: String = "Robert C. Martin".to_owned();
- let expected: String = "Robert C Martin".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn random_text_with_bad_chars() {
- let convertable_string: String = "Random text with *(bad) chars".to_owned();
- let expected: String = "Random Text With Bad Chars".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn trailing_bad_chars() {
- let convertable_string: String = "trailing bad_chars*(()())".to_owned();
- let expected: String = "Trailing Bad Chars".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn leading_bad_chars() {
- let convertable_string: String = "-!#$%leading bad chars".to_owned();
- let expected: String = "Leading Bad Chars".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn wrapped_in_bad_chars() {
- let convertable_string: String = "-!#$%wrapped in bad chars&*^*&(&*^&(<><?>><?><>))".to_owned();
- let expected: String = "Wrapped In Bad Chars".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn has_a_sign() {
- let convertable_string: String = "has a + sign".to_owned();
- let expected: String = "Has A Sign".to_owned();
- assert_eq!(to_title_case(&convertable_string), expected)
- }
-
- #[test]
- fn is_correct_from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- assert_eq!(is_title_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- assert_eq!(is_title_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- assert_eq!(is_title_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- assert_eq!(is_title_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- assert_eq!(is_title_case(&convertable_string), true)
- }
-
- #[test]
- fn is_correct_from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- assert_eq!(is_title_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- assert_eq!(is_title_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- assert_eq!(is_title_case(&convertable_string), false)
- }
-}
-
diff --git a/src/cases/traincase/mod.rs b/src/cases/traincase/mod.rs
deleted file mode 100644
index cb2e882..0000000
--- a/src/cases/traincase/mod.rs
+++ /dev/null
@@ -1,320 +0,0 @@
-#![deny(warnings)]
-use cases::case::*;
-/// Determines if a `&str` is `Train-Case`
-///
-/// ```
-/// use inflector::cases::traincase::is_train_case;
-/// let mock_string: &str = "Foo-Bar-String-That-Is-Really-Really-Long";
-/// let asserted_bool: bool = is_train_case(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::is_train_case;
-/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
-/// let asserted_bool: bool = is_train_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::is_train_case;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_train_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::is_train_case;
-/// let mock_string: &str = "fooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_train_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::is_train_case;
-/// let mock_string: &str = "foo_bar_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_train_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::is_train_case;
-/// let mock_string: &str = "Foo bar string that is really really long";
-/// let asserted_bool: bool = is_train_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::is_train_case;
-/// let mock_string: &str = "Foo Bar Is A Really Really Long String";
-/// let asserted_bool: bool = is_train_case(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-pub fn is_train_case(test_string: &str) -> bool {
- test_string == to_train_case(test_string.clone())
-}
-
-
-/// Converts a `&str` to `Train-Case` `String`
-///
-/// ```
-/// use inflector::cases::traincase::to_train_case;
-/// let mock_string: &str = "foo-bar";
-/// let expected_string: String = "Foo-Bar".to_string();
-/// let asserted_string: String = to_train_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::to_train_case;
-/// let mock_string: &str = "FOO_BAR";
-/// let expected_string: String = "Foo-Bar".to_string();
-/// let asserted_string: String = to_train_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::to_train_case;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "Foo-Bar".to_string();
-/// let asserted_string: String = to_train_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::to_train_case;
-/// let mock_string: &str = "Foo Bar";
-/// let expected_string: String = "Foo-Bar".to_string();
-/// let asserted_string: String = to_train_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::to_train_case;
-/// let mock_string: &str = "Foo bar";
-/// let expected_string: String = "Foo-Bar".to_string();
-/// let asserted_string: String = to_train_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::to_train_case;
-/// let mock_string: &str = "FooBar";
-/// let expected_string: String = "Foo-Bar".to_string();
-/// let asserted_string: String = to_train_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-/// ```
-/// use inflector::cases::traincase::to_train_case;
-/// let mock_string: &str = "fooBar";
-/// let expected_string: String = "Foo-Bar".to_string();
-/// let asserted_string: String = to_train_case(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn to_train_case(non_train_case_string: &str) -> String {
- let options = CamelOptions {
- new_word: true,
- last_char: ' ',
- first_word: true,
- injectable_char: '-',
- has_seperator: true,
- inverted: false,
- };
- to_case_camel_like(non_train_case_string, options)
-}
-
-#[cfg(all(feature = "unstable", test))]
-mod benchmarks {
- extern crate test;
- use self::test::Bencher;
-
- #[bench]
- fn bench_train(b: &mut Bencher) {
- b.iter(|| super::to_train_case("Foo bar"));
- }
-
- #[bench]
- fn bench_is_train(b: &mut Bencher) {
- b.iter(|| super::is_train_case("Foo bar"));
- }
-
- #[bench]
- fn bench_train_from_snake(b: &mut Bencher) {
- b.iter(|| super::to_train_case("test_test_test"));
- }
-
-}
-
-#[cfg(test)]
-mod tests {
- use ::to_train_case;
- use ::is_train_case;
-
- #[test]
- fn from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- let expected: String = "Foo-Bar".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- let expected: String = "Foo-Bar".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- let expected: String = "Foo-Bar".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- let expected: String = "Foo-Bar".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- let expected: String = "Foo-Bar".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- let expected: String = "Foo-Bar".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- let expected: String = "Foo-Bar".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- let expected: String = "Foo-Bar".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn from_case_with_loads_of_space() {
- let convertable_string: String = "foo bar".to_owned();
- let expected: String = "Foo-Bar".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn a_name_with_a_dot() {
- let convertable_string: String = "Robert C. Martin".to_owned();
- let expected: String = "Robert-C-Martin".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn random_text_with_bad_chars() {
- let convertable_string: String = "Random text with *(bad) chars".to_owned();
- let expected: String = "Random-Text-With-Bad-Chars".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn trailing_bad_chars() {
- let convertable_string: String = "trailing bad_chars*(()())".to_owned();
- let expected: String = "Trailing-Bad-Chars".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn leading_bad_chars() {
- let convertable_string: String = "-!#$%leading bad chars".to_owned();
- let expected: String = "Leading-Bad-Chars".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn wrapped_in_bad_chars() {
- let convertable_string: String = "-!#$%wrapped in bad chars&*^*&(&*^&(<><?>><?><>))".to_owned();
- let expected: String = "Wrapped-In-Bad-Chars".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn has_a_sign() {
- let convertable_string: String = "has a + sign".to_owned();
- let expected: String = "Has-A-Sign".to_owned();
- assert_eq!(to_train_case(&convertable_string), expected)
- }
-
- #[test]
- fn is_correct_from_camel_case() {
- let convertable_string: String = "fooBar".to_owned();
- assert_eq!(is_train_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_pascal_case() {
- let convertable_string: String = "FooBar".to_owned();
- assert_eq!(is_train_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_kebab_case() {
- let convertable_string: String = "foo-bar".to_owned();
- assert_eq!(is_train_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_sentence_case() {
- let convertable_string: String = "Foo bar".to_owned();
- assert_eq!(is_train_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_title_case() {
- let convertable_string: String = "Foo Bar".to_owned();
- assert_eq!(is_train_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_train_case() {
- let convertable_string: String = "Foo-Bar".to_owned();
- assert_eq!(is_train_case(&convertable_string), true)
- }
-
- #[test]
- fn is_correct_from_screaming_snake_case() {
- let convertable_string: String = "FOO_BAR".to_owned();
- assert_eq!(is_train_case(&convertable_string), false)
- }
-
- #[test]
- fn is_correct_from_snake_case() {
- let convertable_string: String = "foo_bar".to_owned();
- assert_eq!(is_train_case(&convertable_string), false)
- }
-}
diff --git a/src/lib.rs b/src/lib.rs
deleted file mode 100644
index f52ea29..0000000
--- a/src/lib.rs
+++ /dev/null
@@ -1,332 +0,0 @@
-#![deny(warnings, unused_variables, missing_docs, unsafe_code, unused_extern_crates)]
-#![cfg_attr(feature = "unstable", feature(test))]
-
-//! Adds String based inflections for Rust. Snake, kebab, train, camel,
-//! sentence, class, and title cases as well as ordinalize,
-//! deordinalize, demodulize, deconstantize, and foreign key are supported as
-//! both traits and pure functions acting on String types.
-//! ```rust
-//! use inflector::Inflector;
-//! let camel_case_string: String = "some_string".to_camel_case();
-//! let is_camel_cased: bool= camel_case_string.is_camel_case();
-//! assert!(is_camel_cased == true);
-//! ```
-
-#[cfg(feature = "heavyweight")]
-extern crate regex;
-
-#[cfg(feature = "heavyweight")]
-#[macro_use] extern crate lazy_static;
-
-/// Provides case inflections
-/// - Camel case
-/// - Class case
-/// - Kebab case
-/// - Train case
-/// - Screaming snake case
-/// - Table case
-/// - Sentence case
-/// - Snake case
-/// - Pascal case
-pub mod cases;
-/// Provides number inflections
-/// - Ordinalize
-/// - Deordinalize
-pub mod numbers;
-/// Provides suffix inflections
-/// - Foreign key
-pub mod suffix;
-/// Provides string inflections
-/// - Deconstantize
-/// - Demodulize
-/// - Pluralize
-/// - Singularize
-#[cfg(feature = "heavyweight")]
-pub mod string;
-
-
-#[cfg(feature = "heavyweight")]
-use cases::classcase::to_class_case;
-#[cfg(feature = "heavyweight")]
-use cases::classcase::is_class_case;
-
-use cases::camelcase::to_camel_case;
-use cases::camelcase::is_camel_case;
-
-use cases::pascalcase::to_pascal_case;
-use cases::pascalcase::is_pascal_case;
-
-use cases::snakecase::to_snake_case;
-use cases::snakecase::is_snake_case;
-
-use cases::screamingsnakecase::to_screaming_snake_case;
-use cases::screamingsnakecase::is_screaming_snake_case;
-
-use cases::kebabcase::to_kebab_case;
-use cases::kebabcase::is_kebab_case;
-
-use cases::traincase::to_train_case;
-use cases::traincase::is_train_case;
-
-use cases::sentencecase::to_sentence_case;
-use cases::sentencecase::is_sentence_case;
-
-use cases::titlecase::to_title_case;
-use cases::titlecase::is_title_case;
-
-#[cfg(feature = "heavyweight")]
-use cases::tablecase::to_table_case;
-#[cfg(feature = "heavyweight")]
-use cases::tablecase::is_table_case;
-
-use numbers::ordinalize::ordinalize;
-use numbers::deordinalize::deordinalize;
-
-use suffix::foreignkey::to_foreign_key;
-use suffix::foreignkey::is_foreign_key;
-
-#[cfg(feature = "heavyweight")]
-use string::demodulize::demodulize;
-#[cfg(feature = "heavyweight")]
-use string::deconstantize::deconstantize;
-
-#[cfg(feature = "heavyweight")]
-use string::pluralize::to_plural;
-#[cfg(feature = "heavyweight")]
-use string::singularize::to_singular;
-
-#[allow(missing_docs)]
-pub trait Inflector {
-
- fn to_camel_case(&self) -> String;
- fn is_camel_case(&self) -> bool;
-
- fn to_pascal_case(&self) -> String;
- fn is_pascal_case(&self) -> bool;
-
- fn to_snake_case(&self) -> String;
- fn is_snake_case(&self) -> bool;
-
- fn to_screaming_snake_case(&self) -> String;
- fn is_screaming_snake_case(&self) -> bool;
-
- fn to_kebab_case(&self) -> String;
- fn is_kebab_case(&self) -> bool;
-
- fn to_train_case(&self) -> String;
- fn is_train_case(&self) -> bool;
-
- fn to_sentence_case(&self) -> String;
- fn is_sentence_case(&self) -> bool;
-
- fn to_title_case(&self) -> String;
- fn is_title_case(&self) -> bool;
-
- fn ordinalize(&self) -> String;
- fn deordinalize(&self) -> String;
-
- fn to_foreign_key(&self) -> String;
- fn is_foreign_key(&self) -> bool;
-
- #[cfg(feature = "heavyweight")]
- fn demodulize(&self) -> String;
- #[cfg(feature = "heavyweight")]
- fn deconstantize(&self) -> String;
-
- #[cfg(feature = "heavyweight")]
- fn to_class_case(&self) -> String;
- #[cfg(feature = "heavyweight")]
- fn is_class_case(&self) -> bool;
-
- #[cfg(feature = "heavyweight")]
- fn to_table_case(&self) -> String;
- #[cfg(feature = "heavyweight")]
- fn is_table_case(&self) -> bool;
- #[cfg(feature = "heavyweight")]
- fn to_plural(&self) -> String;
- #[cfg(feature = "heavyweight")]
- fn to_singular(&self) -> String;
-}
-
-
-#[allow(missing_docs)]
-pub trait InflectorNumbers {
- fn ordinalize(&self) -> String;
-}
-
-
-macro_rules! define_implementations {
- ( $slf:ident; $($imp_trait:ident => $typ:ident), *) => {
- $(
- #[inline]
- fn $imp_trait(&$slf) -> $typ {
- $imp_trait($slf)
- }
- )*
- }
-}
-
-macro_rules! define_number_implementations {
- ( $slf:ident; $($imp_trait:ident => $typ:ident), *) => {
- $(
- #[inline]
- fn $imp_trait(&$slf) -> $typ {
- $imp_trait(&$slf.to_string())
- }
- )*
- }
-}
-
-macro_rules! define_gated_implementations {
- ( $slf:ident; $($imp_trait:ident => $typ:ident), *) => {
- $(
- #[inline]
- #[cfg(feature = "heavyweight")]
- fn $imp_trait(&$slf) -> $typ {
- $imp_trait($slf)
- }
- )*
- }
-}
-
-macro_rules! implement_string_for {
- ( $trt:ident; $($typ:ident), *) => {
- $(
- impl $trt for $typ {
- define_implementations![self;
- to_camel_case => String,
- is_camel_case => bool,
- to_pascal_case => String,
- is_pascal_case => bool,
- to_screaming_snake_case => String,
- is_screaming_snake_case => bool,
- to_snake_case => String,
- is_snake_case => bool,
- to_kebab_case => String,
- is_kebab_case => bool,
- to_train_case => String,
- is_train_case => bool,
- to_sentence_case => String,
- is_sentence_case => bool,
- to_title_case => String,
- is_title_case => bool,
- to_foreign_key => String,
- is_foreign_key => bool,
- ordinalize => String,
- deordinalize => String
- ];
- define_gated_implementations![self;
- to_class_case => String,
- is_class_case => bool,
- to_table_case => String,
- is_table_case => bool,
- to_plural => String,
- to_singular => String,
- demodulize => String,
- deconstantize => String
- ];
- }
- )*
- }
-}
-
-macro_rules! implement_number_for {
- ( $trt:ident; $($typ:ident), *) => {
- $(
- impl $trt for $typ {
- define_number_implementations![self;
- ordinalize => String
- ];
- }
- )*
- }
-}
-
-implement_string_for![
- Inflector;
- String, str
-];
-
-implement_number_for![
- InflectorNumbers;
- i8, i16, i32, i64, u8, u16, u32, u64, isize, usize, f32, f64
-];
-
-#[cfg(all(feature = "unstable", test))]
-mod benchmarks {
- extern crate test;
- use self::test::Bencher;
- use ::Inflector;
-
- macro_rules! benchmarks {
- ( $($test_name:ident => $imp_trait:ident => $to_cast:expr), *) => {
- $(
- #[bench]
- fn $test_name(b: &mut Bencher) {
- b.iter(|| {
- $to_cast.$imp_trait()
- });
- }
- )*
- }
- }
-
- benchmarks![
- benchmark_str_to_camel => to_camel_case => "foo_bar",
- benchmark_str_is_camel => is_camel_case => "fooBar",
- benchmark_str_to_screaming_snake => to_screaming_snake_case => "fooBar",
- benchmark_str_is_screaming_snake => is_screaming_snake_case => "FOO_BAR",
- benchmark_str_to_snake => to_snake_case => "fooBar",
- benchmark_str_is_snake => is_snake_case => "foo_bar",
- benchmark_str_to_kebab => to_kebab_case => "fooBar",
- benchmark_str_is_kebab => is_kebab_case => "foo-bar",
- benchmark_str_to_train => to_train_case => "fooBar",
- benchmark_str_is_train => is_train_case => "Foo-Bar",
- benchmark_str_to_sentence => to_sentence_case => "fooBar",
- benchmark_str_is_sentence => is_sentence_case => "Foo bar",
- benchmark_str_to_title => to_title_case => "fooBar",
- benchmark_str_is_title => is_title_case => "Foo Bar",
- benchmark_str_ordinalize => ordinalize => "1",
- benchmark_str_deordinalize => deordinalize => "1st",
- benchmark_str_to_foreign_key => to_foreign_key => "Foo::Bar",
- benchmark_str_is_foreign_key => is_foreign_key => "bar_id",
- benchmark_string_to_camel => to_camel_case => "foo_bar".to_string(),
- benchmark_string_is_camel => is_camel_case => "fooBar".to_string(),
- benchmark_string_to_screaming_snake => to_screaming_snake_case => "fooBar".to_string(),
- benchmark_string_is_screaming_snake => is_screaming_snake_case => "FOO_BAR".to_string(),
- benchmark_string_to_snake => to_snake_case => "fooBar".to_string(),
- benchmark_string_is_snake => is_snake_case => "foo_bar".to_string(),
- benchmark_string_to_kebab => to_kebab_case => "fooBar".to_string(),
- benchmark_string_is_kebab => is_kebab_case => "foo-bar".to_string(),
- benchmark_string_to_train => to_train_case => "fooBar".to_string(),
- benchmark_string_is_train => is_train_case => "Foo-Bar".to_string(),
- benchmark_string_to_sentence => to_sentence_case => "fooBar".to_string(),
- benchmark_string_is_sentence => is_sentence_case => "Foo bar".to_string(),
- benchmark_string_to_title => to_title_case => "fooBar".to_string(),
- benchmark_string_is_title => is_title_case => "Foo Bar".to_string(),
- benchmark_string_ordinalize => ordinalize => "1".to_string(),
- benchmark_string_deordinalize => deordinalize => "1st".to_string(),
- benchmark_string_to_foreign_key => to_foreign_key => "Foo::Bar".to_string(),
- benchmark_string_is_foreign_key => is_foreign_key => "bar_id".to_string()
- ];
-
- #[cfg(feature = "heavyweight")]
- benchmarks![
- benchmark_str_to_class => to_class_case => "foo",
- benchmark_str_is_class => is_class_case => "Foo",
- benchmark_str_to_table => to_table_case => "fooBar",
- benchmark_str_is_table => is_table_case => "foo_bars",
- benchmark_str_pluralize => to_plural => "crate",
- benchmark_str_singular => to_singular => "crates",
- benchmark_string_to_class => to_class_case => "foo".to_string(),
- benchmark_string_is_class => is_class_case => "Foo".to_string(),
- benchmark_string_to_table => to_table_case => "fooBar".to_string(),
- benchmark_string_is_table => is_table_case => "foo_bars".to_string(),
- benchmark_string_pluralize => to_plural => "crate".to_string(),
- benchmark_string_singular => to_singular => "crates".to_string(),
- benchmark_string_demodulize => demodulize => "Foo::Bar".to_string(),
- benchmark_string_deconstantize => deconstantize => "Foo::Bar".to_string(),
- benchmark_str_demodulize => demodulize => "Foo::Bar",
- benchmark_str_deconstantize => deconstantize => "Foo::Bar"
- ];
-}
diff --git a/src/numbers/deordinalize/mod.rs b/src/numbers/deordinalize/mod.rs
deleted file mode 100644
index f64cce1..0000000
--- a/src/numbers/deordinalize/mod.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-/// Deorginalizes a `&str`
-///
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "0.1";
-/// let expected_string: String = "0.1".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "-1st";
-/// let expected_string: String = "-1".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "0th";
-/// let expected_string: String = "0".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "1st";
-/// let expected_string: String = "1".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "2nd";
-/// let expected_string: String = "2".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "3rd";
-/// let expected_string: String = "3".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "9th";
-/// let expected_string: String = "9".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "12th";
-/// let expected_string: String = "12".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "12000th";
-/// let expected_string: String = "12000".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "12001th";
-/// let expected_string: String = "12001".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "12002nd";
-/// let expected_string: String = "12002".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "12003rd";
-/// let expected_string: String = "12003".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::deordinalize::deordinalize;
-/// let mock_string: &str = "12004th";
-/// let expected_string: String = "12004".to_owned();
-/// let asserted_string: String = deordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn deordinalize(non_ordinalized_string: &str) -> String {
- if non_ordinalized_string.contains('.') {
- non_ordinalized_string.to_owned()
- } else {
- non_ordinalized_string.trim_end_matches("st")
- .trim_end_matches("nd")
- .trim_end_matches("rd")
- .trim_end_matches("th")
- .to_owned()
- }
-}
diff --git a/src/numbers/mod.rs b/src/numbers/mod.rs
deleted file mode 100644
index f28704f..0000000
--- a/src/numbers/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![deny(warnings)]
-/// Provides ordinalization of a string.
-///
-/// Example string "1" becomes "1st"
-pub mod ordinalize;
-/// Provides deordinalization of a string.
-///
-/// Example string "1st" becomes "1"
-pub mod deordinalize;
diff --git a/src/numbers/ordinalize/mod.rs b/src/numbers/ordinalize/mod.rs
deleted file mode 100644
index 82b0d2d..0000000
--- a/src/numbers/ordinalize/mod.rs
+++ /dev/null
@@ -1,147 +0,0 @@
-/// Orginalizes a `&str`
-///
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "a";
-/// let expected_string: String = "a".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "0.1";
-/// let expected_string: String = "0.1".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "-1";
-/// let expected_string: String = "-1st".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "0";
-/// let expected_string: String = "0th".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "1";
-/// let expected_string: String = "1st".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "2";
-/// let expected_string: String = "2nd".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "3";
-/// let expected_string: String = "3rd".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "9";
-/// let expected_string: String = "9th".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "12";
-/// let expected_string: String = "12th".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "12000";
-/// let expected_string: String = "12000th".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "12001";
-/// let expected_string: String = "12001st".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "12002";
-/// let expected_string: String = "12002nd".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "12003";
-/// let expected_string: String = "12003rd".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::numbers::ordinalize::ordinalize;
-/// let mock_string: &str = "12004";
-/// let expected_string: String = "12004th".to_owned();
-/// let asserted_string: String = ordinalize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn ordinalize(non_ordinalized_string: &str) -> String {
- let chars: Vec<char> = non_ordinalized_string.clone().chars().collect();
- let last_number: char = chars[chars.len() - 1];
- if is_ordinalizable(last_number) {
- return non_ordinalized_string.to_owned();
- }
- if chars.len() > 1 {
- if second_last_number_is_one(chars) {
- return format!("{}{}", non_ordinalized_string, "th");
- } else if string_contains_decimal(non_ordinalized_string.to_owned()) {
- return non_ordinalized_string.to_owned();
- }
- }
- match last_number {
- '1' => format!("{}{}", non_ordinalized_string, "st"),
- '2' => format!("{}{}", non_ordinalized_string, "nd"),
- '3' => format!("{}{}", non_ordinalized_string, "rd"),
- _ => format!("{}{}", non_ordinalized_string, "th"),
- }
-}
-
-fn is_ordinalizable(last_number: char) -> bool {
- !last_number.is_numeric()
-}
-
-fn second_last_number_is_one(chars: Vec<char>) -> bool {
- let second_last_number: char = chars[chars.len() - 2];
- second_last_number == '1'
-}
-
-fn string_contains_decimal(non_ordinalized_string: String) -> bool {
- non_ordinalized_string.contains('.')
-}
diff --git a/src/string/constants/mod.rs b/src/string/constants/mod.rs
deleted file mode 100644
index 0ba4e42..0000000
--- a/src/string/constants/mod.rs
+++ /dev/null
@@ -1,225 +0,0 @@
-pub const UNACCONTABLE_WORDS: [&'static str; 202] = ["accommodation",
- "adulthood",
- "advertising",
- "advice",
- "aggression",
- "aid",
- "air",
- "aircraft",
- "alcohol",
- "anger",
- "applause",
- "arithmetic",
- "assistance",
- "athletics",
-
- "bacon",
- "baggage",
- "beef",
- "biology",
- "blood",
- "botany",
- "bread",
- "butter",
-
- "carbon",
- "cardboard",
- "cash",
- "chalk",
- "chaos",
- "chess",
- "crossroads",
- "countryside",
-
- "dancing",
- "deer",
- "dignity",
- "dirt",
- "dust",
-
- "economics",
- "education",
- "electricity",
- "engineering",
- "enjoyment",
- "envy",
- "equipment",
- "ethics",
- "evidence",
- "evolution",
-
- "fame",
- "fiction",
- "flour",
- "flu",
- "food",
- "fuel",
- "fun",
- "furniture",
-
- "gallows",
- "garbage",
- "garlic",
- "genetics",
- "gold",
- "golf",
- "gossip",
- "grammar",
- "gratitude",
- "grief",
- "guilt",
- "gymnastics",
-
- "happiness",
- "hardware",
- "harm",
- "hate",
- "hatred",
- "health",
- "heat",
- "help",
- "homework",
- "honesty",
- "honey",
- "hospitality",
- "housework",
- "humour",
- "hunger",
- "hydrogen",
-
- "ice",
- "importance",
- "inflation",
- "information",
- "innocence",
- "iron",
- "irony",
-
- "jam",
- "jewelry",
- "judo",
-
- "karate",
- "knowledge",
-
- "lack",
- "laughter",
- "lava",
- "leather",
- "leisure",
- "lightning",
- "linguine",
- "linguini",
- "linguistics",
- "literature",
- "litter",
- "livestock",
- "logic",
- "loneliness",
- "luck",
- "luggage",
-
- "macaroni",
- "machinery",
- "magic",
- "management",
- "mankind",
- "marble",
- "mathematics",
- "mayonnaise",
- "measles",
- "methane",
- "milk",
- "money",
- "mud",
- "music",
- "mumps",
-
- "nature",
- "news",
- "nitrogen",
- "nonsense",
- "nurture",
- "nutrition",
-
- "obedience",
- "obesity",
- "oxygen",
-
- "pasta",
- "patience",
- "physics",
- "poetry",
- "pollution",
- "poverty",
- "pride",
- "psychology",
- "publicity",
- "punctuation",
-
- "quartz",
-
- "racism",
- "relaxation",
- "reliability",
- "research",
- "respect",
- "revenge",
- "rice",
- "rubbish",
- "rum",
-
- "safety",
- "scenery",
- "seafood",
- "seaside",
- "series",
- "shame",
- "sheep",
- "shopping",
- "sleep",
- "smoke",
- "smoking",
- "snow",
- "soap",
- "software",
- "soil",
- "spaghetti",
- "species",
- "steam",
- "stuff",
- "stupidity",
- "sunshine",
- "symmetry",
-
- "tennis",
- "thirst",
- "thunder",
- "timber",
- "traffic",
- "transportation",
- "trust",
-
- "underwear",
- "unemployment",
- "unity",
-
- "validity",
- "veal",
- "vegetation",
- "vegetarianism",
- "vengeance",
- "violence",
- "vitality",
-
- "warmth",
- "wealth",
- "weather",
- "welfare",
- "wheat",
- "wildlife",
- "wisdom",
- "yoga",
-
- "zinc",
- "zoology"];
diff --git a/src/string/deconstantize/mod.rs b/src/string/deconstantize/mod.rs
deleted file mode 100644
index 5b106e5..0000000
--- a/src/string/deconstantize/mod.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-#[cfg(feature = "heavyweight")]
-use cases::classcase::to_class_case;
-
-#[cfg(feature = "heavyweight")]
-/// Deconstantizes a `&str`
-///
-/// ```
-/// use inflector::string::deconstantize::deconstantize;
-/// let mock_string: &str = "Bar";
-/// let expected_string: String = "".to_owned();
-/// let asserted_string: String = deconstantize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::deconstantize::deconstantize;
-/// let mock_string: &str = "::Bar";
-/// let expected_string: String = "".to_owned();
-/// let asserted_string: String = deconstantize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::deconstantize::deconstantize;
-/// let mock_string: &str = "Foo::Bar";
-/// let expected_string: String = "Foo".to_owned();
-/// let asserted_string: String = deconstantize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::deconstantize::deconstantize;
-/// let mock_string: &str = "Test::Foo::Bar";
-/// let expected_string: String = "Foo".to_owned();
-/// let asserted_string: String = deconstantize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn deconstantize(non_deconstantized_string: &str) -> String {
- if non_deconstantized_string.contains("::") {
- let split_string: Vec<&str> = non_deconstantized_string.split("::").collect();
- if split_string.len() > 1 {
- to_class_case(split_string[split_string.len() - 2])
- } else {
- "".to_owned()
- }
- } else {
- "".to_owned()
- }
-}
diff --git a/src/string/demodulize/mod.rs b/src/string/demodulize/mod.rs
deleted file mode 100644
index 5d4bd77..0000000
--- a/src/string/demodulize/mod.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-#[cfg(feature = "heavyweight")]
-use cases::classcase::to_class_case;
-
-#[cfg(feature = "heavyweight")]
-/// Demodulize a `&str`
-///
-/// ```
-/// use inflector::string::demodulize::demodulize;
-/// let mock_string: &str = "Bar";
-/// let expected_string: String = "Bar".to_owned();
-/// let asserted_string: String = demodulize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::demodulize::demodulize;
-/// let mock_string: &str = "::Bar";
-/// let expected_string: String = "Bar".to_owned();
-/// let asserted_string: String = demodulize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::demodulize::demodulize;
-/// let mock_string: &str = "Foo::Bar";
-/// let expected_string: String = "Bar".to_owned();
-/// let asserted_string: String = demodulize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::demodulize::demodulize;
-/// let mock_string: &str = "Test::Foo::Bar";
-/// let expected_string: String = "Bar".to_owned();
-/// let asserted_string: String = demodulize(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn demodulize(non_demodulize_string: &str) -> String {
- if non_demodulize_string.contains("::") {
- let split_string: Vec<&str> = non_demodulize_string.split("::").collect();
- to_class_case(split_string[split_string.len() - 1])
- } else {
- non_demodulize_string.to_owned()
- }
-}
diff --git a/src/string/mod.rs b/src/string/mod.rs
deleted file mode 100644
index 7270288..0000000
--- a/src/string/mod.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-#![deny(warnings)]
-/// Provides demodulize a string.
-///
-/// Example string `Foo::Bar` becomes `Bar`
-#[cfg(feature = "heavyweight")]
-pub mod demodulize;
-/// Provides deconstantizea string.
-///
-/// Example string `Foo::Bar` becomes `Foo`
-#[cfg(feature = "heavyweight")]
-pub mod deconstantize;
-/// Provides conversion to plural strings.
-///
-/// Example string `FooBar` -> `FooBars`
-#[cfg(feature = "heavyweight")]
-pub mod pluralize;
-/// Provides conversion to singular strings.
-///
-/// Example string `FooBars` -> `FooBar`
-#[cfg(feature = "heavyweight")]
-pub mod singularize;
-
-mod constants;
diff --git a/src/string/pluralize/mod.rs b/src/string/pluralize/mod.rs
deleted file mode 100644
index 1caeea5..0000000
--- a/src/string/pluralize/mod.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-#![deny(warnings)]
-use regex::Regex;
-use string::constants::UNACCONTABLE_WORDS;
-
-macro_rules! add_rule{
- ($r:ident, $rule:expr => $replace:expr) => {
- $r.push((Regex::new($rule).unwrap(), $replace));
- }
-}
-
-macro_rules! rules{
- ($r:ident; $($rule:expr => $replace:expr), *) => {
- $(
- add_rule!{$r, $rule => $replace}
- )*
- }
-}
-
-
-lazy_static!{
- static ref RULES: Vec<(Regex, &'static str)> = {
- let mut r = Vec::with_capacity(24);
- rules![r;
- r"(\w*)s$" => "s",
- r"(\w*([^aeiou]ese))$" => "",
- r"(\w*(ax|test))is$" => "es",
- r"(\w*(alias|[^aou]us|tlas|gas|ris))$" => "es",
- r"(\w*(e[mn]u))s?$" => "s",
- r"(\w*([^l]ias|[aeiou]las|[emjzr]as|[iu]am))$" => "",
- r"(\w*(alumn|syllab|octop|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat))(?:us|i)$" => "i",
- r"(\w*(alumn|alg|vertebr))(?:a|ae)$" => "ae",
- r"(\w*(seraph|cherub))(?:im)?$" => "im",
- r"(\w*(her|at|gr))o$" => "oes",
- r"(\w*(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor))(?:a|um)$" => "a",
- r"(\w*(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat))(?:a|on)$" => "a",
- r"(\w*)sis$" => "ses",
- r"(\w*(kni|wi|li))fe$" => "ves",
- r"(\w*(ar|l|ea|eo|oa|hoo))f$" => "ves",
- r"(\w*([^aeiouy]|qu))y$" => "ies",
- r"(\w*([^ch][ieo][ln]))ey$" => "ies",
- r"(\w*(x|ch|ss|sh|zz)es)$" => "",
- r"(\w*(x|ch|ss|sh|zz))$" => "es",
- r"(\w*(matr|cod|mur|sil|vert|ind|append))(?:ix|ex)$" => "ices",
- r"(\w*(m|l)(?:ice|ouse))$" => "ice",
- r"(\w*(pe)(?:rson|ople))$" => "ople",
- r"(\w*(child))(?:ren)?$" => "ren",
- r"(\w*eaux)$" => ""
- ];
- r
- };
-}
-
-macro_rules! special_cases{
- ($s:ident, $($singular: expr => $plural:expr), *) => {
- match &$s[..] {
- $(
- $singular => {
- return $plural.to_owned();
- },
- )*
- _ => ()
- }
- }
-}
-
-
-/// Converts a `&str` to pluralized `String`
-///
-/// ```
-/// use inflector::string::pluralize::to_plural;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "foo_bars".to_owned();
-/// let asserted_string: String = to_plural(mock_string);
-/// assert_eq!(asserted_string, expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::pluralize::to_plural;
-/// let mock_string: &str = "ox";
-/// let expected_string: String = "oxen".to_owned();
-/// let asserted_string: String = to_plural(mock_string);
-/// assert_eq!(asserted_string, expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::pluralize::to_plural;
-/// let mock_string: &str = "crate";
-/// let expected_string: String = "crates".to_owned();
-/// let asserted_string: String = to_plural(mock_string);
-/// assert_eq!(asserted_string, expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::pluralize::to_plural;
-/// let mock_string: &str = "boxes";
-/// let expected_string: String = "boxes".to_owned();
-/// let asserted_string: String = to_plural(mock_string);
-/// assert_eq!(asserted_string, expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::pluralize::to_plural;
-/// let mock_string: &str = "vengeance";
-/// let expected_string: String = "vengeance".to_owned();
-/// let asserted_string: String = to_plural(mock_string);
-/// assert_eq!(asserted_string, expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::pluralize::to_plural;
-/// let mock_string: &str = "yoga";
-/// let expected_string: String = "yoga".to_owned();
-/// let asserted_string: String = to_plural(mock_string);
-/// assert_eq!(asserted_string, expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::pluralize::to_plural;
-/// let mock_string: &str = "geometry";
-/// let expected_string: String = "geometries".to_owned();
-/// let asserted_string: String = to_plural(mock_string);
-/// assert_eq!(asserted_string, expected_string);
-///
-/// ```
-///
-pub fn to_plural(non_plural_string: &str) -> String {
- if UNACCONTABLE_WORDS.contains(&non_plural_string.as_ref()) {
- non_plural_string.to_owned()
- } else {
- special_cases![non_plural_string,
- "ox" => "oxen",
- "man" => "men",
- "woman" => "women",
- "die" => "dice",
- "yes" => "yeses",
- "foot" => "feet",
- "eave" => "eaves",
- "goose" => "geese",
- "tooth" => "teeth",
- "quiz" => "quizzes"
- ];
- for &(ref rule, replace) in RULES.iter().rev() {
- if let Some(c) = rule.captures(&non_plural_string) {
- if let Some(c) = c.get(1) {
- return format!("{}{}", c.as_str(), replace);
- }
- }
- }
-
- format!("{}s", non_plural_string)
- }
-}
-
-
-#[cfg(test)]
-mod tests {
-
- macro_rules! as_item {
- ($i:item) => { $i };
- }
-
- macro_rules! make_tests{
- ($($singular:ident => $plural:ident); *) =>{
- $(
- as_item! {
- #[test]
- fn $singular(){
- assert_eq!(
- stringify!($plural),
- super::to_plural(stringify!($singular))
- );
- }
- }
- )*
- }
- }
-
- #[test]
- fn boxes() {
- assert_eq!("boxes", super::to_plural("box"));
- }
-
- make_tests!{
- geometry => geometries;
- ox => oxen;
- woman => women;
- test => tests;
- axis => axes;
- knife => knives;
- agendum => agenda;
- elf => elves;
- zoology => zoology
- }
-}
diff --git a/src/string/singularize/mod.rs b/src/string/singularize/mod.rs
deleted file mode 100644
index 60e0b51..0000000
--- a/src/string/singularize/mod.rs
+++ /dev/null
@@ -1,189 +0,0 @@
-use regex::Regex;
-use string::constants::UNACCONTABLE_WORDS;
-
-macro_rules! special_cases{
- ($s:ident, $($singular: expr => $plural:expr), *) => {
- match &$s[..] {
- $(
- $singular => {
- return $plural.to_owned();
- },
- )*
- _ => ()
- }
- }
-}
-
-
-/// Converts a `&str` to singularized `String`
-///
-/// ```
-/// use inflector::string::singularize::to_singular;
-/// let mock_string: &str = "foo_bars";
-/// let expected_string: String = "foo_bar".to_owned();
-/// let asserted_string: String = to_singular(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::singularize::to_singular;
-/// let mock_string: &str = "oxen";
-/// let expected_string: String = "ox".to_owned();
-/// let asserted_string: String = to_singular(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::singularize::to_singular;
-/// let mock_string: &str = "crates";
-/// let expected_string: String = "crate".to_owned();
-/// let asserted_string: String = to_singular(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::singularize::to_singular;
-/// let mock_string: &str = "oxen";
-/// let expected_string: String = "ox".to_owned();
-/// let asserted_string: String = to_singular(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::singularize::to_singular;
-/// let mock_string: &str = "boxes";
-/// let expected_string: String = "box".to_owned();
-/// let asserted_string: String = to_singular(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::singularize::to_singular;
-/// let mock_string: &str = "vengeance";
-/// let expected_string: String = "vengeance".to_owned();
-/// let asserted_string: String = to_singular(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::string::singularize::to_singular;
-/// let mock_string: &str = "yoga";
-/// let expected_string: String = "yoga".to_owned();
-/// let asserted_string: String = to_singular(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-///
-pub fn to_singular(non_singular_string: &str) -> String {
- if UNACCONTABLE_WORDS.contains(&non_singular_string.as_ref()) {
- non_singular_string.to_owned()
- } else {
- special_cases![non_singular_string,
- "oxen" => "ox",
- "boxes" => "box",
- "men" => "man",
- "women" => "woman",
- "dice" => "die",
- "yeses" => "yes",
- "feet" => "foot",
- "eaves" => "eave",
- "geese" => "goose",
- "teeth" => "tooth",
- "quizzes" => "quiz"
- ];
- for &(ref rule, replace) in RULES.iter().rev() {
- if let Some(captures) = rule.captures(&non_singular_string) {
- if let Some(c) = captures.get(1) {
- let mut buf = String::new();
- captures.expand(&format!("{}{}", c.as_str(), replace), &mut buf);
- return buf;
- }
- }
- }
-
- format!("{}", non_singular_string)
- }
-}
-
-macro_rules! add_rule{
- ($r:ident, $rule:expr => $replace:expr) => {
- $r.push((Regex::new($rule).unwrap(), $replace));
- }
-}
-
-macro_rules! rules{
- ($r:ident; $($rule:expr => $replace:expr), *) => {
- $(
- add_rule!{$r, $rule => $replace}
- )*
- }
-}
-
-
-lazy_static!{
- static ref RULES: Vec<(Regex, &'static str)> = {
- let mut r = Vec::with_capacity(27);
- rules![r;
- r"(\w*)s$" => "",
- r"(\w*)(ss)$" => "$2",
- r"(n)ews$" => "ews",
- r"(\w*)(o)es$" => "",
- r"(\w*)([ti])a$" => "um",
- r"((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$" => "sis",
- r"(^analy)(sis|ses)$" => "sis",
- r"(\w*)([^f])ves$" => "fe",
- r"(\w*)(hive)s$" => "",
- r"(\w*)(tive)s$" => "",
- r"(\w*)([lr])ves$" => "f",
- r"(\w*([^aeiouy]|qu))ies$" => "y",
- r"(s)eries$" => "eries",
- r"(m)ovies$" => "ovie",
- r"(\w*)(x|ch|ss|sh)es$" => "$2",
- r"(m|l)ice$" => "ouse",
- r"(bus)(es)?$" => "",
- r"(shoe)s$" => "",
- r"(cris|test)(is|es)$" => "is",
- r"^(a)x[ie]s$" => "xis",
- r"(octop|vir)(us|i)$" => "us",
- r"(alias|status)(es)?$" => "",
- r"^(ox)en" => "",
- r"(vert|ind)ices$" => "ex",
- r"(matr)ices$" => "ix",
- r"(quiz)zes$" => "",
- r"(database)s$" => ""
- ];
- r
- };
-}
-
-#[test]
-fn singularize_ies_suffix() {
- assert_eq!("reply", to_singular("replies"));
- assert_eq!("lady", to_singular("ladies"));
- assert_eq!("soliloquy", to_singular("soliloquies"));
-}
-
-#[test]
-fn singularize_ss_suffix() {
- assert_eq!("glass", to_singular("glass"));
- assert_eq!("access", to_singular("access"));
- assert_eq!("glass", to_singular("glasses"));
- assert_eq!("witch", to_singular("witches"));
- assert_eq!("dish", to_singular("dishes"));
-}
-
-#[test]
-fn singularize_string_if_a_regex_will_match() {
- let expected_string: String = "ox".to_owned();
- let asserted_string: String = to_singular("oxen");
- assert!(expected_string == asserted_string);
-
-}
-
-#[test]
-fn singularize_string_returns_none_option_if_no_match() {
- let expected_string: String = "bacon".to_owned();
- let asserted_string: String = to_singular("bacon");
-
- assert!(expected_string == asserted_string);
-}
diff --git a/src/suffix/foreignkey/mod.rs b/src/suffix/foreignkey/mod.rs
deleted file mode 100644
index e46696d..0000000
--- a/src/suffix/foreignkey/mod.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-use cases::snakecase::to_snake_case;
-
-/// Converts a `&str` to a `foreign_key`
-///
-/// ```
-/// use inflector::suffix::foreignkey::to_foreign_key;
-/// let mock_string: &str = "foo_bar";
-/// let expected_string: String = "foo_bar_id".to_owned();
-/// let asserted_string: String = to_foreign_key(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::to_foreign_key;
-/// let mock_string: &str = "Foo bar";
-/// let expected_string: String = "foo_bar_id".to_owned();
-/// let asserted_string: String = to_foreign_key(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::to_foreign_key;
-/// let mock_string: &str = "Foo Bar";
-/// let expected_string: String = "foo_bar_id".to_owned();
-/// let asserted_string: String = to_foreign_key(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::to_foreign_key;
-/// let mock_string: &str = "Foo::Bar";
-/// let expected_string: String = "bar_id".to_owned();
-/// let asserted_string: String = to_foreign_key(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::to_foreign_key;
-/// let mock_string: &str = "Test::Foo::Bar";
-/// let expected_string: String = "bar_id".to_owned();
-/// let asserted_string: String = to_foreign_key(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::to_foreign_key;
-/// let mock_string: &str = "FooBar";
-/// let expected_string: String = "foo_bar_id".to_owned();
-/// let asserted_string: String = to_foreign_key(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::to_foreign_key;
-/// let mock_string: &str = "fooBar";
-/// let expected_string: String = "foo_bar_id".to_owned();
-/// let asserted_string: String = to_foreign_key(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::to_foreign_key;
-/// let mock_string: &str = "fooBar3";
-/// let expected_string: String = "foo_bar_3_id".to_owned();
-/// let asserted_string: String = to_foreign_key(mock_string);
-/// assert!(asserted_string == expected_string);
-///
-/// ```
-pub fn to_foreign_key(non_foreign_key_string: &str) -> String {
- if non_foreign_key_string.contains("::") {
- let split_string: Vec<&str> = non_foreign_key_string.split("::").collect();
- safe_convert(split_string[split_string.len() - 1])
- } else {
- safe_convert(non_foreign_key_string)
- }
-}
-fn safe_convert(safe_string: &str) -> String {
- let snake_cased: String = to_snake_case(safe_string);
- if snake_cased.ends_with("_id") {
- snake_cased
- } else {
- format!("{}{}", snake_cased, "_id")
- }
-}
-
-/// Determines if a `&str` is a `foreign_key`
-///
-/// ```
-/// use inflector::suffix::foreignkey::is_foreign_key;
-/// let mock_string: &str = "Foo bar string that is really really long";
-/// let asserted_bool: bool = is_foreign_key(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::is_foreign_key;
-/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
-/// let asserted_bool: bool = is_foreign_key(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::is_foreign_key;
-/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_foreign_key(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::is_foreign_key;
-/// let mock_string: &str = "Foo Bar Is A Really Really Long String";
-/// let asserted_bool: bool = is_foreign_key(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::is_foreign_key;
-/// let mock_string: &str = "fooBarIsAReallyReallyLongString";
-/// let asserted_bool: bool = is_foreign_key(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::is_foreign_key;
-/// let mock_string: &str = "foo_bar_string_that_is_really_really_long";
-/// let asserted_bool: bool = is_foreign_key(mock_string);
-/// assert!(asserted_bool == false);
-///
-/// ```
-/// ```
-/// use inflector::suffix::foreignkey::is_foreign_key;
-/// let mock_string: &str = "foo_bar_string_that_is_really_really_long_id";
-/// let asserted_bool: bool = is_foreign_key(mock_string);
-/// assert!(asserted_bool == true);
-///
-/// ```
-pub fn is_foreign_key(test_string: &str) -> bool {
- to_foreign_key(test_string.clone()) == test_string
-}
diff --git a/src/suffix/mod.rs b/src/suffix/mod.rs
deleted file mode 100644
index 2083cd5..0000000
--- a/src/suffix/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#![deny(warnings)]
-/// Provides foreign key conversion for String.
-///
-/// Example string `foo` becomes `foo_id`
-pub mod foreignkey;
diff --git a/tests/lib.rs b/tests/lib.rs
deleted file mode 100644
index 62d77f4..0000000
--- a/tests/lib.rs
+++ /dev/null
@@ -1,162 +0,0 @@
-#![deny(warnings)]
-extern crate inflector;
-
-use inflector::Inflector;
-use inflector::InflectorNumbers;
-
-macro_rules! str_tests {
- ( $($test_name:ident => $imp_trait:ident => $to_cast:expr => $casted:expr), *) => {
- $(
- #[test]
- fn $test_name() {
- assert_eq!($to_cast.$imp_trait(), $casted)
- }
- )*
- }
-}
-
-macro_rules! string_tests {
- ( $($test_name:ident => $imp_trait:ident => $to_cast:expr => $casted:expr), *) => {
- $(
- #[test]
- fn $test_name() {
- assert_eq!($to_cast.to_string().$imp_trait(), $casted)
- }
- )*
- }
-}
-
-macro_rules! number_tests {
- ( $($test_name:ident => $imp_trait:ident => $typ:ident => $to_cast:expr => $casted:expr), *) => {
- $(
- #[test]
- fn $test_name() {
- let to_cast: $typ = $to_cast;
- assert_eq!(to_cast.$imp_trait(), $casted)
- }
- )*
- }
-}
-
-macro_rules! gated_str_tests {
- ( $($test_name:ident => $imp_trait:ident => $to_cast:expr => $casted:expr), *) => {
- $(
- #[test]
- #[cfg(feature = "heavyweight")]
- fn $test_name() {
- assert_eq!($to_cast.$imp_trait(), $casted)
- }
- )*
- }
-}
-
-macro_rules! gated_string_tests {
- ( $($test_name:ident => $imp_trait:ident => $to_cast:expr => $casted:expr), *) => {
- $(
- #[test]
- #[cfg(feature = "heavyweight")]
- fn $test_name() {
- assert_eq!($to_cast.to_string().$imp_trait(), $casted)
- }
- )*
- }
-}
-
-str_tests![
- str_to_camel => to_camel_case => "foo_bar" => "fooBar".to_string(),
- str_is_camel => is_camel_case => "fooBar" => true,
- str_is_not_camel => is_camel_case => "foo_bar" => false,
- str_to_screaming_snake => to_screaming_snake_case => "fooBar" => "FOO_BAR".to_string(),
- str_is_screaming_snake => is_screaming_snake_case => "FOO_BAR" => true,
- str_is_not_screaming_snake => is_screaming_snake_case => "foo_bar" => false,
- str_to_snake => to_snake_case => "fooBar" => "foo_bar".to_string(),
- str_is_snake => is_snake_case => "foo_bar" => true,
- str_is_not_snake => is_snake_case => "fooBar" => false,
- str_to_kebab => to_kebab_case => "fooBar" => "foo-bar".to_string(),
- str_is_kebab => is_kebab_case => "foo-bar" => true,
- str_is_not_kebab => is_kebab_case => "fooBar" => false,
- str_to_train => to_train_case => "fooBar" => "Foo-Bar".to_string(),
- str_is_train => is_train_case => "Foo-Bar" => true,
- str_is_not_train => is_train_case => "FOO-Bar" => false,
- str_to_sentence => to_sentence_case => "fooBar" => "Foo bar".to_string(),
- str_is_sentence => is_sentence_case => "Foo bar" => true,
- str_is_not_sentence => is_sentence_case => "foo_bar" => false,
- str_to_title => to_title_case => "fooBar" => "Foo Bar".to_string(),
- str_is_title => is_title_case => "Foo Bar" => true,
- str_is_not_title => is_title_case => "Foo_Bar" => false,
- str_ordinalize => ordinalize => "1" => "1st".to_string(),
- str_deordinalize => deordinalize => "1st" => "1".to_string(),
- str_to_foreign_key => to_foreign_key => "Foo::Bar" => "bar_id".to_string(),
- str_is_foreign_key => is_foreign_key => "bar_id" => true,
- str_is_not_foreign_key => is_foreign_key => "bar" => false
-];
-
-gated_str_tests![
- str_to_class_case => to_class_case => "foo" => "Foo".to_string(),
- str_is_class_case => is_class_case => "Foo" => true,
- str_is_not_class_case => is_class_case => "foo" => false,
- str_to_table => to_table_case => "fooBar" => "foo_bars".to_string(),
- str_is_table => is_table_case => "foo_bars" => true,
- str_is_not_table => is_table_case => "fooBars" => false,
- str_pluralize => to_plural => "crate" => "crates".to_string(),
- str_singular => to_singular => "crates" => "crate".to_string(),
- str_demodulize => demodulize => "Foo::Bar" => "Bar".to_string(),
- str_deconstantize => deconstantize => "Foo::Bar" => "Foo".to_string()
-];
-
-string_tests![
- string_to_camel => to_camel_case => "foo_bar".to_string() => "fooBar".to_string(),
- string_is_camel => is_camel_case => "fooBar".to_string() => true,
- string_is_not_camel => is_camel_case => "foo_bar".to_string() => false,
- string_to_screaming_snake => to_screaming_snake_case => "fooBar".to_string() => "FOO_BAR".to_string(),
- string_is_screaming_snake => is_screaming_snake_case => "FOO_BAR".to_string() => true,
- string_is_not_screaming_snake => is_screaming_snake_case => "foo_bar".to_string() => false,
- string_to_snake => to_snake_case => "fooBar".to_string() => "foo_bar".to_string(),
- string_is_snake => is_snake_case => "foo_bar".to_string() => true,
- string_is_not_snake => is_snake_case => "fooBar".to_string() => false,
- string_to_kebab => to_kebab_case => "fooBar".to_string() => "foo-bar".to_string(),
- string_is_kebab => is_kebab_case => "foo-bar".to_string() => true,
- string_is_not_kebab => is_kebab_case => "fooBar".to_string() => false,
- string_to_train => to_train_case => "fooBar".to_string() => "Foo-Bar".to_string(),
- string_is_train => is_train_case => "Foo-Bar".to_string() => true,
- string_is_not_train => is_train_case => "foo-Bar".to_string() => false,
- string_to_sentence => to_sentence_case => "fooBar".to_string() => "Foo bar".to_string(),
- string_is_sentence => is_sentence_case => "Foo bar".to_string() => true,
- string_is_not_sentence => is_sentence_case => "fooBar".to_string() => false,
- string_to_title => to_title_case => "fooBar".to_string() => "Foo Bar".to_string(),
- string_is_title => is_title_case => "Foo Bar".to_string() => true,
- string_is_not_title => is_title_case => "fooBar".to_string() => false,
- string_ordinalize => ordinalize => "1".to_string() => "1st".to_string(),
- string_deordinalize => deordinalize => "1st".to_string() => "1".to_string(),
- string_to_foreign_key => to_foreign_key => "Foo::Bar".to_string() => "bar_id".to_string(),
- string_is_foreign_key => is_foreign_key => "bar_id".to_string() => true,
- string_is_not_foreign_key => is_foreign_key => "bar".to_string() => false
-];
-
-gated_string_tests![
- string_to_class_case => to_class_case => "foo".to_string() => "Foo".to_string(),
- string_is_class_case => is_class_case => "Foo".to_string() => true,
- string_is_not_class_case => is_class_case => "ooBar".to_string() => false,
- string_to_table => to_table_case => "fooBar".to_string() => "foo_bars".to_string(),
- string_is_table => is_table_case => "foo_bars".to_string() => true,
- string_is_not_table => is_table_case => "fooBar".to_string() => false,
- string_pluralize => to_plural => "crate".to_string() => "crates".to_string(),
- string_singular => to_singular => "crates".to_string() => "crate".to_string(),
- string_demodulize => demodulize => "Foo::Bar".to_string() => "Bar".to_string(),
- string_deconstantize => deconstantize => "Foo::Bar".to_string() => "Foo".to_string()
-];
-
-number_tests![
- i8_ordinalize => ordinalize => i8 => 1 => "1st".to_string(),
- i16_ordinalize => ordinalize => i16 => 1 => "1st".to_string(),
- i32_ordinalize => ordinalize => i32 => 1 => "1st".to_string(),
- i64_ordinalize => ordinalize => i64 => 1 => "1st".to_string(),
- u8_ordinalize => ordinalize => u8 => 1 => "1st".to_string(),
- u16_ordinalize => ordinalize => u16 => 1 => "1st".to_string(),
- u32_ordinalize => ordinalize => u32 => 1 => "1st".to_string(),
- u64_ordinalize => ordinalize => u64 => 1 => "1st".to_string(),
- isize_ordinalize => ordinalize => isize => 1 => "1st".to_string(),
- usize_ordinalize => ordinalize => usize => 1 => "1st".to_string(),
- f32_ordinalize => ordinalize => f32 => 1.0 => "1st".to_string(),
- f64_ordinalize => ordinalize => f64 => 1.0 => "1st".to_string()
-];
