Merge pull request #32 from avencera/sort-responsive-classes

Sort responsive classes

Cargo.toml

@@ -7,14 +7,21 @@ version = "0.10.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+# cli
 clap = "2.33"
-ignore = "0.4"
 indoc = "1.0"
+
+# files
+ignore = "0.4"
+
+# utils
 itertools = "0.10"
 lazy_static = "1.4.0"
-rayon = "1.5"
 regex = "1"
 
+# parrelel
+rayon = "1.5"
+
 [dev-dependencies]
 pretty_assertions = "0.7"
 

src/consts.rs

@@ -0,0 +1,6 @@
+use lazy_static::lazy_static;
+
+lazy_static! {
+    pub static ref RESPONSIVE_SIZES: Vec<&'static str> =
+        vec!["sm", "md", "lg", "xl", "2xl", "3xl", "4xl", "5xl", "6xl"];
+}

src/lib.rs

@@ -1,11 +1,13 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, collections::HashMap};
 
 use itertools::Itertools;
 use regex::Captures;
 
+pub mod consts;
 pub mod defaults;
 pub mod options;
 
+use consts::RESPONSIVE_SIZES;
 use defaults::{RE, SORTER};
 use options::Options;
 
@@ -45,22 +47,108 @@ fn sort_classes_vec<'a>(classes: impl Iterator<Item = &'a str>) -> Vec<&'a str>
 
     let mut tailwind_classes: Vec<(&str, &usize)> = vec![];
     let mut custom_classes: Vec<&str> = vec![];
+    let mut responsive: HashMap<&str, Vec<&str>> = HashMap::new();
 
     for (class, maybe_size) in enumerated_classes {
         match maybe_size {
             Some(size) => tailwind_classes.push((class, size)),
-            None => custom_classes.push(class),
+            None => match class.as_bytes() {
+                [b's', b'm', b':', ..] => {
+                    responsive.entry("sm").or_insert_with(|| vec![]).push(class)
+                }
+
+                [b'm', b'd', b':', ..] => {
+                    responsive.entry("md").or_insert_with(|| vec![]).push(class)
+                }
+
+                [b'l', b'g', b':', ..] => {
+                    responsive.entry("lg").or_insert_with(|| vec![]).push(class)
+                }
+
+                [b'x', b'l', b':', ..] => {
+                    responsive.entry("xl").or_insert_with(|| vec![]).push(class)
+                }
+
+                [b'2', b'x', b'l', b':', ..] => responsive
+                    .entry("2xl")
+                    .or_insert_with(|| vec![])
+                    .push(class),
+
+                [b'3', b'x', b'l', b':', ..] => responsive
+                    .entry("3xl")
+                    .or_insert_with(|| vec![])
+                    .push(class),
+
+                [b'4', b'x', b'l', b':', ..] => responsive
+                    .entry("4xl")
+                    .or_insert_with(|| vec![])
+                    .push(class),
+
+                [b'5', b'x', b'l', b':', ..] => responsive
+                    .entry("5xl")
+                    .or_insert_with(|| vec![])
+                    .push(class),
+
+                [b'6', b'x', b'l', b':', ..] => responsive
+                    .entry("6xl")
+                    .or_insert_with(|| vec![])
+                    .push(class),
+
+                _ => custom_classes.push(class),
+            },
         }
     }
 
     tailwind_classes.sort_by_key(|&(_class, class_placement)| class_placement);
 
     let sorted_tailwind_classes: Vec<&str> = tailwind_classes
-        .into_iter()
-        .map(|(class, _index)| class)
+        .iter()
+        .map(|(class, _index)| *class)
+        .collect();
+
+    let mut sorted_responsive_classes = vec![];
+
+    for key in RESPONSIVE_SIZES.iter() {
+        let (mut sorted_classes, new_custom_classes) = sort_responsive_classes(
+            responsive.remove(key).unwrap_or_else(|| vec![]),
+            custom_classes,
+            key.len() + 1,
+        );
+
+        sorted_responsive_classes.append(&mut sorted_classes);
+        custom_classes = new_custom_classes
+    }
+
+    [
+        &sorted_tailwind_classes[..],
+        &sorted_responsive_classes[..],
+        &custom_classes[..],
+    ]
+    .concat()
+}
+
+fn sort_responsive_classes<'a>(
+    classes: Vec<&'a str>,
+    mut custom_classes: Vec<&'a str>,
+    class_after: usize,
+) -> (Vec<&'a str>, Vec<&'a str>) {
+    let mut tailwind_classes = Vec::with_capacity(classes.len());
+
+    for class in classes {
+        match SORTER.get(&class[class_after..]) {
+            Some(class_placement) => tailwind_classes.push((class, class_placement)),
+            None => custom_classes.push(class),
+        }
+    }
+
+    tailwind_classes.sort_by_key(|&(_class, class_placement)| class_placement);
+
+    let sorted_classes = tailwind_classes
+        .iter()
+        .map(|(class, _index)| *class)
         .collect();
 
-    [&sorted_tailwind_classes[..], &custom_classes[..]].concat()
+    (sorted_classes, custom_classes)
 }
 
 #[cfg(test)]

tests/rustywind_test.rs

@@ -222,3 +222,28 @@ fn test_sort_file_contents_with_spaces_newlines_and_custom_classes() {
         expected_outcome
     )
 }
+
+#[test]
+fn test_sort_file_contents_with_responsive_classes() {
+    let file_contents = r#"
+<div>
+    <div class='4xl:inline-block absolute xl:relative relative flex inline-block xl:absolute sm:relative sm:flex inline random-class justify-items another-random-class
+    sm:absolute 4xl:flex xl:random-class sm:inline-block'>
+        <ul class='flex items-center md:pr-4 lg:pr-6 xl:flex'>
+    </div>
+</div>
+"#;
+
+    let expected_outcome = r#"
+<div>
+    <div class='inline-block inline flex absolute relative sm:inline-block sm:flex sm:absolute sm:relative xl:absolute xl:relative 4xl:inline-block 4xl:flex random-class justify-items another-random-class xl:random-class'>
+        <ul class='flex items-center md:pr-4 lg:pr-6 xl:flex'>
+    </div>
+</div>
+"#.to_string();
+
+    assert_eq!(
+        rustywind::sort_file_contents(file_contents, &default_options_for_test()),
+        expected_outcome
+    )
+}