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/README.md | 2 +- 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 ---------------------- mingling_pathf/test/src/lib.rs | 4 +- .../test/src/test_files/test_grouped_derive.rs | 43 ++++++++++ .../test/src/test_files/test_groupped_derive.rs | 43 ---------- 8 files changed, 147 insertions(+), 147 deletions(-) create mode 100644 mingling_pathf/src/patterns/grouped_derive.rs delete mode 100644 mingling_pathf/src/patterns/groupped_derive.rs create mode 100644 mingling_pathf/test/src/test_files/test_grouped_derive.rs delete mode 100644 mingling_pathf/test/src/test_files/test_groupped_derive.rs (limited to 'mingling_pathf') diff --git a/mingling_pathf/README.md b/mingling_pathf/README.md index 89d1811..9706f49 100644 --- a/mingling_pathf/README.md +++ b/mingling_pathf/README.md @@ -7,7 +7,7 @@ ## Overview -`mingling_pathf` provides the `pathf` feature for Mingling. It automatically analyzes the full module paths of all Mingling types in a crate at build-time (types defined via `pack!`, `#[derive(Groupped)]`, `#[chain]`, `#[renderer]`, etc.), and generates a mapping from type names to module paths for consumption by `gen_program!()` at compile-time. +`mingling_pathf` provides the `pathf` feature for Mingling. It automatically analyzes the full module paths of all Mingling types in a crate at build-time (types defined via `pack!`, `#[derive(Grouped)]`, `#[chain]`, `#[renderer]`, etc.), and generates a mapping from type names to module paths for consumption by `gen_program!()` at compile-time. When enabled, `gen_program!()` uses full module paths for type references in the generated dispatch code (e.g., `downcast::()`), eliminating the need to `use` all types in the module where `gen_program!()` is called. This allows for a more flexible module organization without the constraint of centralized `use` statements. 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 - } - }) -} diff --git a/mingling_pathf/test/src/lib.rs b/mingling_pathf/test/src/lib.rs index 824cbbf..7e7cbd5 100644 --- a/mingling_pathf/test/src/lib.rs +++ b/mingling_pathf/test/src/lib.rs @@ -222,11 +222,11 @@ fn test_group_analyze() { } #[test] -fn test_groupped_derive_analyze() { +fn test_grouped_derive_analyze() { let analyzer = mingling_pathf::pattern_analyzer::init(); let file = current_dir() .unwrap() - .join("src/test_files/test_groupped_derive.rs"); + .join("src/test_files/test_grouped_derive.rs"); let r = analyzer.analyze_file(file).unwrap(); let required: Vec<&str> = vec![ diff --git a/mingling_pathf/test/src/test_files/test_grouped_derive.rs b/mingling_pathf/test/src/test_files/test_grouped_derive.rs new file mode 100644 index 0000000..20055e9 --- /dev/null +++ b/mingling_pathf/test/src/test_files/test_grouped_derive.rs @@ -0,0 +1,43 @@ +#[derive(Grouped)] +struct Derived1 { + value: String, +} + +#[derive(Grouped, Debug, Clone)] +struct Derived2 { + value: i32, +} + +#[derive(GroupedSerialize)] +struct Derived3 { + value: bool, +} + +#[derive(Grouped)] +enum EnumDerived1 { + A, + B, +} + +#[derive(GroupedSerialize)] +enum EnumDerived2 { + X(String), + Y(i32), +} + +pub mod sub { + #[derive(Grouped)] + struct Derived1 { + value: String, + } + + #[derive(GroupedSerialize)] + struct Derived3 { + value: bool, + } + + #[derive(Grouped)] + enum EnumDerived1 { + A, + } +} diff --git a/mingling_pathf/test/src/test_files/test_groupped_derive.rs b/mingling_pathf/test/src/test_files/test_groupped_derive.rs deleted file mode 100644 index 913587c..0000000 --- a/mingling_pathf/test/src/test_files/test_groupped_derive.rs +++ /dev/null @@ -1,43 +0,0 @@ -#[derive(Groupped)] -struct Derived1 { - value: String, -} - -#[derive(Groupped, Debug, Clone)] -struct Derived2 { - value: i32, -} - -#[derive(GrouppedSerialize)] -struct Derived3 { - value: bool, -} - -#[derive(Groupped)] -enum EnumDerived1 { - A, - B, -} - -#[derive(GrouppedSerialize)] -enum EnumDerived2 { - X(String), - Y(i32), -} - -pub mod sub { - #[derive(Groupped)] - struct Derived1 { - value: String, - } - - #[derive(GrouppedSerialize)] - struct Derived3 { - value: bool, - } - - #[derive(Groupped)] - enum EnumDerived1 { - A, - } -} -- cgit