(
+ /// Returns a `GrimoireCssError` if there is an issue during processing.
+ fn collect_classes(
content: &str,
regex: &Regex,
- mut predicate: Option,
- mut splitter: Option,
- class_names: &mut Vec,
+ split_by_whitespace: bool,
+ class_names: &mut Vec<(String, (usize, usize))>,
seen_class_names: &mut HashSet,
collection_type: CollectionType,
- ) -> Result<(), GrimoireCssError>
- where
- P: FnMut(&str) -> bool,
- S: FnMut(&str) -> Vec,
- {
+ ) -> Result<(), GrimoireCssError> {
for cap in regex.captures_iter(content) {
- let class_value = match collection_type {
- CollectionType::TemplatedSpell => cap.get(1).map(|m| m.as_str()).unwrap_or(""),
- CollectionType::CurlyClass => cap.get(1).map(|m| m.as_str()).unwrap_or(""),
- CollectionType::RegularClass => cap
- .get(2)
- .or_else(|| cap.get(3))
- .or_else(|| cap.get(4))
- .map(|m| m.as_str())
- .unwrap_or(""),
+ let match_obj = match collection_type {
+ CollectionType::TemplatedSpell => cap.get(1),
+ CollectionType::CurlyClass => cap.get(1),
+ CollectionType::RegularClass => {
+ cap.get(2).or_else(|| cap.get(3)).or_else(|| cap.get(4))
+ }
};
- let classes = if let Some(splitter_fn) = &mut splitter {
- let splitted = splitter_fn(class_value);
+ if let Some(m) = match_obj {
+ let full_value = m.as_str();
+ let base_offset = m.start();
- if matches!(collection_type, CollectionType::CurlyClass) {
- splitted
- .into_iter()
- .map(|s| Self::clean_unpaired_brackets(&s))
- .collect()
- } else {
- splitted
- }
- } else {
- vec![class_value.to_string()]
- };
+ if split_by_whitespace {
+ for part in full_value.split_whitespace() {
+ // Calculate the offset of the part within the full content
+ let part_start = part.as_ptr() as usize - full_value.as_ptr() as usize;
+ let start = base_offset + part_start;
+ let length = part.len();
+
+ let mut class_string = part.to_string();
+
+ if matches!(collection_type, CollectionType::CurlyClass) {
+ class_string = Self::clean_unpaired_brackets(&class_string);
+ }
- for class in classes {
- let should_include = predicate.as_mut().is_none_or(|p| p(&class));
+ if !class_string.is_empty() && !seen_class_names.contains(&class_string) {
+ seen_class_names.insert(class_string.clone());
+ class_names.push((class_string, (start, length)));
+ }
+ }
+ } else {
+ let start = base_offset;
+ let length = full_value.len();
+ let class_string = full_value.to_string();
+
+ if class_string.contains(' ') {
+ // IMPORTANT:
+ // - In HTML attributes, spaces are class separators, not part of a single class token.
+ // - If a user tries to encode a value that contains spaces (e.g. calc(100vh - 50px)),
+ // the correct Grimoire convention is to use underscores instead: calc(100vh_-_50px).
+ //
+ // We return a Diagnostic-style error so the CLI can render it like rustc.
+ return Err(GrimoireCssError::CompileError {
+ message: "Spaces are not allowed inside a single spell token."
+ .to_string(),
+ span: (start, length),
+ label: "Error in this spell".to_string(),
+ help: Some(format!(
+ "You likely wrote a value with spaces inside a class attribute (HTML treats spaces as class separators).\n\
+Fix: replace spaces with '_' inside the value, e.g.:\n\
+ h=calc(100vh - 50px) -> h=calc(100vh_-_50px)\n\n\
+Offending spell: '{class_string}'"
+ )),
+ source_file: None,
+ });
+ }
- if should_include && !seen_class_names.contains(&class) {
- seen_class_names.insert(class.clone());
- class_names.push(class);
+ if !class_string.is_empty() && !seen_class_names.contains(&class_string) {
+ seen_class_names.insert(class_string.clone());
+ class_names.push((class_string, (start, length)));
+ }
}
}
}
@@ -171,7 +195,7 @@ impl Parser {
/// # Arguments
///
/// * `content` - The content to parse
- /// * `class_names` - A mutable reference to a vector that stores the collected class names
+ /// * `class_names` - A mutable reference to a vector that stores the collected class names and their spans
/// * `seen_class_names` - A mutable reference to a HashSet for tracking seen class names
///
/// # Returns
@@ -180,66 +204,54 @@ impl Parser {
pub fn collect_candidates(
&self,
content: &str,
- class_names: &mut Vec,
+ class_names: &mut Vec<(String, (usize, usize))>,
seen_class_names: &mut HashSet,
) -> Result<(), GrimoireCssError> {
- let whitespace_splitter = |input: &str| {
- input
- .split_whitespace()
- .map(String::from)
- .collect::>()
- };
-
// Collect all 'className' matches
- Self::collect_classes:: bool, fn(&str) -> Vec>(
+ Self::collect_classes(
content,
&self.class_name_regex,
- None,
- Some(whitespace_splitter),
+ true,
class_names,
seen_class_names,
CollectionType::RegularClass,
)?;
// Collect all 'class' matches
- Self::collect_classes:: bool, fn(&str) -> Vec>(
+ Self::collect_classes(
content,
&self.class_regex,
- None,
- Some(whitespace_splitter),
+ true,
class_names,
seen_class_names,
CollectionType::RegularClass,
)?;
// Collect all 'templated class' (starts with 'g!', ends with ';') matches
- Self::collect_classes:: bool, fn(&str) -> Vec>(
+ Self::collect_classes(
content,
&self.tepmplated_spell_regex,
- None,
- None,
+ false,
class_names,
seen_class_names,
CollectionType::TemplatedSpell,
)?;
// Collect all curly 'className' matches
- Self::collect_classes:: bool, fn(&str) -> Vec>(
+ Self::collect_classes(
content,
&self.curly_class_name_regex,
- None,
- Some(whitespace_splitter),
+ true,
class_names,
seen_class_names,
CollectionType::CurlyClass,
)?;
// Collect all curly 'class' matches
- Self::collect_classes:: bool, fn(&str) -> Vec>(
+ Self::collect_classes(
content,
&self.curly_class_regex,
- None,
- Some(whitespace_splitter),
+ true,
class_names,
seen_class_names,
CollectionType::CurlyClass,
@@ -271,11 +283,13 @@ mod tests {
.unwrap();
assert_eq!(class_names.len(), 5);
- assert!(class_names.contains(&"test1".to_string()));
- assert!(class_names.contains(&"test2".to_string()));
- assert!(class_names.contains(&"test3".to_string()));
- assert!(class_names.contains(&"test4".to_string()));
- assert!(class_names.contains(&"g!display=block;".to_string()));
+
+ let names: Vec = class_names.iter().map(|(n, _)| n.clone()).collect();
+ assert!(names.contains(&"test1".to_string()));
+ assert!(names.contains(&"test2".to_string()));
+ assert!(names.contains(&"test3".to_string()));
+ assert!(names.contains(&"test4".to_string()));
+ assert!(names.contains(&"g!display=block;".to_string()));
}
#[test]
@@ -295,8 +309,9 @@ mod tests {
.unwrap();
assert_eq!(class_names.len(), 2);
- assert!(class_names.contains(&"g!display=flex;".to_string()));
- assert!(class_names.contains(&"g!color=red;".to_string()));
+ let names: Vec = class_names.iter().map(|(n, _)| n.clone()).collect();
+ assert!(names.contains(&"g!display=flex;".to_string()));
+ assert!(names.contains(&"g!color=red;".to_string()));
}
#[test]
@@ -319,8 +334,9 @@ mod tests {
.unwrap();
assert_eq!(class_names.len(), 6);
+ let names: Vec = class_names.iter().map(|(n, _)| n.clone()).collect();
for i in 1..=6 {
- assert!(class_names.contains(&format!("test{i}")));
+ assert!(names.contains(&format!("test{i}")));
}
}
@@ -341,15 +357,16 @@ mod tests {
assert_eq!(class_names.len(), 9);
- assert!(class_names.contains(&"isError".to_string()));
- assert!(class_names.contains(&"?".to_string()));
- assert!(class_names.contains(&"color=red".to_string()));
- assert!(class_names.contains(&"regular-class-error".to_string()));
- assert!(class_names.contains(&":".to_string()));
- assert!(class_names.contains(&"color=green".to_string()));
- assert!(class_names.contains(&"regular-class-success".to_string()));
- assert!(class_names.contains(&"display=grid".to_string()));
- assert!(class_names.contains(&"state-${state}".to_string()));
+ let names: Vec = class_names.iter().map(|(n, _)| n.clone()).collect();
+ assert!(names.contains(&"isError".to_string()));
+ assert!(names.contains(&"?".to_string()));
+ assert!(names.contains(&"color=red".to_string()));
+ assert!(names.contains(&"regular-class-error".to_string()));
+ assert!(names.contains(&":".to_string()));
+ assert!(names.contains(&"color=green".to_string()));
+ assert!(names.contains(&"regular-class-success".to_string()));
+ assert!(names.contains(&"display=grid".to_string()));
+ assert!(names.contains(&"state-${state}".to_string()));
}
#[test]
@@ -368,13 +385,38 @@ mod tests {
.unwrap();
// Should clean unpaired brackets and quotes
- assert!(class_names.contains(&"class-with-{unpaired}".to_string()));
- assert!(class_names.contains(&"brackets".to_string()));
- assert!(class_names.contains(&"and".to_string()));
- assert!(class_names.contains(&"quotes".to_string()));
- assert!(class_names.contains(&"normal-class".to_string()));
- assert!(class_names.contains(&"{paired}".to_string()));
- assert!(class_names.contains(&"[brackets]".to_string()));
- assert!(class_names.contains(&"(work)".to_string()));
+ let names: Vec = class_names.iter().map(|(n, _)| n.clone()).collect();
+ assert!(names.contains(&"class-with-{unpaired}".to_string()));
+ assert!(names.contains(&"brackets".to_string()));
+ assert!(names.contains(&"and".to_string()));
+ assert!(names.contains(&"quotes".to_string()));
+ assert!(names.contains(&"normal-class".to_string()));
+ assert!(names.contains(&"{paired}".to_string()));
+ assert!(names.contains(&"[brackets]".to_string()));
+ assert!(names.contains(&"(work)".to_string()));
+ }
+
+ #[test]
+ fn test_spans() {
+ let parser = Parser::new();
+ let mut class_names = Vec::new();
+ let mut seen_class_names = HashSet::new();
+
+ let content = r#""#;
+ // 012345678901234567890123456
+ // foo is at 12..15
+ // bar is at 16..19
+
+ parser
+ .collect_candidates(content, &mut class_names, &mut seen_class_names)
+ .unwrap();
+
+ assert_eq!(class_names.len(), 2);
+
+ let foo = class_names.iter().find(|(n, _)| n == "foo").unwrap();
+ assert_eq!(foo.1, (12, 3));
+
+ let bar = class_names.iter().find(|(n, _)| n == "bar").unwrap();
+ assert_eq!(bar.1, (16, 3));
}
}
diff --git a/src/core/parser/parser_fs.rs b/src/core/parser/parser_fs.rs
index c7a294f..639f736 100644
--- a/src/core/parser/parser_fs.rs
+++ b/src/core/parser/parser_fs.rs
@@ -2,13 +2,21 @@
//! with filesystem-specific functionality for collecting CSS classes from files and directories.
use super::Parser;
+use crate::core::SourceFile;
use crate::{buffer::add_message, core::GrimoireCssError};
use std::{
collections::HashSet,
fs,
path::{Path, PathBuf},
+ sync::Arc,
};
+type Span = (usize, usize);
+type ClassWithSpan = (String, Span);
+
+type SingleOutputFileResult = (PathBuf, String, Vec);
+type MultiOutputFileResult = (PathBuf, PathBuf, String, Vec);
+
/// `ParserFs` extends the base `Parser` with filesystem-specific functionality.
/// It handles file reading, directory traversal, and path resolution.
pub struct ParserFs {
@@ -37,7 +45,7 @@ impl ParserFs {
///
/// # Returns
///
- /// A vector of unique class names found in the input files.
+ /// A vector of tuples containing file path, file content, and found classes with spans.
///
/// # Errors
///
@@ -45,16 +53,16 @@ impl ParserFs {
pub fn collect_classes_single_output(
&self,
input_paths: &Vec,
- ) -> Result, GrimoireCssError> {
- let mut class_names: Vec = Vec::new();
+ ) -> Result, GrimoireCssError> {
+ let mut results = Vec::new();
let mut seen_class_names: HashSet = HashSet::new();
for input_path in input_paths {
let path = self.current_dir.join(input_path);
- self.collect_spells_from_path(&path, &mut class_names, &mut seen_class_names)?;
+ self.collect_spells_from_path(&path, &mut results, &mut seen_class_names)?;
}
- Ok(class_names)
+ Ok(results)
}
/// Collects class names or templated spells from multiple input paths, producing multiple outputs.
@@ -66,7 +74,7 @@ impl ParserFs {
///
/// # Returns
///
- /// A vector of tuples, where each tuple contains the path to the output CSS file and a vector of class names.
+ /// A vector of tuples: (OutputCssPath, InputSourcePath, InputSourceContent, ClassesWithSpans).
///
/// # Errors
///
@@ -75,14 +83,14 @@ impl ParserFs {
&self,
input_paths: &Vec,
output_dir_path: &Path,
- ) -> Result)>, GrimoireCssError> {
- let mut res: Vec<(PathBuf, Vec)> = Vec::new();
+ ) -> Result, GrimoireCssError> {
+ let mut res = Vec::new();
for input_path_string in input_paths {
let path = self.current_dir.join(input_path_string);
if path.is_file() {
- let mut class_names: Vec = Vec::new();
+ let mut class_names = Vec::new();
let mut seen_class_names: HashSet = HashSet::new();
let output_file_path = path.with_extension("css");
@@ -92,13 +100,20 @@ impl ParserFs {
})?);
let file_content = fs::read_to_string(&path)?;
- self.base_parser.collect_candidates(
+ if let Err(e) = self.base_parser.collect_candidates(
&file_content,
&mut class_names,
&mut seen_class_names,
- )?;
-
- res.push((bundle_output_full_path, class_names));
+ ) {
+ let src = Arc::new(SourceFile::new(
+ Some(path.clone()),
+ path.to_string_lossy().to_string(),
+ file_content.clone(),
+ ));
+ return Err(e.with_source(src));
+ }
+
+ res.push((bundle_output_full_path, path, file_content, class_names));
} else if path.is_dir() {
let entries = &self.get_sorted_directory_entries(&path)?;
@@ -128,7 +143,7 @@ impl ParserFs {
/// # Arguments
///
/// * `path` - The path of the file or directory to process.
- /// * `class_names` - A mutable reference to a vector that stores the collected class names.
+ /// * `results` - A mutable reference to a vector that stores the collected results.
/// * `seen_class_names` - A mutable reference to a HashSet for tracking seen class names.
///
/// # Errors
@@ -137,18 +152,34 @@ impl ParserFs {
fn collect_spells_from_path(
&self,
path: &Path,
- class_names: &mut Vec,
+ results: &mut Vec,
seen_class_names: &mut HashSet,
) -> Result<(), GrimoireCssError> {
if path.is_file() {
let file_content = fs::read_to_string(path)?;
- self.base_parser
- .collect_candidates(&file_content, class_names, seen_class_names)?;
+ let mut class_names = Vec::new();
+
+ if let Err(e) = self.base_parser.collect_candidates(
+ &file_content,
+ &mut class_names,
+ seen_class_names,
+ ) {
+ let src = Arc::new(SourceFile::new(
+ Some(path.to_path_buf()),
+ path.to_string_lossy().to_string(),
+ file_content.clone(),
+ ));
+ return Err(e.with_source(src));
+ }
+
+ if !class_names.is_empty() {
+ results.push((path.to_path_buf(), file_content, class_names));
+ }
} else if path.is_dir() {
let entries = &self.get_sorted_directory_entries(path)?;
for entry in entries {
- self.collect_spells_from_path(entry, class_names, seen_class_names)?;
+ self.collect_spells_from_path(entry, results, seen_class_names)?;
}
} else {
add_message(format!("Invalid path: {}", path.display()));
@@ -188,7 +219,7 @@ impl ParserFs {
let mut seen = std::collections::HashSet::new();
self.base_parser
.collect_candidates(content, &mut raw_spells, &mut seen)?;
- Ok(raw_spells)
+ Ok(raw_spells.into_iter().map(|(s, _)| s).collect())
}
}
@@ -213,11 +244,16 @@ mod tests {
parser.collect_classes_single_output(&vec![test_file.to_str().unwrap().to_string()]);
assert!(result.is_ok());
- let classes = result.unwrap();
+ let results = result.unwrap();
+ assert_eq!(results.len(), 1);
+ let (path, _, classes) = &results[0];
+ assert_eq!(path, &test_file);
assert_eq!(classes.len(), 3);
- assert!(classes.contains(&"test1".to_string()));
- assert!(classes.contains(&"test2".to_string()));
- assert!(classes.contains(&"test3".to_string()));
+
+ let class_names: Vec = classes.iter().map(|(n, _)| n.clone()).collect();
+ assert!(class_names.contains(&"test1".to_string()));
+ assert!(class_names.contains(&"test2".to_string()));
+ assert!(class_names.contains(&"test3".to_string()));
}
#[test]
@@ -246,12 +282,14 @@ mod tests {
assert_eq!(outputs.len(), 2);
// Check first file output
- assert_eq!(outputs[0].1.len(), 1);
- assert!(outputs[0].1.contains(&"file1-class".to_string()));
+ let (_, _, _, classes1) = &outputs[0];
+ assert_eq!(classes1.len(), 1);
+ assert_eq!(classes1[0].0, "file1-class");
// Check second file output
- assert_eq!(outputs[1].1.len(), 1);
- assert!(outputs[1].1.contains(&"file2-class".to_string()));
+ let (_, _, _, classes2) = &outputs[1];
+ assert_eq!(classes2.len(), 1);
+ assert_eq!(classes2[0].0, "file2-class");
}
#[test]
@@ -271,9 +309,11 @@ mod tests {
parser.collect_classes_single_output(&vec![sub_dir.to_str().unwrap().to_string()]);
assert!(result.is_ok());
- let classes = result.unwrap();
+ let results = result.unwrap();
+ assert_eq!(results.len(), 1);
+ let (_, _, classes) = &results[0];
assert_eq!(classes.len(), 1);
- assert!(classes.contains(&"nested-class".to_string()));
+ assert_eq!(classes[0].0, "nested-class");
}
#[test]
diff --git a/src/core/source_file.rs b/src/core/source_file.rs
new file mode 100644
index 0000000..473f35b
--- /dev/null
+++ b/src/core/source_file.rs
@@ -0,0 +1,18 @@
+use std::{path::PathBuf, sync::Arc};
+
+#[derive(Debug, Clone)]
+pub struct SourceFile {
+ pub name: String,
+ pub path: Option,
+ pub content: Arc,
+}
+
+impl SourceFile {
+ pub fn new(path: Option, name: String, content: String) -> Self {
+ Self {
+ name,
+ path,
+ content: Arc::new(content),
+ }
+ }
+}
diff --git a/src/core/spell.rs b/src/core/spell.rs
index fd7e807..32180f4 100644
--- a/src/core/spell.rs
+++ b/src/core/spell.rs
@@ -26,10 +26,15 @@
//! if the string format is invalid.
use std::collections::{HashMap, HashSet};
+use std::hash::{Hash, Hasher};
+use std::path::PathBuf;
+use std::sync::Arc;
-use super::{GrimoireCssError, component::get_css_property};
+use super::{
+ GrimoireCssError, component::get_css_property, source_file::SourceFile, spell_value_validator,
+};
-#[derive(Eq, Hash, PartialEq, Debug, Clone)]
+#[derive(Debug, Clone)]
pub struct Spell {
pub raw_spell: String,
pub component: String,
@@ -39,6 +44,37 @@ pub struct Spell {
pub focus: String,
pub with_template: bool,
pub scroll_spells: Option>,
+ pub span: (usize, usize),
+ pub file_path: Option,
+ pub source: Option>,
+}
+
+impl PartialEq for Spell {
+ fn eq(&self, other: &Self) -> bool {
+ self.raw_spell == other.raw_spell
+ && self.component == other.component
+ && self.component_target == other.component_target
+ && self.effects == other.effects
+ && self.area == other.area
+ && self.focus == other.focus
+ && self.with_template == other.with_template
+ && self.scroll_spells == other.scroll_spells
+ }
+}
+
+impl Eq for Spell {}
+
+impl Hash for Spell {
+ fn hash(&self, state: &mut H) {
+ self.raw_spell.hash(state);
+ self.component.hash(state);
+ self.component_target.hash(state);
+ self.effects.hash(state);
+ self.area.hash(state);
+ self.focus.hash(state);
+ self.with_template.hash(state);
+ self.scroll_spells.hash(state);
+ }
}
impl Spell {
@@ -47,9 +83,12 @@ impl Spell {
raw_spell: &str,
shared_spells: &HashSet,
scrolls: &Option>>,
+ span: (usize, usize),
+ file_path: Option,
+ source: Option>,
) -> Result, GrimoireCssError> {
let with_template = Self::check_for_template(raw_spell);
- let raw_spell = if with_template {
+ let raw_spell_cleaned = if with_template {
raw_spell
.strip_prefix("g!")
.and_then(|s| s.strip_suffix(";"))
@@ -58,18 +97,28 @@ impl Spell {
raw_spell
};
- let raw_spell_split: Vec<&str> = raw_spell.split("--").filter(|s| !s.is_empty()).collect();
+ let raw_spell_split: Vec<&str> = raw_spell_cleaned
+ .split("--")
+ .filter(|s| !s.is_empty())
+ .collect();
if with_template && !raw_spell_split.is_empty() {
let mut scroll_spells: Vec = Vec::new();
for rs in raw_spell_split {
- if let Some(spell) = Spell::new(rs, shared_spells, scrolls)? {
+ if let Some(spell) = Spell::new(
+ rs,
+ shared_spells,
+ scrolls,
+ span,
+ file_path.clone(),
+ source.clone(),
+ )? {
scroll_spells.push(spell);
}
}
return Ok(Some(Spell {
- raw_spell: raw_spell.to_string(),
+ raw_spell: raw_spell_cleaned.to_string(),
component: String::new(),
component_target: String::new(),
effects: String::new(),
@@ -77,11 +126,16 @@ impl Spell {
focus: String::new(),
with_template,
scroll_spells: Some(scroll_spells),
+ span,
+ file_path,
+ source,
}));
}
// Split the input string by "__" to separate the area (screen size) and the rest
- let (area, rest) = raw_spell.split_once("__").unwrap_or(("", raw_spell));
+ let (area, rest) = raw_spell_cleaned
+ .split_once("__")
+ .unwrap_or(("", raw_spell_cleaned));
// Split the raw spell by "}" to get the focus and the rest
let (focus, rest) = rest
@@ -93,8 +147,43 @@ impl Spell {
// Split the rest by "=" to separate the component (property) and component_target (value)
if let Some((component, component_target)) = rest.split_once("=") {
+ if let Some(err) = spell_value_validator::validate_component_target(component_target) {
+ let message = match err {
+ spell_value_validator::SpellValueValidationError::UnexpectedClosingParen => {
+ format!(
+ "Invalid value '{component_target}': unexpected ')'.\n\n\
+If you intended a CSS function (e.g. calc(...)), ensure parentheses are balanced."
+ )
+ }
+ spell_value_validator::SpellValueValidationError::UnclosedParen => {
+ format!(
+ "Invalid value '{component_target}': unclosed '('.\n\n\
+Common cause: spaces inside a class attribute split the spell into multiple tokens.\n\
+Fix: replace spaces with '_' inside the value, e.g.:\n\
+ h=calc(100vh - 50px) -> h=calc(100vh_-_50px)"
+ )
+ }
+ };
+
+ if let Some(src) = &source {
+ return Err(GrimoireCssError::CompileError {
+ message,
+ span,
+ label: "invalid spell value".to_string(),
+ help: Some(
+ "In HTML class attributes, spaces split classes.\n\
+Use '_' inside spell values to represent spaces."
+ .to_string(),
+ ),
+ source_file: Some(src.clone()),
+ });
+ }
+
+ return Err(GrimoireCssError::InvalidInput(message));
+ }
+
let mut spell = Spell {
- raw_spell: raw_spell.to_string(),
+ raw_spell: raw_spell_cleaned.to_string(),
component: component.to_string(),
component_target: component_target.to_string(),
effects: effects.to_string(),
@@ -102,6 +191,9 @@ impl Spell {
focus: focus.to_string(),
with_template,
scroll_spells: None,
+ span,
+ file_path: file_path.clone(),
+ source: source.clone(),
};
if let Some(raw_scroll_spells) =
@@ -113,13 +205,34 @@ impl Spell {
&spell.component_target,
shared_spells,
scrolls,
+ span,
+ &file_path,
+ source.clone(),
)?;
+ } else if !spell.component.starts_with("--")
+ && get_css_property(&spell.component).is_none()
+ {
+ let message = format!("Unknown component or scroll: '{}'", spell.component);
+ if let Some(src) = &source {
+ return Err(GrimoireCssError::InvalidSpellFormat {
+ message,
+ span,
+ label: "Error in this spell".to_string(),
+ help: Some(
+ "Check that the component name exists (built-in CSS property alias) or that the scroll is defined in config.scrolls."
+ .to_string(),
+ ),
+ source_file: Some(src.clone()),
+ });
+ } else {
+ return Err(GrimoireCssError::InvalidInput(message));
+ }
}
return Ok(Some(spell));
} else if let Some(raw_scroll_spells) = Self::check_raw_scroll_spells(rest, scrolls) {
return Ok(Some(Spell {
- raw_spell: raw_spell.to_string(),
+ raw_spell: raw_spell_cleaned.to_string(),
component: rest.to_string(),
component_target: String::new(),
effects: effects.to_string(),
@@ -132,7 +245,13 @@ impl Spell {
"",
shared_spells,
scrolls,
+ span,
+ &file_path,
+ source.clone(),
)?,
+ span,
+ file_path,
+ source,
}));
}
@@ -158,12 +277,16 @@ impl Spell {
None
}
+ #[allow(clippy::too_many_arguments)]
fn parse_scroll(
scroll_name: &str,
raw_scroll_spells: &[String],
component_target: &str,
shared_spells: &HashSet,
scrolls: &Option>>,
+ span: (usize, usize),
+ file_path: &Option,
+ source: Option>,
) -> Result>, GrimoireCssError> {
if raw_scroll_spells.is_empty() {
return Ok(None);
@@ -190,20 +313,50 @@ impl Spell {
format!("={}", scroll_variables[count_of_used_variables]).as_str(),
);
- if let Ok(Some(spell)) = Spell::new(&variabled_raw_spell, shared_spells, scrolls) {
+ if let Ok(Some(spell)) = Spell::new(
+ &variabled_raw_spell,
+ shared_spells,
+ scrolls,
+ span,
+ file_path.clone(),
+ source.clone(),
+ ) {
spells.push(spell);
}
count_of_used_variables += 1;
- } else if let Ok(Some(spell)) = Spell::new(raw_spell, shared_spells, scrolls) {
+ } else if let Ok(Some(spell)) = Spell::new(
+ raw_spell,
+ shared_spells,
+ scrolls,
+ span,
+ file_path.clone(),
+ source.clone(),
+ ) {
spells.push(spell);
}
}
if count_of_used_variables != count_of_variables {
- return Err(GrimoireCssError::InvalidInput(format!(
- "Not all variables used in scroll '{scroll_name}'. Expected {count_of_variables}, but used {count_of_used_variables}",
- )));
+ let message = format!(
+ "Variable count mismatch for scroll '{scroll_name}'. Provided {count_of_variables} arguments, but scroll definition uses {count_of_used_variables}",
+ );
+
+ if let Some(src) = &source {
+ return Err(GrimoireCssError::InvalidSpellFormat {
+ message,
+ span,
+ label: "Error in this spell".to_string(),
+ help: Some(
+ "Pass exactly N arguments separated by '_' (underscores).\n\
+Example: complex-card=arg1_arg2_arg3"
+ .to_string(),
+ ),
+ source_file: Some(src.clone()),
+ });
+ } else {
+ return Err(GrimoireCssError::InvalidInput(message));
+ }
}
if spells.is_empty() {
@@ -214,15 +367,24 @@ impl Spell {
}
pub fn generate_spells_from_classes(
- css_classes: Vec,
+ css_classes: Vec<(String, (usize, usize))>,
shared_spells: &HashSet,
scrolls: &Option>>,
+ file_path: Option,
+ source: Option>,
) -> Result, GrimoireCssError> {
let mut spells = Vec::with_capacity(css_classes.len());
- for cs in css_classes {
+ for (cs, span) in css_classes {
if !shared_spells.contains(&cs)
- && let Some(spell) = Spell::new(&cs, shared_spells, scrolls)?
+ && let Some(spell) = Spell::new(
+ &cs,
+ shared_spells,
+ scrolls,
+ span,
+ file_path.clone(),
+ source.clone(),
+ )?
{
spells.push(spell);
}
@@ -234,15 +396,17 @@ impl Spell {
#[cfg(test)]
mod tests {
+ use crate::core::source_file::SourceFile;
use crate::core::spell::Spell;
use std::collections::{HashMap, HashSet};
+ use std::sync::Arc;
#[test]
fn test_multiple_raw_spells_in_template() {
let shared_spells = HashSet::new();
let scrolls: Option>> = None;
let raw = "g!color=red--display=flex;";
- let spell = Spell::new(raw, &shared_spells, &scrolls)
+ let spell = Spell::new(raw, &shared_spells, &scrolls, (0, 0), None, None)
.expect("parse ok")
.expect("not None");
assert!(spell.with_template);
@@ -254,4 +418,27 @@ mod tests {
assert_eq!(spells[1].component, "display");
assert_eq!(spells[1].component_target, "flex");
}
+
+ #[test]
+ fn test_non_grimoire_plain_class_is_ignored() {
+ let shared_spells = HashSet::new();
+ let scrolls: Option>> = None;
+
+ // Plain CSS class (no '=') must not be treated as a spell.
+ let spell = Spell::new(
+ "red",
+ &shared_spells,
+ &scrolls,
+ (12, 3),
+ None,
+ Some(Arc::new(SourceFile::new(
+ None,
+ "test".to_string(),
+ "".to_string(),
+ ))),
+ )
+ .expect("parsing must not fail");
+
+ assert!(spell.is_none());
+ }
}
diff --git a/src/core/spell_value_validator.rs b/src/core/spell_value_validator.rs
new file mode 100644
index 0000000..8ed0027
--- /dev/null
+++ b/src/core/spell_value_validator.rs
@@ -0,0 +1,51 @@
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SpellValueValidationError {
+ UnexpectedClosingParen,
+ UnclosedParen,
+}
+
+pub fn validate_component_target(component_target: &str) -> Option {
+ // Intentionally minimal and cheap validation to surface common HTML class tokenization mistakes
+ // (e.g. h=calc(100vh - 50px) becomes h=calc(100vh).
+ //
+ // We only treat parentheses as syntax when NOT inside CSS string literals.
+ // In CSS, string literals are only single/double quotes.
+
+ let mut depth: i32 = 0;
+ let mut in_single_quote = false;
+ let mut in_double_quote = false;
+ let mut escape_next = false;
+
+ for ch in component_target.chars() {
+ if escape_next {
+ escape_next = false;
+ continue;
+ }
+
+ match ch {
+ '\\' if in_single_quote || in_double_quote => {
+ escape_next = true;
+ }
+ '\'' if !in_double_quote => {
+ in_single_quote = !in_single_quote;
+ }
+ '"' if !in_single_quote => {
+ in_double_quote = !in_double_quote;
+ }
+ '(' if !in_single_quote && !in_double_quote => depth += 1,
+ ')' if !in_single_quote && !in_double_quote => {
+ depth -= 1;
+ if depth < 0 {
+ return Some(SpellValueValidationError::UnexpectedClosingParen);
+ }
+ }
+ _ => {}
+ }
+ }
+
+ if depth != 0 {
+ return Some(SpellValueValidationError::UnclosedParen);
+ }
+
+ None
+}
diff --git a/src/infrastructure/diagnostics.rs b/src/infrastructure/diagnostics.rs
new file mode 100644
index 0000000..0620441
--- /dev/null
+++ b/src/infrastructure/diagnostics.rs
@@ -0,0 +1,167 @@
+use crate::core::{GrimoireCssError, SourceFile};
+use miette::{Diagnostic, LabeledSpan, SourceCode};
+use std::sync::Arc;
+use thiserror::Error;
+
+fn named_source_from(source: &Arc) -> miette::NamedSource {
+ miette::NamedSource::new(source.name.clone(), (*source.content).clone())
+}
+
+#[derive(Debug, Error)]
+pub enum GrimoireCssDiagnostic {
+ #[error("IO error: {0}")]
+ Io(String),
+
+ #[error("Regex error: {0}")]
+ Regex(String),
+
+ #[error("Serialization/Deserialization error: {0}")]
+ Serde(String),
+
+ #[error("Invalid input: {0}")]
+ InvalidInput(String),
+
+ #[error("Invalid path: {0}")]
+ InvalidPath(String),
+
+ #[error("Glob pattern error: {0}")]
+ GlobPatternError(String),
+
+ #[error("Runtime error: {0}")]
+ RuntimeError(String),
+
+ #[error("CSS Optimization failed: {0}")]
+ OptimizationError(String),
+
+ #[error("Invalid spell format: {message}")]
+ InvalidSpellFormat {
+ message: String,
+ src: miette::NamedSource,
+ span: (usize, usize),
+ label: String,
+ help: Option,
+ },
+
+ #[error("{message}")]
+ CompileError {
+ message: String,
+ src: miette::NamedSource,
+ span: (usize, usize),
+ label: String,
+ help: Option,
+ },
+}
+
+impl Diagnostic for GrimoireCssDiagnostic {
+ fn code<'a>(&'a self) -> Option> {
+ match self {
+ GrimoireCssDiagnostic::Io(_) => Some(Box::new("grimoire_css::io")),
+ GrimoireCssDiagnostic::Regex(_) => Some(Box::new("grimoire_css::regex")),
+ GrimoireCssDiagnostic::Serde(_) => Some(Box::new("grimoire_css::serde")),
+ GrimoireCssDiagnostic::InvalidInput(_) => Some(Box::new("grimoire_css::invalid_input")),
+ GrimoireCssDiagnostic::InvalidPath(_) => Some(Box::new("grimoire_css::invalid_path")),
+ GrimoireCssDiagnostic::GlobPatternError(_) => {
+ Some(Box::new("grimoire_css::glob_pattern"))
+ }
+ GrimoireCssDiagnostic::RuntimeError(_) => Some(Box::new("grimoire_css::runtime")),
+ GrimoireCssDiagnostic::OptimizationError(_) => {
+ Some(Box::new("grimoire_css::optimization"))
+ }
+ GrimoireCssDiagnostic::InvalidSpellFormat { .. } => {
+ Some(Box::new("grimoire_css::invalid_spell_format"))
+ }
+ GrimoireCssDiagnostic::CompileError { .. } => {
+ Some(Box::new("grimoire_css::compile_error"))
+ }
+ }
+ }
+
+ fn help<'a>(&'a self) -> Option> {
+ match self {
+ GrimoireCssDiagnostic::InvalidSpellFormat { help, .. }
+ | GrimoireCssDiagnostic::CompileError { help, .. } => help
+ .as_deref()
+ .map(|h| Box::new(h) as Box),
+ _ => None,
+ }
+ }
+
+ fn source_code(&self) -> Option<&dyn SourceCode> {
+ match self {
+ GrimoireCssDiagnostic::InvalidSpellFormat { src, .. }
+ | GrimoireCssDiagnostic::CompileError { src, .. } => Some(src),
+ _ => None,
+ }
+ }
+
+ fn labels(&self) -> Option + '_>> {
+ match self {
+ GrimoireCssDiagnostic::InvalidSpellFormat { span, label, .. }
+ | GrimoireCssDiagnostic::CompileError { span, label, .. } => {
+ Some(Box::new(std::iter::once(
+ LabeledSpan::new_primary_with_span(Some(label.clone()), *span),
+ )))
+ }
+ _ => None,
+ }
+ }
+}
+
+impl From<&GrimoireCssError> for GrimoireCssDiagnostic {
+ fn from(value: &GrimoireCssError) -> Self {
+ match value {
+ GrimoireCssError::Io(e) => GrimoireCssDiagnostic::Io(e.to_string()),
+ GrimoireCssError::Regex(e) => GrimoireCssDiagnostic::Regex(e.to_string()),
+ GrimoireCssError::Serde(e) => GrimoireCssDiagnostic::Serde(e.to_string()),
+ GrimoireCssError::InvalidInput(msg) => GrimoireCssDiagnostic::InvalidInput(msg.clone()),
+ GrimoireCssError::InvalidPath(msg) => GrimoireCssDiagnostic::InvalidPath(msg.clone()),
+ GrimoireCssError::GlobPatternError(msg) => {
+ GrimoireCssDiagnostic::GlobPatternError(msg.clone())
+ }
+ GrimoireCssError::RuntimeError(msg) => GrimoireCssDiagnostic::RuntimeError(msg.clone()),
+ GrimoireCssError::OptimizationError(msg) => {
+ GrimoireCssDiagnostic::OptimizationError(msg.clone())
+ }
+ GrimoireCssError::InvalidSpellFormat {
+ message,
+ span,
+ label,
+ help,
+ source_file,
+ } => {
+ let src = source_file
+ .as_ref()
+ .map(named_source_from)
+ .unwrap_or_else(|| miette::NamedSource::new("unknown", "".to_string()));
+
+ GrimoireCssDiagnostic::InvalidSpellFormat {
+ message: message.clone(),
+ src,
+ span: *span,
+ label: label.clone(),
+ help: help.clone(),
+ }
+ }
+ GrimoireCssError::CompileError {
+ message,
+ span,
+ label,
+ help,
+ source_file,
+ } => {
+ let src = source_file
+ .as_ref()
+ .map(named_source_from)
+ .unwrap_or_else(|| miette::NamedSource::new("unknown", "".to_string()));
+
+ GrimoireCssDiagnostic::CompileError {
+ message: message.clone(),
+ src,
+ span: *span,
+ label: label.clone(),
+ help: help.clone(),
+ }
+ }
+ }
+ }
+}
diff --git a/src/infrastructure/lightning_css_optimizer.rs b/src/infrastructure/lightning_css_optimizer.rs
index 4036753..775dc46 100644
--- a/src/infrastructure/lightning_css_optimizer.rs
+++ b/src/infrastructure/lightning_css_optimizer.rs
@@ -79,8 +79,9 @@ impl CssOptimizer for LightningCssOptimizer {
///
/// Returns a `Result` containing the optimized CSS string or a `GrimoireCSSError` if optimization fails.
fn optimize(&self, raw_css: &str) -> Result {
- let mut stylesheet = StyleSheet::parse(raw_css, ParserOptions::default())
- .map_err(|e| GrimoireCssError::InvalidInput(format!("Failed to parse CSS: {e}")))?;
+ let mut stylesheet = StyleSheet::parse(raw_css, ParserOptions::default()).map_err(|e| {
+ GrimoireCssError::OptimizationError(format!("Failed to parse CSS: {e}"))
+ })?;
// Apply minification and optimization based on the browser targets.
stylesheet
@@ -88,7 +89,9 @@ impl CssOptimizer for LightningCssOptimizer {
targets: self.targets,
unused_symbols: Default::default(),
})
- .map_err(|e| GrimoireCssError::InvalidInput(format!("Failed to minify CSS: {e}")))?;
+ .map_err(|e| {
+ GrimoireCssError::OptimizationError(format!("Failed to minify CSS: {e}"))
+ })?;
// Generate the final CSS as a string.
stylesheet
@@ -97,6 +100,14 @@ impl CssOptimizer for LightningCssOptimizer {
..Default::default()
})
.map(|res| res.code)
- .map_err(|e| GrimoireCssError::InvalidInput(format!("Failed to generate CSS: {e}")))
+ .map_err(|e| {
+ GrimoireCssError::OptimizationError(format!("Failed to generate CSS: {e}"))
+ })
+ }
+
+ fn validate(&self, raw_css: &str) -> Result<(), GrimoireCssError> {
+ StyleSheet::parse(raw_css, ParserOptions::default())
+ .map(|_| ())
+ .map_err(|e| GrimoireCssError::OptimizationError(format!("Failed to parse CSS: {e}")))
}
}
diff --git a/src/infrastructure/mod.rs b/src/infrastructure/mod.rs
index a954821..61d32a3 100644
--- a/src/infrastructure/mod.rs
+++ b/src/infrastructure/mod.rs
@@ -1,6 +1,8 @@
//! The `infrastructure` module provides integration with external libraries and services
//! that power Grimoire CSS's core functionality. This includes CSS optimization,
//! minification, and other low-level operations that require external dependencies.
+pub mod diagnostics;
pub mod lightning_css_optimizer;
+pub use diagnostics::*;
pub use lightning_css_optimizer::*;
diff --git a/src/lib.rs b/src/lib.rs
index b7fdbe0..de7ceef 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -19,7 +19,8 @@ use commands::{handle_in_memory, process_mode_and_handle};
use console::style;
use core::{compiled_css::CompiledCssInMemory, config::ConfigInMemory};
use indicatif::{ProgressBar, ProgressStyle};
-use infrastructure::LightningCssOptimizer;
+use infrastructure::{GrimoireCssDiagnostic, LightningCssOptimizer};
+use miette::GraphicalReportHandler;
use std::time::{Duration, Instant};
pub use core::{GrimoireCssError, color, component, config, spell::Spell};
@@ -192,7 +193,18 @@ pub fn start_as_cli(args: Vec) -> Result<(), GrimoireCssError> {
print!("\r\x1b[2K{GRIMM_CURSED}\n");
println!();
- println!("{} {}", style(" Cursed! ").white().on_red().bright(), e);
+ println!(
+ "{} Something went wrong...",
+ style(" Cursed! ").white().on_red().bright()
+ );
+ println!();
+
+ let diagnostic: GrimoireCssDiagnostic = (&e).into();
+ let mut out = String::new();
+ GraphicalReportHandler::new()
+ .render_report(&mut out, &diagnostic)
+ .unwrap();
+ println!("{out}");
Err(e)
}