Update coverage

Author: owjs3901

bindings/devup-ui-wasm/src/lib.rs

@@ -32,6 +32,7 @@ where
     f(&mut guard)
 }
 
+#[cfg(not(tarpaulin_include))]
 fn js_error(message: impl Display) -> JsValue {
     js_sys::Error::new(&message.to_string()).into()
 }

libs/css/src/lib.rs

@@ -358,20 +358,13 @@ pub fn sheet_to_classname(
                 num_to_nm_base(len)
             }
         });
-        if filename.is_some() {
-            if let Some(file_num) = file_num {
-                let mut result = String::with_capacity(prefix.len() + 8 + clas_num.len());
-                result.push_str(&prefix);
-                result.push_str(&num_to_nm_base(file_num));
-                result.push('-');
-                result.push_str(&clas_num);
-                result
-            } else {
-                let mut result = String::with_capacity(prefix.len() + clas_num.len());
-                result.push_str(&prefix);
-                result.push_str(&clas_num);
-                result
-            }
+        if let Some(file_num) = file_num {
+            let mut result = String::with_capacity(prefix.len() + 8 + clas_num.len());
+            result.push_str(&prefix);
+            result.push_str(&num_to_nm_base(file_num));
+            result.push('-');
+            result.push_str(&clas_num);
+            result
         } else {
             let mut result = String::with_capacity(prefix.len() + clas_num.len());
             result.push_str(&prefix);

libs/css/src/optimize_value.rs

@@ -322,6 +322,12 @@ mod tests {
     #[case("translate(0px) scale(0deg)", "translate(0) scale(0)")]
     #[case("translate(-0px) scale(-0deg)", "translate(0) scale(0)")]
     #[case("translate(-10px) scale(-10deg)", "translate(-10px) scale(-10deg)")]
+    // rgba/rgb fallback paths when channel parsing fails
+    // i32 overflow for r/g/b (> i32::MAX = 2_147_483_647) → falls back to original
+    #[case("rgba(2147483648,0,0,0.5)", "rgba(2147483648,0,0,.5)")]
+    #[case("rgb(2147483648,0,0)", "rgb(2147483648,0,0)")]
+    // f32 parse failure for alpha (".") → falls back to original
+    #[case("rgba(255,0,0,.)", "rgba(255,0,0,.)")]
     fn test_optimize_value(#[case] input: &str, #[case] expected: &str) {
         assert_eq!(optimize_value(input), expected);
     }

libs/extractor/src/css_utils.rs

@@ -1436,4 +1436,18 @@ mod tests {
             assert_eq!(result, expected_sorted);
         }
     }
+
+    #[rstest]
+    #[case("  hello", "hello")]
+    #[case("\t\nhello", "hello")]
+    #[case("  hello  ", "hello")]
+    #[case("hello  ", "hello")]
+    #[case("hello", "hello")]
+    #[case("", "")]
+    #[case("   ", "")]
+    fn test_trim_string_in_place(#[case] input: &str, #[case] expected: &str) {
+        let mut value = input.to_string();
+        trim_string_in_place(&mut value);
+        assert_eq!(value, expected);
+    }
 }

libs/extractor/src/gen_class_name.rs

@@ -177,43 +177,44 @@ pub fn merge_expression_for_class_name<'a>(
             unknown_expr.push(expr);
         }
     }
-    if unknown_expr.is_empty() && class_name.is_empty() {
-        return None;
+    if unknown_expr.is_empty() {
+        if class_name.is_empty() {
+            return None;
+        }
+        return Some(ast_builder.expression_string_literal(
+            SPAN,
+            ast_builder.str(&class_name),
+            None,
+        ));
     }
-    if !unknown_expr.is_empty() {
-        if class_name.is_empty() && unknown_expr.len() == 1 {
-            Some(unknown_expr.remove(0))
-        } else {
-            let mut qu = oxc_allocator::Vec::new_in(ast_builder.allocator);
-            for idx in 0..=unknown_expr.len() {
-                let tail = idx == unknown_expr.len();
-                let t = TemplateElementValue {
-                    raw: ast_builder.str(if idx == 0 {
-                        if class_name.is_empty() {
-                            ""
-                        } else {
-                            class_name.push(' ');
-                            class_name.as_str()
-                        }
-                    } else if tail {
+    if class_name.is_empty() && unknown_expr.len() == 1 {
+        Some(unknown_expr.remove(0))
+    } else {
+        let mut qu = oxc_allocator::Vec::new_in(ast_builder.allocator);
+        for idx in 0..=unknown_expr.len() {
+            let tail = idx == unknown_expr.len();
+            let t = TemplateElementValue {
+                raw: ast_builder.str(if idx == 0 {
+                    if class_name.is_empty() {
                         ""
                     } else {
-                        " "
-                    }),
-                    cooked: None,
-                };
-                qu.push(ast_builder.template_element(SPAN, t, tail, false));
-            }
-
-            Some(ast_builder.expression_template_literal(
-                SPAN,
-                qu,
-                oxc_allocator::Vec::from_iter_in(unknown_expr, ast_builder.allocator),
-            ))
+                        class_name.push(' ');
+                        class_name.as_str()
+                    }
+                } else if tail {
+                    ""
+                } else {
+                    " "
+                }),
+                cooked: None,
+            };
+            qu.push(ast_builder.template_element(SPAN, t, tail, false));
         }
-    } else if class_name.is_empty() {
-        None
-    } else {
-        Some(ast_builder.expression_string_literal(SPAN, ast_builder.str(&class_name), None))
+
+        Some(ast_builder.expression_template_literal(
+            SPAN,
+            qu,
+            oxc_allocator::Vec::from_iter_in(unknown_expr, ast_builder.allocator),
+        ))
     }
 }

libs/extractor/src/lib.rs

@@ -6204,6 +6204,27 @@ import {Button} from '@devup/ui'
             )
             .unwrap()
         ));
+
+        // Computed selector key whose `key.name()` is None must be skipped.
+        // Mixed with a valid selector to ensure extraction still proceeds.
+        reset_class_map();
+        reset_file_map();
+        assert_debug_snapshot!(ToBTreeSet::from(
+            extract(
+                "test.jsx",
+                r#"import {Box} from '@devup-ui/core'
+<Box selectors={{ [dynamic]: { color: 'red' }, "&:focus": { color: 'blue' } }} />
+            "#,
+                ExtractOption {
+                    package: "@devup-ui/core".to_string(),
+                    css_dir: "@devup-ui/core".to_string(),
+                    single_css: true,
+                    import_main_css: false,
+                    import_aliases: HashMap::new()
+                }
+            )
+            .unwrap()
+        ));
     }
 
     #[test]

libs/extractor/src/snapshots/extractor__tests__custom_selector-4.snap

@@ -0,0 +1,23 @@
+---
+source: libs/extractor/src/lib.rs
+expression: "ToBTreeSet::from(extract(\"test.jsx\",\nr#\"import {Box} from '@devup-ui/core'\n<Box selectors={{ [dynamic]: { color: 'red' }, \"&:focus\": { color: 'blue' } }} />\n            \"#,\nExtractOption\n{\n    package: \"@devup-ui/core\".to_string(), css_dir:\n    \"@devup-ui/core\".to_string(), single_css: true, import_main_css: false,\n    import_aliases: HashMap::new()\n}).unwrap())"
+---
+ToBTreeSet {
+    styles: {
+        Static(
+            ExtractStaticStyle {
+                property: "color",
+                value: "blue",
+                level: 0,
+                selector: Some(
+                    Selector(
+                        "&:focus",
+                    ),
+                ),
+                style_order: None,
+                layer: None,
+            },
+        ),
+    },
+    code: "import \"@devup-ui/core/devup-ui.css\";\n<div className=\"a\" />;\n",
+}

libs/extractor/src/stylex.rs

@@ -249,16 +249,14 @@ fn compose_selectors(parts: &[SelectorPart]) -> Option<StyleSelector> {
         Some(format!("&{}", pseudos.join("")))
     };
 
-    if at_rules.is_empty() {
-        pseudo_str.map(StyleSelector::Selector)
-    } else if let Some((kind, query)) = at_rules.last() {
+    if let Some((kind, query)) = at_rules.last() {
         Some(StyleSelector::At {
             kind: *kind,
             query: query.to_string(),
             selector: pseudo_str,
         })
     } else {
-        None
+        pseudo_str.map(StyleSelector::Selector)
     }
 }
 

libs/extractor/src/tailwind.rs

@@ -1187,10 +1187,8 @@ fn is_valid_tailwind_value(value: &str) -> bool {
     }
 
     // Numeric values (including decimals like 0.5, 1.5)
-    let Some(first_char) = value.chars().next() else {
-        return false;
-    };
-    if first_char.is_ascii_digit() {
+    // Safe: `value.is_empty()` returns early above, so `value` has at least one char.
+    if value.starts_with(|c: char| c.is_ascii_digit()) {
         return true;
     }
 

libs/sheet/src/lib.rs

@@ -21,18 +21,11 @@ use std::sync::LazyLock;
 
 macro_rules! push_fmt {
     ($target:expr, $($arg:tt)*) => {{
-        std::fmt::Write::write_fmt($target, format_args!($($arg)*))
-            .unwrap_or_else(|err| panic!("failed to write CSS into string: {err}"));
+        // `std::fmt::Write::write_fmt` on `&mut String` is infallible; discard result.
+        let _ = std::fmt::Write::write_fmt($target, format_args!($($arg)*));
     }};
 }
 
-trait ExtractStyle {
-    fn extract(&self) -> String;
-    fn write_extract(&self, css: &mut String) {
-        css.push_str(&self.extract());
-    }
-}
-
 #[derive(Debug, Hash, Eq, PartialEq, Deserialize, Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct StyleSheetProperty {
@@ -81,15 +74,7 @@ impl Ord for StyleSheetProperty {
     }
 }
 
-impl ExtractStyle for StyleSheetProperty {
-    fn extract(&self) -> String {
-        let mut css = String::with_capacity(
-            self.class_name.len() + self.property.len() + self.value.len() + 4,
-        );
-        self.write_extract(&mut css);
-        css
-    }
-
+impl StyleSheetProperty {
     fn write_extract(&self, css: &mut String) {
         css.push_str(&merge_selector(&self.class_name, self.selector.as_ref()));
         css.push('{');
@@ -150,16 +135,6 @@ pub struct StyleSheetCss {
     pub css: String,
 }
 
-impl ExtractStyle for StyleSheetCss {
-    fn extract(&self) -> String {
-        self.css.clone()
-    }
-
-    fn write_extract(&self, css: &mut String) {
-        css.push_str(&self.css);
-    }
-}
-
 type PropertyMap = BTreeMap<u8, BTreeMap<u8, FxHashSet<StyleSheetProperty>>>;
 type KeyframesMap = BTreeMap<String, BTreeMap<String, BTreeMap<String, Vec<(String, String)>>>>;
 
@@ -2064,6 +2039,37 @@ mod tests {
             "ShadowsInterface",
             "ThemeInterface"
         ));
+
+        // Multiple typography keys + multiple color themes exercise the
+        // `plain_keys` semicolon separator (joins 2+ entries).
+        let mut sheet = StyleSheet::default();
+        let mut theme = Theme::default();
+        let mut light_theme = ColorTheme::default();
+        light_theme.add_color("primary", "#000");
+        let mut dark_theme = ColorTheme::default();
+        dark_theme.add_color("primary", "#fff");
+        theme.add_color_theme("default", light_theme);
+        theme.add_color_theme("dark", dark_theme);
+        let make_typography = || {
+            Typography::new(
+                Some("Arial".to_string()),
+                Some("16px".to_string()),
+                Some("400".to_string()),
+                Some("1.5".to_string()),
+                Some("0.5".to_string()),
+            )
+        };
+        theme.add_typography("heading", vec![Some(make_typography())]);
+        theme.add_typography("body", vec![Some(make_typography())]);
+        sheet.set_theme(theme);
+        assert_debug_snapshot!(sheet.create_interface(
+            "package",
+            "ColorInterface",
+            "TypographyInterface",
+            "LengthInterface",
+            "ShadowsInterface",
+            "ThemeInterface"
+        ));
     }
 
     #[test]
@@ -2299,14 +2305,30 @@ mod tests {
     }
 
     #[test]
-    fn test_stylesheet_css_extract() {
+    fn test_stylesheet_css_struct() {
         let css_entry = StyleSheetCss {
             css: "div{display:flex}".to_string(),
         };
-        assert_eq!(css_entry.extract(), "div{display:flex}");
+        assert_eq!(css_entry.css, "div{display:flex}");
 
         let empty = StyleSheetCss { css: String::new() };
-        assert_eq!(empty.extract(), "");
+        assert_eq!(empty.css, "");
+    }
+
+    #[test]
+    fn test_stylesheet_property_ord_no_selectors() {
+        // Both sides without selectors: branches on property then value.
+        let make = |property: &str, value: &str| StyleSheetProperty {
+            class_name: "a".to_string(),
+            property: property.to_string(),
+            value: value.to_string(),
+            selector: None,
+            layer: None,
+        };
+        assert_eq!(make("color", "red").cmp(&make("color", "red")), Equal);
+        assert!(make("color", "red") < make("color", "white"));
+        assert!(make("color", "red") < make("display", "block"));
+        assert!(make("display", "block") > make("color", "white"));
     }
 
     #[test]