From 320ea9a3a418daa17174dc78f1262509b96b13b9 Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Sun, 19 Jul 2026 10:32:33 +0800 Subject: fix!: rename `Groupped` to `Grouped` across the codebase --- mingling_pathf/src/pattern_analyzer.rs | 2 +- mingling_pathf/src/patterns.rs | 4 +- mingling_pathf/src/patterns/grouped_derive.rs | 98 ++++++++++++++++++++++++++ mingling_pathf/src/patterns/groupped_derive.rs | 98 -------------------------- 4 files changed, 101 insertions(+), 101 deletions(-) create mode 100644 mingling_pathf/src/patterns/grouped_derive.rs delete mode 100644 mingling_pathf/src/patterns/groupped_derive.rs (limited to 'mingling_pathf/src') diff --git a/mingling_pathf/src/pattern_analyzer.rs b/mingling_pathf/src/pattern_analyzer.rs index 3765971..5bbc3b4 100644 --- a/mingling_pathf/src/pattern_analyzer.rs +++ b/mingling_pathf/src/pattern_analyzer.rs @@ -31,7 +31,7 @@ pub fn init_with_config(config: PathfinderConfig) -> PatternAnalyzer { analyzer.add_pattern(BasicStructPattern); analyzer.add_pattern(PackPattern); analyzer.add_pattern(GroupPattern); - analyzer.add_pattern(GrouppedDerivePattern); + analyzer.add_pattern(GroupedDerivePattern); analyzer.add_pattern(ChainPattern); analyzer.add_pattern(RendererPattern); analyzer.add_pattern(HelpPattern); diff --git a/mingling_pathf/src/patterns.rs b/mingling_pathf/src/patterns.rs index 9801e9b..9845b73 100644 --- a/mingling_pathf/src/patterns.rs +++ b/mingling_pathf/src/patterns.rs @@ -6,7 +6,7 @@ pub use completion::*; pub use dispatcher::*; pub use dispatcher_clap::*; pub use group::*; -pub use groupped_derive::*; +pub use grouped_derive::*; pub use help::*; pub use pack::*; pub use renderer::*; @@ -17,7 +17,7 @@ mod completion; mod dispatcher; mod dispatcher_clap; mod group; -mod groupped_derive; +mod grouped_derive; mod help; mod pack; mod renderer; diff --git a/mingling_pathf/src/patterns/grouped_derive.rs b/mingling_pathf/src/patterns/grouped_derive.rs new file mode 100644 index 0000000..9522c1f --- /dev/null +++ b/mingling_pathf/src/patterns/grouped_derive.rs @@ -0,0 +1,98 @@ +//! The `GroupedDerivePattern` matches structs, enums, and unions annotated with +//! `#[derive(Grouped)]` or `#[derive(GroupedSerialize)]` (or any combination +//! with other derives). It also recurses into `mod` items to find nested types. +//! This is used to track grouped items for code generation or analysis. + +use syn::Item; + +use crate::pattern_analyzer::{AnalyzeItem, AnalyzePattern}; + +/// Matches `#[derive(Grouped)]` and `#[derive(GroupedSerialize)]`. +/// +/// Covers the forms: +/// - `#[derive(Grouped)] struct T { ... }` +/// - `#[derive(Grouped, Serialize, ...)] struct T { ... }` +/// - `#[derive(GroupedSerialize)] struct T { ... }` +pub struct GroupedDerivePattern; + +impl AnalyzePattern for GroupedDerivePattern { + fn contains(&self, content: &str) -> bool { + content.contains("Grouped") + } + + fn analyze(&self, content: &str) -> Vec { + let Ok(syntax) = syn::parse_file(content) else { + return Vec::new(); + }; + + let mut items = Vec::new(); + + for item in &syntax.items { + match item { + Item::Struct(s) if has_grouped_derive(&s.attrs) => { + items.push(AnalyzeItem { + module: String::new(), + item_name: s.ident.to_string(), + }); + } + Item::Enum(e) if has_grouped_derive(&e.attrs) => { + items.push(AnalyzeItem { + module: String::new(), + item_name: e.ident.to_string(), + }); + } + Item::Union(u) if has_grouped_derive(&u.attrs) => { + items.push(AnalyzeItem { + module: String::new(), + item_name: u.ident.to_string(), + }); + } + Item::Mod(item_mod) => { + if let Some((_, nested)) = &item_mod.content { + for n in nested { + match n { + Item::Struct(s) if has_grouped_derive(&s.attrs) => { + items.push(AnalyzeItem { + module: item_mod.ident.to_string(), + item_name: s.ident.to_string(), + }); + } + Item::Enum(e) if has_grouped_derive(&e.attrs) => { + items.push(AnalyzeItem { + module: item_mod.ident.to_string(), + item_name: e.ident.to_string(), + }); + } + _ => {} + } + } + } + } + _ => {} + } + } + + items + } +} + +fn has_grouped_derive(attrs: &[syn::Attribute]) -> bool { + attrs.iter().any(|attr| { + if attr.path().is_ident("derive") { + // Correctly parse comma-separated paths in #[derive(Grouped, Debug, ...)] + attr.parse_args_with(|input: syn::parse::ParseStream| { + let paths = + syn::punctuated::Punctuated::::parse_terminated( + input, + )?; + Ok(paths.iter().any(|p| { + let name = p.segments.last().unwrap().ident.to_string(); + name == "Grouped" || name == "GroupedSerialize" + })) + }) + .unwrap_or(false) + } else { + false + } + }) +} diff --git a/mingling_pathf/src/patterns/groupped_derive.rs b/mingling_pathf/src/patterns/groupped_derive.rs deleted file mode 100644 index 91daaef..0000000 --- a/mingling_pathf/src/patterns/groupped_derive.rs +++ /dev/null @@ -1,98 +0,0 @@ -//! The `GrouppedDerivePattern` matches structs, enums, and unions annotated with -//! `#[derive(Groupped)]` or `#[derive(GrouppedSerialize)]` (or any combination -//! with other derives). It also recurses into `mod` items to find nested types. -//! This is used to track grouped items for code generation or analysis. - -use syn::Item; - -use crate::pattern_analyzer::{AnalyzeItem, AnalyzePattern}; - -/// Matches `#[derive(Groupped)]` and `#[derive(GrouppedSerialize)]`. -/// -/// Covers the forms: -/// - `#[derive(Groupped)] struct T { ... }` -/// - `#[derive(Groupped, Serialize, ...)] struct T { ... }` -/// - `#[derive(GrouppedSerialize)] struct T { ... }` -pub struct GrouppedDerivePattern; - -impl AnalyzePattern for GrouppedDerivePattern { - fn contains(&self, content: &str) -> bool { - content.contains("Groupped") - } - - fn analyze(&self, content: &str) -> Vec { - let Ok(syntax) = syn::parse_file(content) else { - return Vec::new(); - }; - - let mut items = Vec::new(); - - for item in &syntax.items { - match item { - Item::Struct(s) if has_groupped_derive(&s.attrs) => { - items.push(AnalyzeItem { - module: String::new(), - item_name: s.ident.to_string(), - }); - } - Item::Enum(e) if has_groupped_derive(&e.attrs) => { - items.push(AnalyzeItem { - module: String::new(), - item_name: e.ident.to_string(), - }); - } - Item::Union(u) if has_groupped_derive(&u.attrs) => { - items.push(AnalyzeItem { - module: String::new(), - item_name: u.ident.to_string(), - }); - } - Item::Mod(item_mod) => { - if let Some((_, nested)) = &item_mod.content { - for n in nested { - match n { - Item::Struct(s) if has_groupped_derive(&s.attrs) => { - items.push(AnalyzeItem { - module: item_mod.ident.to_string(), - item_name: s.ident.to_string(), - }); - } - Item::Enum(e) if has_groupped_derive(&e.attrs) => { - items.push(AnalyzeItem { - module: item_mod.ident.to_string(), - item_name: e.ident.to_string(), - }); - } - _ => {} - } - } - } - } - _ => {} - } - } - - items - } -} - -fn has_groupped_derive(attrs: &[syn::Attribute]) -> bool { - attrs.iter().any(|attr| { - if attr.path().is_ident("derive") { - // Correctly parse comma-separated paths in #[derive(Groupped, Debug, ...)] - attr.parse_args_with(|input: syn::parse::ParseStream| { - let paths = - syn::punctuated::Punctuated::::parse_terminated( - input, - )?; - Ok(paths.iter().any(|p| { - let name = p.segments.last().unwrap().ident.to_string(); - name == "Groupped" || name == "GrouppedSerialize" - })) - }) - .unwrap_or(false) - } else { - false - } - }) -} -- cgit