From 62171a6008df8cf5559f796d6ee46f8a8a0bcaf2 Mon Sep 17 00:00:00 2001 From: bstriker Date: Mon, 17 Mar 2025 14:10:06 -0400 Subject: [PATCH 1/3] feat: add support for auto_init_state and auto_register_state_type --- Cargo.toml | 2 + .../src/lib.rs | 56 ++++++++++++- .../src/lib.rs | 2 + .../bevy_auto_plugin_proc_macros/src/lib.rs | 83 ++++++++++++++++++- crates/bevy_auto_plugin_shared/src/lib.rs | 43 ++++++++++ crates/bevy_auto_plugin_shared/src/util.rs | 2 + tests/nightly/auto_init_state.rs | 43 ++++++++++ tests/nightly/auto_register_state_type.rs | 61 ++++++++++++++ tests/nightly/mod.rs | 4 + tests/stable/auto_init_state.rs | 48 +++++++++++ tests/stable/auto_register_state_type.rs | 66 +++++++++++++++ tests/stable/mod.rs | 2 + 12 files changed, 405 insertions(+), 7 deletions(-) create mode 100644 tests/nightly/auto_init_state.rs create mode 100644 tests/nightly/auto_register_state_type.rs create mode 100644 tests/stable/auto_init_state.rs create mode 100644 tests/stable/auto_register_state_type.rs diff --git a/Cargo.toml b/Cargo.toml index 6e193725..bd228aca 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -30,6 +30,7 @@ bevy_auto_plugin_nightly_shared = { version = "0.1.0", path = "crates/bevy_auto_ bevy_auto_plugin_proc_macros = { version = "0.1.0", path = "crates/bevy_auto_plugin_proc_macros" } bevy_app = { version = "0.15", default-features = false } bevy_core = { version = "0.15" } +bevy_state = { version = "0.15" } bevy_reflect = { version = "0.15" } bevy_internal = { version = "0.15" } bevy_ecs = { version = "0.15" } @@ -48,6 +49,7 @@ bevy_app = { workspace = true, default-features = false } bevy_core = { workspace = true } bevy_reflect = { workspace = true } bevy_ecs = { workspace = true } +bevy_state = { workspace = true } internal_test_util = { path = "crates/internal_test_util" } trybuild = "1.0" log = { workspace = true } diff --git a/crates/bevy_auto_plugin_nightly_proc_macros/src/lib.rs b/crates/bevy_auto_plugin_nightly_proc_macros/src/lib.rs index 86d4a2dd..98fb055c 100644 --- a/crates/bevy_auto_plugin_nightly_proc_macros/src/lib.rs +++ b/crates/bevy_auto_plugin_nightly_proc_macros/src/lib.rs @@ -12,10 +12,7 @@ use bevy_auto_plugin_nightly_shared::{FileState, UpdateStateError}; use bevy_auto_plugin_shared::util::{ resolve_path_from_item_or_args, FnParamMutabilityCheckErrMessages, Target, }; -use bevy_auto_plugin_shared::{ - generate_add_events, generate_auto_names, generate_init_resources, generate_register_types, - util, -}; +use bevy_auto_plugin_shared::{generate_add_events, generate_auto_names, generate_init_resources, generate_init_states, generate_register_state_types, generate_register_types, util}; use proc_macro2::{Ident, Span}; use quote::quote; use syn::meta::ParseNestedMeta; @@ -168,16 +165,22 @@ fn auto_plugin_inner(file_path: String, app_param_name: &Ident) -> Result Compil pub fn auto_name(attr: CompilerStream, input: CompilerStream) -> CompilerStream { handle_attribute(attr, input, Target::RequiredComponentAutoName) } + +/// Automatically initializes a State in the Bevy `App`. +/// +/// # Example (without generics) +/// ```no_run +/// use bevy::prelude::*; +/// use bevy_auto_plugin::auto_plugin::*; +/// +/// #[auto_init_state] +/// #[derive(States, Debug, Copy, Clone, Default, PartialEq, Eq, Hash)] +/// struct Foo; +/// +/// #[auto_plugin(app=app)] +/// fn plugin(app: &mut App) { +/// // generated code: +/// app.init_state::(); +/// } +/// ``` +#[proc_macro_attribute] +pub fn auto_init_state(attr: CompilerStream, input: CompilerStream) -> CompilerStream { + handle_attribute(attr, input, Target::InitStates) +} + +/// Automatically registers a State type in the Bevy `App`. +/// +/// # Example (without generics) +/// ```no_run +/// use bevy::prelude::*; +/// use bevy_auto_plugin::auto_plugin::*; +/// +/// #[auto_register_state_type] +/// #[derive(States, Debug, Copy, Clone, Default, PartialEq, Eq, Hash, Reflect)] +/// struct Foo; +/// +/// #[auto_plugin(app=app)] +/// fn plugin(app: &mut App) { +/// // generated code: +/// app.register_type::>(); +/// app.register_type::>(); +/// } +/// ``` +#[proc_macro_attribute] +pub fn auto_register_state_type(attr: CompilerStream, input: CompilerStream) -> CompilerStream { + handle_attribute(attr, input, Target::RegisterStateTypes) +} \ No newline at end of file diff --git a/crates/bevy_auto_plugin_nightly_shared/src/lib.rs b/crates/bevy_auto_plugin_nightly_shared/src/lib.rs index 0fcba65d..4824e89f 100644 --- a/crates/bevy_auto_plugin_nightly_shared/src/lib.rs +++ b/crates/bevy_auto_plugin_nightly_shared/src/lib.rs @@ -58,8 +58,10 @@ pub fn update_state( let path = path_to_string(&path, false); let inserted = match target { Target::RegisterTypes => entry.context.register_types.insert(path), + Target::RegisterStateTypes => entry.context.register_state_types.insert(path), Target::AddEvents => entry.context.add_events.insert(path), Target::InitResources => entry.context.init_resources.insert(path), + Target::InitStates => entry.context.init_states.insert(path), Target::RequiredComponentAutoName => entry.context.auto_names.insert(path), }; if !inserted { diff --git a/crates/bevy_auto_plugin_proc_macros/src/lib.rs b/crates/bevy_auto_plugin_proc_macros/src/lib.rs index 218c1e2f..c74cb37e 100644 --- a/crates/bevy_auto_plugin_proc_macros/src/lib.rs +++ b/crates/bevy_auto_plugin_proc_macros/src/lib.rs @@ -4,9 +4,7 @@ use proc_macro2::TokenStream as MacroStream; use bevy_auto_plugin_shared::util::{ inject_module, items_with_attribute_macro, ItemWithAttributeMatch, }; -use bevy_auto_plugin_shared::{ - generate_add_events, generate_auto_names, generate_init_resources, generate_register_types, -}; +use bevy_auto_plugin_shared::{generate_add_events, generate_auto_names, generate_init_resources, generate_init_states, generate_register_state_types, generate_register_types}; use proc_macro2::{Ident, Span}; use quote::quote; use syn::meta::ParseNestedMeta; @@ -99,6 +97,12 @@ fn auto_plugin_inner(mut module: ItemMod, init_name: &Ident) -> Result Result(quote! { pub(super) fn #init_name(app: &mut bevy_app::prelude::App) { #auto_register_types + #auto_register_state_types #auto_add_events #auto_init_resources + #auto_init_states #auto_names } }) @@ -353,3 +361,72 @@ pub fn auto_name(_attr: CompilerStream, input: CompilerStream) -> CompilerStream // Just return the input unchanged; this acts as a marker. input } + +/// Automatically initializes a State in the Bevy `App`. +/// +/// # Example (without generics) +/// ```no_run +/// use bevy::prelude::*; +/// use bevy_auto_plugin::auto_plugin::*; +/// +/// #[auto_plugin(init_name=init)] +/// pub mod my_plugin { +/// use super::*; +/// +/// #[auto_init_state] +/// #[derive(States, Debug, Copy, Clone, Default, PartialEq, Eq, Hash)] +/// enum Foo { +/// #[default] +/// A, +/// } +/// +/// // code gen: +/// pub(super) fn init(app: &mut App) { +/// app.init_state::(); +/// } +/// } +/// +/// fn plugin(app: &mut App) { +/// app.add_plugin(my_plugin::init) +/// } +/// ``` +#[proc_macro_attribute] +pub fn auto_init_state(attr: CompilerStream, input: CompilerStream) -> CompilerStream { + // Just return the input unchanged; this acts as a marker. + input +} + +/// Automatically registers a State and NextState in the Bevy `App`. +/// +/// # Example (without generics) +/// ```no_run +/// use bevy::prelude::*; +/// use bevy_auto_plugin::auto_plugin::*; +/// +/// #[auto_plugin(init_name=init)] +/// pub mod my_plugin { +/// use super::*; +/// +/// #[auto_register_state_type] +/// #[derive(States, Debug, Copy, Clone, Default, PartialEq, Eq, Hash)] +/// enum Foo { +/// #[default] +/// A, +/// } +/// +/// // code gen: +/// pub(super) fn init(app: &mut App) { +/// app.register_type::>(); +/// app.register_type::>(); +/// } +/// } +/// +/// fn plugin(app: &mut App) { +/// app.add_plugin(my_plugin::init) +/// } +/// ``` +#[proc_macro_attribute] +pub fn auto_register_state_type(attr: CompilerStream, input: CompilerStream) -> CompilerStream { + // Just return the input unchanged; this acts as a marker. + input +} \ No newline at end of file diff --git a/crates/bevy_auto_plugin_shared/src/lib.rs b/crates/bevy_auto_plugin_shared/src/lib.rs index 35fa1fef..99aa94c5 100644 --- a/crates/bevy_auto_plugin_shared/src/lib.rs +++ b/crates/bevy_auto_plugin_shared/src/lib.rs @@ -9,8 +9,10 @@ pub mod util; #[derive(Default)] pub struct AutoPluginContext { pub register_types: HashSet, + pub register_state_types: HashSet, pub add_events: HashSet, pub init_resources: HashSet, + pub init_states: HashSet, pub auto_names: HashSet, } @@ -94,3 +96,44 @@ pub fn generate_auto_names( } }) } + +pub fn generate_register_state_types( + app_ident: &Ident, + items: impl Iterator, +) -> syn::Result { + let register_state_types = items + .map(|item| { + let item = syn::parse_str::(&item)?; + Ok(quote! { + #app_ident.register_type::>(); + #app_ident.register_type::>(); + }) + }) + .collect::>>()?; + Ok(quote! { + { + // register_state_types + #(#register_state_types)* + } + }) +} + +pub fn generate_init_states( + app_ident: &Ident, + items: impl Iterator, +) -> syn::Result { + let init_states = items + .map(|item| { + let item = syn::parse_str::(&item)?; + Ok(quote! { + #app_ident.init_state::<#item>(); + }) + }) + .collect::>>()?; + Ok(quote! { + { + // init_states + #(#init_states)* + } + }) +} \ No newline at end of file diff --git a/crates/bevy_auto_plugin_shared/src/util.rs b/crates/bevy_auto_plugin_shared/src/util.rs index a1a4f83d..64b99970 100644 --- a/crates/bevy_auto_plugin_shared/src/util.rs +++ b/crates/bevy_auto_plugin_shared/src/util.rs @@ -53,8 +53,10 @@ pub fn path_to_string(path: &Path, strip_spaces: bool) -> String { pub enum Target { RegisterTypes, + RegisterStateTypes, AddEvents, InitResources, + InitStates, RequiredComponentAutoName, } diff --git a/tests/nightly/auto_init_state.rs b/tests/nightly/auto_init_state.rs new file mode 100644 index 00000000..4b6c5c00 --- /dev/null +++ b/tests/nightly/auto_init_state.rs @@ -0,0 +1,43 @@ +use bevy_app::prelude::*; +use bevy_ecs::prelude::*; +use bevy_state::prelude::*; +use bevy_auto_plugin::auto_plugin::*; +use bevy_state::app::StatesPlugin; + +#[auto_init_state] +#[derive(States, Debug, Copy, Clone, Default, PartialEq, Eq, Hash)] +enum Test { + #[default] + A, + B, +} + +#[auto_init_state] +#[derive(SubStates, Debug, Copy, Clone, Default, PartialEq, Eq, Hash)] +#[source(Test = Test::B)] +enum InnerTest { + #[default] + A, + B, +} + +#[auto_plugin(app=app)] +fn plugin(app: &mut App) { + +} + +fn app() -> App { + let mut app = internal_test_util::create_minimal_app(); + app.add_plugins(StatesPlugin); + app.add_plugins(plugin); + app +} + +#[test] +fn test_auto_init_state() { + let app = app(); + assert!(app.world().get_resource::>().is_some(), "did not auto init state"); + assert!(app.world().get_resource::>().is_some(), "did not auto init state"); + assert!(app.world().get_resource::>().is_some(), "did not auto init state"); + assert!(app.world().get_resource::>().is_some(), "did not auto init state"); +} diff --git a/tests/nightly/auto_register_state_type.rs b/tests/nightly/auto_register_state_type.rs new file mode 100644 index 00000000..61e9142e --- /dev/null +++ b/tests/nightly/auto_register_state_type.rs @@ -0,0 +1,61 @@ +use bevy_app::prelude::*; +use bevy_ecs::prelude::*; +use bevy_reflect::prelude::*; +use bevy_state::app::StatesPlugin; +use bevy_state::prelude::*; +use bevy_auto_plugin::auto_plugin::*; + +#[auto_register_type] +#[auto_register_state_type] +#[derive(States, Debug, Copy, Clone, Default, PartialEq, Eq, Hash, Reflect)] +enum Test { + #[default] + A, + B, +} + +#[auto_register_type] +#[auto_register_state_type] +#[derive(SubStates, Debug, Copy, Clone, Default, PartialEq, Eq, Hash, Reflect)] +#[source(Test = Test::B)] +enum InnerTest { + #[default] + A, + B, +} + +#[auto_plugin(app=app)] +fn plugin(app: &mut App) { + app.init_state::(); +} + +fn app() -> App { + let mut app = internal_test_util::create_minimal_app(); + app.add_plugins(StatesPlugin); + app.add_plugins(plugin); + app +} + +#[test] +fn test_auto_register_state_type() { + use std::any::Any; + let app = app(); + let type_registry = app.world().resource::().0.clone(); + let type_registry = type_registry.read(); + assert!( + type_registry.contains(NextState::::Unchanged.type_id()), + "did not auto register state type" + ); + assert!( + type_registry.contains(State::new(Test::A).type_id()), + "did not auto register state type" + ); + assert!( + type_registry.contains(NextState::::Unchanged.type_id()), + "did not auto register state type" + ); + assert!( + type_registry.contains(State::new(InnerTest::A).type_id()), + "did not auto register state type" + ); +} diff --git a/tests/nightly/mod.rs b/tests/nightly/mod.rs index 23353ffb..f6d65979 100644 --- a/tests/nightly/mod.rs +++ b/tests/nightly/mod.rs @@ -18,3 +18,7 @@ mod auto_register_type; mod auto_register_type_generic; #[cfg(feature = "nightly_proc_macro_span")] mod ui_tests; +#[cfg(feature = "nightly_proc_macro_span")] +mod auto_register_state_type; +#[cfg(feature = "nightly_proc_macro_span")] +mod auto_init_state; diff --git a/tests/stable/auto_init_state.rs b/tests/stable/auto_init_state.rs new file mode 100644 index 00000000..0d78f9ad --- /dev/null +++ b/tests/stable/auto_init_state.rs @@ -0,0 +1,48 @@ +use bevy_app::prelude::*; +use bevy_state::prelude::*; +use bevy_state::app::StatesPlugin; +use bevy_auto_plugin::auto_plugin_module::*; + +#[auto_plugin(init_name=init)] +mod plugin_module { + use super::*; + + #[auto_init_state] + #[derive(States, Debug, Copy, Clone, Default, PartialEq, Eq, Hash)] + pub enum Test { + #[default] + A, + B, + } + + #[auto_init_state] + #[derive(SubStates, Debug, Copy, Clone, Default, PartialEq, Eq, Hash)] + #[source(Test = Test::B)] + pub enum InnerTest { + #[default] + A, + B, + } + +} +use plugin_module::*; + +fn plugin(app: &mut App) { + plugin_module::init(app); +} + +fn app() -> App { + let mut app = internal_test_util::create_minimal_app(); + app.add_plugins(StatesPlugin); + app.add_plugins(plugin); + app +} + +#[test] +fn test_auto_init_state() { + let app = app(); + assert!(app.world().get_resource::>().is_some()); + assert!(app.world().get_resource::>().is_some()); + assert!(app.world().get_resource::>().is_some(), "did not auto init state"); + assert!(app.world().get_resource::>().is_some(), "did not auto init state"); +} diff --git a/tests/stable/auto_register_state_type.rs b/tests/stable/auto_register_state_type.rs new file mode 100644 index 00000000..4cf7c7c5 --- /dev/null +++ b/tests/stable/auto_register_state_type.rs @@ -0,0 +1,66 @@ +use bevy_app::prelude::*; +use bevy_auto_plugin::auto_plugin_module::*; +use bevy_ecs::prelude::*; +use bevy_state::app::StatesPlugin; +use bevy_state::prelude::*; +use bevy_reflect::prelude::*; + +#[auto_plugin(init_name=init)] +mod plugin_module { + use super::*; + + #[auto_register_type] + #[auto_register_state_type] + #[derive(States, Debug, Copy, Clone, Default, PartialEq, Eq, Hash, Reflect)] + pub enum Test { + #[default] + A, + B, + } + + #[auto_register_type] + #[auto_register_state_type] + #[derive(SubStates, Debug, Copy, Clone, Default, PartialEq, Eq, Hash, Reflect)] + #[source(Test = Test::B)] + pub enum InnerTest { + #[default] + A, + B, + } +} +use plugin_module::*; + +fn plugin(app: &mut App) { + plugin_module::init(app); +} + +fn app() -> App { + let mut app = internal_test_util::create_minimal_app(); + app.add_plugins(StatesPlugin); + app.add_plugins(plugin); + app +} + +#[test] +fn test_auto_register_state_type() { + use std::any::Any; + let app = app(); + let type_registry = app.world().resource::().0.clone(); + let type_registry = type_registry.read(); + assert!( + type_registry.contains(State::new(Test::A).type_id()), + "did not auto init state" + ); + assert!( + type_registry.contains(NextState::::Unchanged.type_id()), + "did not auto init state" + ); + assert!( + type_registry.contains(NextState::::Unchanged.type_id()), + "did not auto register state type" + ); + assert!( + type_registry.contains(State::new(InnerTest::A).type_id()), + "did not auto register state type" + ); +} diff --git a/tests/stable/mod.rs b/tests/stable/mod.rs index 067ad14c..e4c985a5 100644 --- a/tests/stable/mod.rs +++ b/tests/stable/mod.rs @@ -7,3 +7,5 @@ mod auto_name_with_generic; mod auto_plugin_param; mod auto_register_type; mod auto_register_type_generic; +mod auto_register_state_type; +mod auto_init_state; From 845118a6a4e233b84550ce83616b7b36e6f2f9fe Mon Sep 17 00:00:00 2001 From: bstriker Date: Mon, 17 Mar 2025 14:30:21 -0400 Subject: [PATCH 2/3] chore(format): apply rustfmt --- .../src/lib.rs | 15 ++++++---- .../bevy_auto_plugin_proc_macros/src/lib.rs | 21 ++++++++------ crates/bevy_auto_plugin_shared/src/lib.rs | 2 +- tests/nightly/auto_init_state.rs | 28 +++++++++++++------ tests/nightly/auto_register_state_type.rs | 2 +- tests/nightly/mod.rs | 8 +++--- tests/stable/auto_init_state.rs | 17 +++++++---- tests/stable/auto_register_state_type.rs | 2 +- tests/stable/mod.rs | 4 +-- 9 files changed, 62 insertions(+), 37 deletions(-) diff --git a/crates/bevy_auto_plugin_nightly_proc_macros/src/lib.rs b/crates/bevy_auto_plugin_nightly_proc_macros/src/lib.rs index 98fb055c..4b793db3 100644 --- a/crates/bevy_auto_plugin_nightly_proc_macros/src/lib.rs +++ b/crates/bevy_auto_plugin_nightly_proc_macros/src/lib.rs @@ -12,7 +12,10 @@ use bevy_auto_plugin_nightly_shared::{FileState, UpdateStateError}; use bevy_auto_plugin_shared::util::{ resolve_path_from_item_or_args, FnParamMutabilityCheckErrMessages, Target, }; -use bevy_auto_plugin_shared::{generate_add_events, generate_auto_names, generate_init_resources, generate_init_states, generate_register_state_types, generate_register_types, util}; +use bevy_auto_plugin_shared::{ + generate_add_events, generate_auto_names, generate_init_resources, generate_init_states, + generate_register_state_types, generate_register_types, util, +}; use proc_macro2::{Ident, Span}; use quote::quote; use syn::meta::ParseNestedMeta; @@ -165,8 +168,10 @@ fn auto_plugin_inner(file_path: String, app_param_name: &Ident) -> Result CompilerStream } /// Automatically initializes a State in the Bevy `App`. -/// +/// /// # Example (without generics) /// ```no_run /// use bevy::prelude::*; @@ -420,4 +425,4 @@ pub fn auto_init_state(attr: CompilerStream, input: CompilerStream) -> CompilerS #[proc_macro_attribute] pub fn auto_register_state_type(attr: CompilerStream, input: CompilerStream) -> CompilerStream { handle_attribute(attr, input, Target::RegisterStateTypes) -} \ No newline at end of file +} diff --git a/crates/bevy_auto_plugin_proc_macros/src/lib.rs b/crates/bevy_auto_plugin_proc_macros/src/lib.rs index c74cb37e..061ed225 100644 --- a/crates/bevy_auto_plugin_proc_macros/src/lib.rs +++ b/crates/bevy_auto_plugin_proc_macros/src/lib.rs @@ -4,7 +4,10 @@ use proc_macro2::TokenStream as MacroStream; use bevy_auto_plugin_shared::util::{ inject_module, items_with_attribute_macro, ItemWithAttributeMatch, }; -use bevy_auto_plugin_shared::{generate_add_events, generate_auto_names, generate_init_resources, generate_init_states, generate_register_state_types, generate_register_types}; +use bevy_auto_plugin_shared::{ + generate_add_events, generate_auto_names, generate_init_resources, generate_init_states, + generate_register_state_types, generate_register_types, +}; use proc_macro2::{Ident, Span}; use quote::quote; use syn::meta::ParseNestedMeta; @@ -97,10 +100,11 @@ fn auto_plugin_inner(mut module: ItemMod, init_name: &Ident) -> Result Result(quote! { pub(super) fn #init_name(app: &mut bevy_app::prelude::App) { @@ -377,7 +382,7 @@ pub fn auto_name(_attr: CompilerStream, input: CompilerStream) -> CompilerStream /// #[derive(States, Debug, Copy, Clone, Default, PartialEq, Eq, Hash)] /// enum Foo { /// #[default] -/// A, +/// A, /// } /// /// // code gen: @@ -411,7 +416,7 @@ pub fn auto_init_state(attr: CompilerStream, input: CompilerStream) -> CompilerS /// #[derive(States, Debug, Copy, Clone, Default, PartialEq, Eq, Hash)] /// enum Foo { /// #[default] -/// A, +/// A, /// } /// /// // code gen: @@ -429,4 +434,4 @@ pub fn auto_init_state(attr: CompilerStream, input: CompilerStream) -> CompilerS pub fn auto_register_state_type(attr: CompilerStream, input: CompilerStream) -> CompilerStream { // Just return the input unchanged; this acts as a marker. input -} \ No newline at end of file +} diff --git a/crates/bevy_auto_plugin_shared/src/lib.rs b/crates/bevy_auto_plugin_shared/src/lib.rs index 99aa94c5..0cd08da8 100644 --- a/crates/bevy_auto_plugin_shared/src/lib.rs +++ b/crates/bevy_auto_plugin_shared/src/lib.rs @@ -136,4 +136,4 @@ pub fn generate_init_states( #(#init_states)* } }) -} \ No newline at end of file +} diff --git a/tests/nightly/auto_init_state.rs b/tests/nightly/auto_init_state.rs index 4b6c5c00..0723415f 100644 --- a/tests/nightly/auto_init_state.rs +++ b/tests/nightly/auto_init_state.rs @@ -1,8 +1,8 @@ use bevy_app::prelude::*; -use bevy_ecs::prelude::*; -use bevy_state::prelude::*; use bevy_auto_plugin::auto_plugin::*; +use bevy_ecs::prelude::*; use bevy_state::app::StatesPlugin; +use bevy_state::prelude::*; #[auto_init_state] #[derive(States, Debug, Copy, Clone, Default, PartialEq, Eq, Hash)] @@ -22,9 +22,7 @@ enum InnerTest { } #[auto_plugin(app=app)] -fn plugin(app: &mut App) { - -} +fn plugin(app: &mut App) {} fn app() -> App { let mut app = internal_test_util::create_minimal_app(); @@ -36,8 +34,20 @@ fn app() -> App { #[test] fn test_auto_init_state() { let app = app(); - assert!(app.world().get_resource::>().is_some(), "did not auto init state"); - assert!(app.world().get_resource::>().is_some(), "did not auto init state"); - assert!(app.world().get_resource::>().is_some(), "did not auto init state"); - assert!(app.world().get_resource::>().is_some(), "did not auto init state"); + assert!( + app.world().get_resource::>().is_some(), + "did not auto init state" + ); + assert!( + app.world().get_resource::>().is_some(), + "did not auto init state" + ); + assert!( + app.world().get_resource::>().is_some(), + "did not auto init state" + ); + assert!( + app.world().get_resource::>().is_some(), + "did not auto init state" + ); } diff --git a/tests/nightly/auto_register_state_type.rs b/tests/nightly/auto_register_state_type.rs index 61e9142e..ea62b23b 100644 --- a/tests/nightly/auto_register_state_type.rs +++ b/tests/nightly/auto_register_state_type.rs @@ -1,9 +1,9 @@ use bevy_app::prelude::*; +use bevy_auto_plugin::auto_plugin::*; use bevy_ecs::prelude::*; use bevy_reflect::prelude::*; use bevy_state::app::StatesPlugin; use bevy_state::prelude::*; -use bevy_auto_plugin::auto_plugin::*; #[auto_register_type] #[auto_register_state_type] diff --git a/tests/nightly/mod.rs b/tests/nightly/mod.rs index f6d65979..4f4bbd27 100644 --- a/tests/nightly/mod.rs +++ b/tests/nightly/mod.rs @@ -7,18 +7,18 @@ mod auto_init_resource; #[cfg(feature = "nightly_proc_macro_span")] mod auto_init_resource_generic; #[cfg(feature = "nightly_proc_macro_span")] +mod auto_init_state; +#[cfg(feature = "nightly_proc_macro_span")] mod auto_name; #[cfg(feature = "nightly_proc_macro_span")] mod auto_name_with_generics; #[cfg(feature = "nightly_proc_macro_span")] mod auto_plugin_param; #[cfg(feature = "nightly_proc_macro_span")] +mod auto_register_state_type; +#[cfg(feature = "nightly_proc_macro_span")] mod auto_register_type; #[cfg(feature = "nightly_proc_macro_span")] mod auto_register_type_generic; #[cfg(feature = "nightly_proc_macro_span")] mod ui_tests; -#[cfg(feature = "nightly_proc_macro_span")] -mod auto_register_state_type; -#[cfg(feature = "nightly_proc_macro_span")] -mod auto_init_state; diff --git a/tests/stable/auto_init_state.rs b/tests/stable/auto_init_state.rs index 0d78f9ad..6b63e8d5 100644 --- a/tests/stable/auto_init_state.rs +++ b/tests/stable/auto_init_state.rs @@ -1,7 +1,7 @@ use bevy_app::prelude::*; -use bevy_state::prelude::*; -use bevy_state::app::StatesPlugin; use bevy_auto_plugin::auto_plugin_module::*; +use bevy_state::app::StatesPlugin; +use bevy_state::prelude::*; #[auto_plugin(init_name=init)] mod plugin_module { @@ -14,7 +14,7 @@ mod plugin_module { A, B, } - + #[auto_init_state] #[derive(SubStates, Debug, Copy, Clone, Default, PartialEq, Eq, Hash)] #[source(Test = Test::B)] @@ -23,7 +23,6 @@ mod plugin_module { A, B, } - } use plugin_module::*; @@ -43,6 +42,12 @@ fn test_auto_init_state() { let app = app(); assert!(app.world().get_resource::>().is_some()); assert!(app.world().get_resource::>().is_some()); - assert!(app.world().get_resource::>().is_some(), "did not auto init state"); - assert!(app.world().get_resource::>().is_some(), "did not auto init state"); + assert!( + app.world().get_resource::>().is_some(), + "did not auto init state" + ); + assert!( + app.world().get_resource::>().is_some(), + "did not auto init state" + ); } diff --git a/tests/stable/auto_register_state_type.rs b/tests/stable/auto_register_state_type.rs index 4cf7c7c5..174453c4 100644 --- a/tests/stable/auto_register_state_type.rs +++ b/tests/stable/auto_register_state_type.rs @@ -1,9 +1,9 @@ use bevy_app::prelude::*; use bevy_auto_plugin::auto_plugin_module::*; use bevy_ecs::prelude::*; +use bevy_reflect::prelude::*; use bevy_state::app::StatesPlugin; use bevy_state::prelude::*; -use bevy_reflect::prelude::*; #[auto_plugin(init_name=init)] mod plugin_module { diff --git a/tests/stable/mod.rs b/tests/stable/mod.rs index e4c985a5..5dde6a90 100644 --- a/tests/stable/mod.rs +++ b/tests/stable/mod.rs @@ -2,10 +2,10 @@ mod auto_add_event; mod auto_add_event_generic; mod auto_init_resource; mod auto_init_resource_generic; +mod auto_init_state; mod auto_name; mod auto_name_with_generic; mod auto_plugin_param; +mod auto_register_state_type; mod auto_register_type; mod auto_register_type_generic; -mod auto_register_state_type; -mod auto_init_state; From 0903fb02fb8d892d25d7d5d6ff4df8ee9d36645a Mon Sep 17 00:00:00 2001 From: bstriker Date: Mon, 17 Mar 2025 14:32:40 -0400 Subject: [PATCH 3/3] chore(lint): satisfy clippy --- crates/bevy_auto_plugin_proc_macros/src/lib.rs | 4 ++-- tests/nightly/auto_init_state.rs | 3 +-- tests/stable/auto_init_state.rs | 2 +- 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/crates/bevy_auto_plugin_proc_macros/src/lib.rs b/crates/bevy_auto_plugin_proc_macros/src/lib.rs index 061ed225..b04e81c1 100644 --- a/crates/bevy_auto_plugin_proc_macros/src/lib.rs +++ b/crates/bevy_auto_plugin_proc_macros/src/lib.rs @@ -396,7 +396,7 @@ pub fn auto_name(_attr: CompilerStream, input: CompilerStream) -> CompilerStream /// } /// ``` #[proc_macro_attribute] -pub fn auto_init_state(attr: CompilerStream, input: CompilerStream) -> CompilerStream { +pub fn auto_init_state(_attr: CompilerStream, input: CompilerStream) -> CompilerStream { // Just return the input unchanged; this acts as a marker. input } @@ -431,7 +431,7 @@ pub fn auto_init_state(attr: CompilerStream, input: CompilerStream) -> CompilerS /// } /// ``` #[proc_macro_attribute] -pub fn auto_register_state_type(attr: CompilerStream, input: CompilerStream) -> CompilerStream { +pub fn auto_register_state_type(_attr: CompilerStream, input: CompilerStream) -> CompilerStream { // Just return the input unchanged; this acts as a marker. input } diff --git a/tests/nightly/auto_init_state.rs b/tests/nightly/auto_init_state.rs index 0723415f..1d4ec9db 100644 --- a/tests/nightly/auto_init_state.rs +++ b/tests/nightly/auto_init_state.rs @@ -1,6 +1,5 @@ use bevy_app::prelude::*; use bevy_auto_plugin::auto_plugin::*; -use bevy_ecs::prelude::*; use bevy_state::app::StatesPlugin; use bevy_state::prelude::*; @@ -9,6 +8,7 @@ use bevy_state::prelude::*; enum Test { #[default] A, + #[allow(dead_code)] B, } @@ -18,7 +18,6 @@ enum Test { enum InnerTest { #[default] A, - B, } #[auto_plugin(app=app)] diff --git a/tests/stable/auto_init_state.rs b/tests/stable/auto_init_state.rs index 6b63e8d5..4c32db0c 100644 --- a/tests/stable/auto_init_state.rs +++ b/tests/stable/auto_init_state.rs @@ -12,6 +12,7 @@ mod plugin_module { pub enum Test { #[default] A, + #[allow(dead_code)] B, } @@ -21,7 +22,6 @@ mod plugin_module { pub enum InnerTest { #[default] A, - B, } } use plugin_module::*;