From 5e20a29b4fdc8a2d442d1093681b396dcb4b816b Mon Sep 17 00:00:00 2001 From: Robin Krahl Date: Tue, 7 Jan 2020 11:18:04 +0000 Subject: Add structopt dependency in version 0.3.7 This patch series replaces argparse with structopt in the argument handling code. As a first step, we need structopt as a dependency. Import subrepo structopt/:structopt at efbdda4753592e27bc430fb01f7b9650b2f3174d Import subrepo bitflags/:bitflags at 30668016aca6bd3b02c766e8347e0b4080d4c296 Import subrepo clap/:clap at 784524f7eb193e35f81082cc69454c8c21b948f7 Import subrepo heck/:heck at 093d56fbf001e1506e56dbfa38631d99b1066df1 Import subrepo proc-macro-error/:proc-macro-error at 6c4cfe79a622c5de8ae68557993542be46eacae2 Import subrepo proc-macro2/:proc-macro2 at d5d48eddca4566e5438e8a2cbed4a74e049544de Import subrepo quote/:quote at 727436c6c137b20f0f34dde5d8fda2679b9747ad Import subrepo rustversion/:rustversion at 0c5663313516263059ce9059ef81fc7a1cf655ca Import subrepo syn-mid/:syn-mid at 5d3d85414a9e6674e1857ec22a87b96e04a6851a Import subrepo syn/:syn at e87c27e87f6f4ef8919d0372bdb056d53ef0d8f3 Import subrepo textwrap/:textwrap at abcd618beae3f74841032aa5b53c1086b0a57ca2 Import subrepo unicode-segmentation/:unicode-segmentation at 637c9874c4fe0c205ff27787faf150a40295c6c3 Import subrepo unicode-width/:unicode-width at 3033826f8bf05e82724140a981d5941e48fce393 Import subrepo unicode-xid/:unicode-xid at 4baae9fffb156ba229665b972a9cd5991787ceb7 --- heck/src/camel.rs | 52 +++++++++++++++ heck/src/kebab.rs | 51 +++++++++++++++ heck/src/lib.rs | 165 +++++++++++++++++++++++++++++++++++++++++++++++ heck/src/mixed.rs | 56 ++++++++++++++++ heck/src/shouty_snake.rs | 67 +++++++++++++++++++ heck/src/snake.rs | 79 +++++++++++++++++++++++ heck/src/title.rs | 52 +++++++++++++++ 7 files changed, 522 insertions(+) create mode 100644 heck/src/camel.rs create mode 100644 heck/src/kebab.rs create mode 100644 heck/src/lib.rs create mode 100644 heck/src/mixed.rs create mode 100644 heck/src/shouty_snake.rs create mode 100644 heck/src/snake.rs create mode 100644 heck/src/title.rs (limited to 'heck/src') diff --git a/heck/src/camel.rs b/heck/src/camel.rs new file mode 100644 index 0000000..74bd741 --- /dev/null +++ b/heck/src/camel.rs @@ -0,0 +1,52 @@ +/// This trait defines a camel case conversion. +/// +/// In CamelCase, word boundaries are indicated by capital letters, including +/// the first word. +/// +/// ## Example: +/// +/// ```rust +/// extern crate heck; +/// fn main() { +/// +/// use heck::CamelCase; +/// +/// let sentence = "We are not in the least afraid of ruins."; +/// assert_eq!(sentence.to_camel_case(), "WeAreNotInTheLeastAfraidOfRuins"); +/// } +/// ``` +pub trait CamelCase: ToOwned { + /// Convert this type to camel case. + fn to_camel_case(&self) -> Self::Owned; +} + +impl CamelCase for str { + fn to_camel_case(&self) -> String { + ::transform(self, ::capitalize, |_| {}) + } +} + +#[cfg(test)] +mod tests { + use super::CamelCase; + + macro_rules! t { + ($t:ident : $s1:expr => $s2:expr) => { + #[test] + fn $t() { + assert_eq!($s1.to_camel_case(), $s2) + } + } + } + + t!(test1: "CamelCase" => "CamelCase"); + t!(test2: "This is Human case." => "ThisIsHumanCase"); + t!(test3: "MixedUP_CamelCase, with some Spaces" => "MixedUpCamelCaseWithSomeSpaces"); + t!(test4: "mixed_up_ snake_case, with some _spaces" => "MixedUpSnakeCaseWithSomeSpaces"); + t!(test5: "kebab-case" => "KebabCase"); + t!(test6: "SHOUTY_SNAKE_CASE" => "ShoutySnakeCase"); + t!(test7: "snake_case" => "SnakeCase"); + t!(test8: "this-contains_ ALLKinds OfWord_Boundaries" => "ThisContainsAllKindsOfWordBoundaries"); + t!(test9: "XΣXΣ baffle" => "XσxςBaffle"); + t!(test10: "XMLHttpRequest" => "XmlHttpRequest"); +} diff --git a/heck/src/kebab.rs b/heck/src/kebab.rs new file mode 100644 index 0000000..f81ba92 --- /dev/null +++ b/heck/src/kebab.rs @@ -0,0 +1,51 @@ +/// This trait defines a kebab case conversion. +/// +/// In kebab-case, word boundaries are indicated by hyphens. +/// +/// ## Example: +/// +/// ```rust +/// extern crate heck; +/// fn main() { +/// +/// use heck::KebabCase; +/// +/// let sentence = "We are going to inherit the earth."; +/// assert_eq!(sentence.to_kebab_case(), "we-are-going-to-inherit-the-earth"); +/// } +/// ``` +pub trait KebabCase: ToOwned { + /// Convert this type to kebab case. + fn to_kebab_case(&self) -> Self::Owned; +} + +impl KebabCase for str { + fn to_kebab_case(&self) -> Self::Owned { + ::transform(self, ::lowercase, |s| s.push('-')) + } +} + +#[cfg(test)] +mod tests { + use super::KebabCase; + + macro_rules! t { + ($t:ident : $s1:expr => $s2:expr) => { + #[test] + fn $t() { + assert_eq!($s1.to_kebab_case(), $s2) + } + } + } + + t!(test1: "CamelCase" => "camel-case"); + t!(test2: "This is Human case." => "this-is-human-case"); + t!(test3: "MixedUP CamelCase, with some Spaces" => "mixed-up-camel-case-with-some-spaces"); + t!(test4: "mixed_up_ snake_case with some _spaces" => "mixed-up-snake-case-with-some-spaces"); + t!(test5: "kebab-case" => "kebab-case"); + t!(test6: "SHOUTY_SNAKE_CASE" => "shouty-snake-case"); + t!(test7: "snake_case" => "snake-case"); + t!(test8: "this-contains_ ALLKinds OfWord_Boundaries" => "this-contains-all-kinds-of-word-boundaries"); + t!(test9: "XΣXΣ baffle" => "xσxς-baffle"); + t!(test10: "XMLHttpRequest" => "xml-http-request"); +} diff --git a/heck/src/lib.rs b/heck/src/lib.rs new file mode 100644 index 0000000..c35ba34 --- /dev/null +++ b/heck/src/lib.rs @@ -0,0 +1,165 @@ +//! **heck** is a case conversion library. +//! +//! This library exists to provide case conversion between common cases like +//! CamelCase and snake_case. It is intended to be unicode aware, internally, +//! consistent, and reasonably well performing. +//! +//! ## Definition of a word boundary +//! +//! Word boundaries are defined as the "unicode words" defined in the +//! `unicode_segmentation` library, as well as within those words in this manner: +//! +//! 1. All underscore characters are considered word boundaries. +//! 2. If an uppercase character is followed by lowercase letters, a word boundary +//! is considered to be just prior to that uppercase character. +//! 3. If multiple uppercase characters are consecutive, they are considered to be +//! within a single word, except that the last will be part of the next word if it +//! is followed by lowercase characters (see rule 2). +//! +//! That is, "HelloWorld" is segmented `Hello|World` whereas "XMLHttpRequest" is +//! segmented `XML|Http|Request`. +//! +//! Characters not within words (such as spaces, punctuations, and underscores) +//! are not included in the output string except as they are a part of the case +//! being converted to. Multiple adjacent word boundaries (such as a series of +//! underscores) are folded into one. ("hello__world" in snake case is therefore +//! "hello_world", not the exact same string). Leading or trailing word boundary +//! indicators are dropped, except insofar as CamelCase capitalizes the first word. +//! +//! ### Cases contained in this library: +//! +//! 1. CamelCase +//! 2. snake_case +//! 3. kebab-case +//! 4. SHOUTY_SNAKE_CASE +//! 5. mixedCase +//! 6. Title Case +#![deny(missing_docs)] +extern crate unicode_segmentation; + +mod camel; +mod kebab; +mod mixed; +mod shouty_snake; +mod snake; +mod title; + +pub use camel::CamelCase; +pub use kebab::KebabCase; +pub use mixed::MixedCase; +pub use shouty_snake::{ShoutySnakeCase, ShoutySnekCase}; +pub use snake::{SnakeCase, SnekCase}; +pub use title::TitleCase; + +use unicode_segmentation::UnicodeSegmentation; + +fn transform(s: &str, with_word: F, boundary: G) -> String +where + F: Fn(&str, &mut String), + G: Fn(&mut String) +{ + + /// Tracks the current 'mode' of the transformation algorithm as it scans the input string. + /// + /// The mode is a tri-state which tracks the case of the last cased character of the current + /// word. If there is no cased character (either lowercase or uppercase) since the previous + /// word boundary, than the mode is `Boundary`. If the last cased character is lowercase, then + /// the mode is `Lowercase`. Othertherwise, the mode is `Uppercase`. + #[derive(Clone, Copy, PartialEq)] + enum WordMode { + /// There have been no lowercase or uppercase characters in the current word. + Boundary, + /// The previous cased character in the current word is lowercase. + Lowercase, + /// The previous cased character in the current word is uppercase. + Uppercase, + } + + let mut out = String::new(); + let mut first_word = true; + + for word in s.unicode_words() { + let mut char_indices = word.char_indices().peekable(); + let mut init = 0; + let mut mode = WordMode::Boundary; + + while let Some((i, c)) = char_indices.next() { + // Skip underscore characters + if c == '_' { + if init == i { init += 1; } + continue + } + + if let Some(&(next_i, next)) = char_indices.peek() { + + // The mode including the current character, assuming the current character does + // not result in a word boundary. + let next_mode = if c.is_lowercase() { + WordMode::Lowercase + } else if c.is_uppercase() { + WordMode::Uppercase + } else { + mode + }; + + // Word boundary after if next is underscore or current is + // not uppercase and next is uppercase + if next == '_' || (next_mode == WordMode::Lowercase && next.is_uppercase()) { + if !first_word { boundary(&mut out); } + with_word(&word[init..next_i], &mut out); + first_word = false; + init = next_i; + mode = WordMode::Boundary; + + // Otherwise if current and previous are uppercase and next + // is lowercase, word boundary before + } else if mode == WordMode::Uppercase && c.is_uppercase() && next.is_lowercase() { + if !first_word { boundary(&mut out); } + else { first_word = false; } + with_word(&word[init..i], &mut out); + init = i; + mode = WordMode::Boundary; + + // Otherwise no word boundary, just update the mode + } else { + mode = next_mode; + } + } else { + // Collect trailing characters as a word + if !first_word { boundary(&mut out); } + else { first_word = false; } + with_word(&word[init..], &mut out); + break; + } + } + } + + out +} + +fn lowercase(s: &str, out: &mut String) { + let mut chars = s.chars().peekable(); + while let Some(c) = chars.next() { + if c == 'Σ' && chars.peek().is_none() { + out.push('ς'); + } else { + out.extend(c.to_lowercase()); + } + } +} + +fn uppercase(s: &str, out: &mut String ) { + for c in s.chars() { + out.extend(c.to_uppercase()) + } +} + +fn capitalize(s: &str, out: &mut String) { + let mut char_indices = s.char_indices(); + if let Some((_, c)) = char_indices.next() { + out.extend(c.to_uppercase()); + if let Some((i, _)) = char_indices.next() { + lowercase(&s[i..], out); + } + } +} diff --git a/heck/src/mixed.rs b/heck/src/mixed.rs new file mode 100644 index 0000000..7736684 --- /dev/null +++ b/heck/src/mixed.rs @@ -0,0 +1,56 @@ +/// This trait defines a mixed case conversion. +/// +/// In mixedCase, word boundaries are indicated by capital letters, excepting +/// the first word. +/// +/// ## Example: +/// +/// ```rust +/// extern crate heck; +/// fn main() { +/// +/// use heck::MixedCase; +/// +/// let sentence = "It is we who built these palaces and cities."; +/// assert_eq!(sentence.to_mixed_case(), "itIsWeWhoBuiltThesePalacesAndCities"); +/// } +/// ``` +pub trait MixedCase: ToOwned { + /// Convert this type to mixed case. + fn to_mixed_case(&self) -> Self::Owned; +} + +impl MixedCase for str { + fn to_mixed_case(&self) -> String { + ::transform(self, |s, out| { + if out.is_empty() { ::lowercase(s, out); } + else { ::capitalize(s, out) } + }, |_| {}) + } +} + +#[cfg(test)] +mod tests { + use super::MixedCase; + + macro_rules! t { + ($t:ident : $s1:expr => $s2:expr) => { + #[test] + fn $t() { + assert_eq!($s1.to_mixed_case(), $s2) + } + } + } + + t!(test1: "CamelCase" => "camelCase"); + t!(test2: "This is Human case." => "thisIsHumanCase"); + t!(test3: "MixedUP CamelCase, with some Spaces" => "mixedUpCamelCaseWithSomeSpaces"); + t!(test4: "mixed_up_ snake_case, with some _spaces" => "mixedUpSnakeCaseWithSomeSpaces"); + t!(test5: "kebab-case" => "kebabCase"); + t!(test6: "SHOUTY_SNAKE_CASE" => "shoutySnakeCase"); + t!(test7: "snake_case" => "snakeCase"); + t!(test8: "this-contains_ ALLKinds OfWord_Boundaries" => "thisContainsAllKindsOfWordBoundaries"); + t!(test9: "XΣXΣ baffle" => "xσxςBaffle"); + t!(test10: "XMLHttpRequest" => "xmlHttpRequest"); + // TODO unicode tests +} diff --git a/heck/src/shouty_snake.rs b/heck/src/shouty_snake.rs new file mode 100644 index 0000000..0f846c3 --- /dev/null +++ b/heck/src/shouty_snake.rs @@ -0,0 +1,67 @@ +/// This trait defines a shouty snake case conversion. +/// +/// In SHOUTY_SNAKE_CASE, word boundaries are indicated by underscores and all +/// words are in uppercase. +/// +/// ## Example: +/// +/// ```rust +/// extern crate heck; +/// fn main() { +/// +/// use heck::ShoutySnakeCase; +/// +/// let sentence = "That world is growing in this minute."; +/// assert_eq!(sentence.to_shouty_snake_case(), "THAT_WORLD_IS_GROWING_IN_THIS_MINUTE"); +/// } +/// ``` +pub trait ShoutySnakeCase: ToOwned { + /// Convert this type to shouty snake case. + fn to_shouty_snake_case(&self) -> Self::Owned; +} + +/// Oh heck, ShoutySnekCase is an alias for ShoutySnakeCase. See ShoutySnakeCase for +/// more documentation. +pub trait ShoutySnekCase: ToOwned { + /// CONVERT THIS TYPE TO SNEK CASE. + #[allow(non_snake_case)] + fn TO_SHOUTY_SNEK_CASE(&self) -> Self::Owned; +} + +impl ShoutySnekCase for T { + fn TO_SHOUTY_SNEK_CASE(&self) -> Self::Owned { + self.to_shouty_snake_case() + } +} + + +impl ShoutySnakeCase for str { + fn to_shouty_snake_case(&self) -> Self::Owned { + ::transform(self, ::uppercase, |s| s.push('_')) + } +} + +#[cfg(test)] +mod tests { + use super::ShoutySnakeCase; + + macro_rules! t { + ($t:ident : $s1:expr => $s2:expr) => { + #[test] + fn $t() { + assert_eq!($s1.to_shouty_snake_case(), $s2) + } + } + } + + t!(test1: "CamelCase" => "CAMEL_CASE"); + t!(test2: "This is Human case." => "THIS_IS_HUMAN_CASE"); + t!(test3: "MixedUP CamelCase, with some Spaces" => "MIXED_UP_CAMEL_CASE_WITH_SOME_SPACES"); + t!(test4: "mixed_up_snake_case with some _spaces" => "MIXED_UP_SNAKE_CASE_WITH_SOME_SPACES"); + t!(test5: "kebab-case" => "KEBAB_CASE"); + t!(test6: "SHOUTY_SNAKE_CASE" => "SHOUTY_SNAKE_CASE"); + t!(test7: "snake_case" => "SNAKE_CASE"); + t!(test8: "this-contains_ ALLKinds OfWord_Boundaries" => "THIS_CONTAINS_ALL_KINDS_OF_WORD_BOUNDARIES"); + t!(test9: "XΣXΣ baffle" => "XΣXΣ_BAFFLE"); + t!(test10: "XMLHttpRequest" => "XML_HTTP_REQUEST"); +} diff --git a/heck/src/snake.rs b/heck/src/snake.rs new file mode 100644 index 0000000..86c3756 --- /dev/null +++ b/heck/src/snake.rs @@ -0,0 +1,79 @@ +/// This trait defines a camel case conversion. +/// +/// In snake_case, word boundaries are indicated by underscores. +/// +/// ## Example: +/// +/// ```rust +/// extern crate heck; +/// fn main() { +/// +/// use heck::SnakeCase; +/// +/// let sentence = "We carry a new world here, in our hearts."; +/// assert_eq!(sentence.to_snake_case(), "we_carry_a_new_world_here_in_our_hearts"); +/// } +/// ``` +pub trait SnakeCase: ToOwned { + /// Convert this type to snake case. + fn to_snake_case(&self) -> Self::Owned; +} + +/// Oh heck, SnekCase is an alias for SnakeCase. See SnakeCase for +/// more documentation. +pub trait SnekCase: ToOwned { + /// Convert this type to snek case. + fn to_snek_case(&self) -> Self::Owned; +} + +impl SnekCase for T { + fn to_snek_case(&self) -> Self::Owned { + self.to_snake_case() + } +} + +impl SnakeCase for str { + fn to_snake_case(&self) -> String { + ::transform(self, ::lowercase, |s| s.push('_')) + } +} + +#[cfg(test)] +mod tests { + use super::SnakeCase; + + macro_rules! t { + ($t:ident : $s1:expr => $s2:expr) => { + #[test] + fn $t() { + assert_eq!($s1.to_snake_case(), $s2) + } + } + } + + t!(test1: "CamelCase" => "camel_case"); + t!(test2: "This is Human case." => "this_is_human_case"); + t!(test3: "MixedUP CamelCase, with some Spaces" => "mixed_up_camel_case_with_some_spaces"); + t!(test4: "mixed_up_ snake_case with some _spaces" => "mixed_up_snake_case_with_some_spaces"); + t!(test5: "kebab-case" => "kebab_case"); + t!(test6: "SHOUTY_SNAKE_CASE" => "shouty_snake_case"); + t!(test7: "snake_case" => "snake_case"); + t!(test8: "this-contains_ ALLKinds OfWord_Boundaries" => "this_contains_all_kinds_of_word_boundaries"); + t!(test9: "XΣXΣ baffle" => "xσxς_baffle"); + t!(test10: "XMLHttpRequest" => "xml_http_request"); + t!(test11: "FIELD_NAME11" => "field_name11"); + t!(test12: "99BOTTLES" => "99bottles"); + t!(test13: "FieldNamE11" => "field_nam_e11"); + + t!(test14: "abc123def456" => "abc123def456"); + t!(test16: "abc123DEF456" => "abc123_def456"); + t!(test17: "abc123Def456" => "abc123_def456"); + t!(test18: "abc123DEf456" => "abc123_d_ef456"); + t!(test19: "ABC123def456" => "abc123def456"); + t!(test20: "ABC123DEF456" => "abc123def456"); + t!(test21: "ABC123Def456" => "abc123_def456"); + t!(test22: "ABC123DEf456" => "abc123d_ef456"); + t!(test23: "ABC123dEEf456FOO" => "abc123d_e_ef456_foo"); + t!(test24: "abcDEF" => "abc_def"); + t!(test25: "ABcDE" => "a_bc_de"); +} diff --git a/heck/src/title.rs b/heck/src/title.rs new file mode 100644 index 0000000..cb48302 --- /dev/null +++ b/heck/src/title.rs @@ -0,0 +1,52 @@ +/// This trait defines a title case conversion. +/// +/// In Title Case, word boundaries are indicated by spaces, and every word is +/// capitalized. +/// +/// ## Example: +/// +/// ```rust +/// extern crate heck; +/// fn main() { +/// +/// use heck::TitleCase; +/// +/// let sentence = "We have always lived in slums and holes in the wall."; +/// assert_eq!(sentence.to_title_case(), "We Have Always Lived In Slums And Holes In The Wall"); +/// } +/// ``` +pub trait TitleCase: ToOwned { + /// Convert this type to title case. + fn to_title_case(&self) -> Self::Owned; +} + +impl TitleCase for str { + fn to_title_case(&self) -> String { + ::transform(self, ::capitalize, |s| s.push(' ')) + } +} + +#[cfg(test)] +mod tests { + use super::TitleCase; + + macro_rules! t { + ($t:ident : $s1:expr => $s2:expr) => { + #[test] + fn $t() { + assert_eq!($s1.to_title_case(), $s2) + } + } + } + + t!(test1: "CamelCase" => "Camel Case"); + t!(test2: "This is Human case." => "This Is Human Case"); + t!(test3: "MixedUP CamelCase, with some Spaces" => "Mixed Up Camel Case With Some Spaces"); + t!(test4: "mixed_up_ snake_case, with some _spaces" => "Mixed Up Snake Case With Some Spaces"); + t!(test5: "kebab-case" => "Kebab Case"); + t!(test6: "SHOUTY_SNAKE_CASE" => "Shouty Snake Case"); + t!(test7: "snake_case" => "Snake Case"); + t!(test8: "this-contains_ ALLKinds OfWord_Boundaries" => "This Contains All Kinds Of Word Boundaries"); + t!(test9: "XΣXΣ baffle" => "Xσxς Baffle"); + t!(test10: "XMLHttpRequest" => "Xml Http Request"); +} -- cgit v1.2.1