feat: switch vscode to xtask

Author: makspll

.vscode/settings.json

@@ -10,11 +10,10 @@
     },
     "rust-analyzer.rustc.source": "discover",
     "rust-analyzer.linkedProjects": [
-        // "./crates/bevy_api_gen/Cargo.toml",
+        "./crates/bevy_api_gen/Cargo.toml",
         "Cargo.toml",
     ],
-    "rust-analyzer.check.invocationStrategy": "per_workspace",
-    "rust-analyzer.check.invocationLocation": "workspace",
+    "rust-analyzer.check.invocationStrategy": "once",
     "rust-analyzer.check.overrideCommand": [
         "/home/makspll/git/bevy_mod_scripting/check.sh"
     ],
@@ -28,8 +27,8 @@
     "rust-analyzer.runnables.extraArgs": [
         "--profile=release-with-debug",
     ],
-    "rust-analyzer.cargo.features": [
-        "bevy_mod_scripting_functions/test_functions"
-    ]
+    // "rust-analyzer.cargo.features": [
+    //     "bevy_mod_scripting_functions/test_functions"
+    // ]
     // "rust-analyzer.semanticHighlighting.operator.enable": false
 }

check.sh

@@ -1,11 +1,3 @@
 #!/bin/bash
-unset RUSTUP_TOOLCHAIN
-CURRENT_DIR=$(basename "$PWD")
-
-
-if [[ "$CURRENT_DIR" == "bevy_api_gen" ]]; then
-    cargo +nightly-2024-11-05 clippy --all-targets --message-format=json 
-else
-    cargo xtask check --ide-mode
-    # cargo clippy --workspace --all-targets --message-format=json --features="lua54 rhai rune bevy/file_watcher bevy/multi_threaded "
-fi
+cd "$(dirname "$0")"
+cargo xtask check --ide-mode

crates/bevy_mod_scripting_core/src/commands.rs

@@ -152,7 +152,7 @@ impl<P: IntoScriptPluginParams> Command for CreateOrUpdateScript<P> {
             // If None assign new context ID, otherwise assign the old one
             // If re-loading and different from the previous one, the old one will be removed
             let current_context_id = (assigner.assign)(script.as_deref(), &self.id, &self.content, &mut contexts);
-            
+
             debug!("{}: New context assigned?: {:?}", P::LANGUAGE, current_context_id.is_none() || current_context_id != previous_context_id);
 
             let current_context_id = if let Some(id) = current_context_id {

crates/languages/bevy_mod_scripting_lua/src/lib.rs

@@ -174,7 +174,7 @@ pub fn lua_handler(
     pre_handling_initializers: &[ContextPreHandlingInitializer<LuaScriptingPlugin>],
     _: &mut (),
     world: &mut bevy::ecs::world::World,
-) -> Result<(), bevy_mod_scripting_core::error::ScriptError> {
+) -> Result<ScriptValue, bevy_mod_scripting_core::error::ScriptError> {
     with_world(world, context, |context| {
         pre_handling_initializers
             .iter()
@@ -183,7 +183,7 @@ pub fn lua_handler(
         let handler: Function = match context.globals().raw_get(callback_label.as_ref()) {
             Ok(handler) => handler,
             // not subscribed to this event type
-            Err(_) => return Ok(()),
+            Err(_) => return Ok(ScriptValue::Unit),
         };
 
         let input = MultiValue::from_vec(
@@ -192,17 +192,17 @@ pub fn lua_handler(
                 .collect::<Result<_, _>>()?,
         );
 
-        handler.call::<()>(input)?;
-        Ok(())
+        let out = handler.call::<LuaScriptValue>(input)?;
+        Ok(out.into())
     })
 }
 
 /// Safely scopes world access for a lua context to the given closure's scope
-pub fn with_world<F: FnOnce(&mut Lua) -> Result<(), ScriptError>>(
+pub fn with_world<O, F: FnOnce(&mut Lua) -> Result<O, ScriptError>>(
     world: &mut World,
     context: &mut Lua,
     f: F,
-) -> Result<(), ScriptError> {
+) -> Result<O, ScriptError> {
     WorldCallbackAccess::with_callback_access(world, |guard| {
         context
             .globals()

crates/languages/bevy_mod_scripting_rhai/src/bindings/script_value.rs

@@ -0,0 +1 @@
+

crates/languages/bevy_mod_scripting_rhai/src/lib.rs

@@ -132,7 +132,7 @@ pub fn rhai_callback_handler(
     pre_handling_initializers: &[ContextPreHandlingInitializer<RhaiScriptingPlugin>],
     runtime: &mut RhaiRuntime,
     world: &mut World,
-) -> Result<(), ScriptError> {
+) -> Result<ScriptValue, ScriptError> {
     with_world(world, context, |context| {
         pre_handling_initializers
             .iter()
@@ -144,27 +144,27 @@ pub fn rhai_callback_handler(
             .is_none()
         {
             // not subscribed to this handler
-            return Ok(());
+            return Ok(ScriptValue::Unit);
         };
 
         // we want the call to be able to impact the scope
         let options = CallFnOptions::new().rewind_scope(false);
-        runtime.call_fn_with_options(
+        let out = runtime.call_fn_with_options::<ScriptValue>(
             options,
             &mut context.scope,
             &context.ast,
             callback.as_ref(),
             args,
         )?;
-        Ok(())
+        Ok(out)
     })
 }
 
-pub fn with_world<F: FnOnce(&mut RhaiScriptContext) -> Result<(), ScriptError>>(
+pub fn with_world<O, F: FnOnce(&mut RhaiScriptContext) -> Result<O, ScriptError>>(
     world: &mut World,
     context: &mut RhaiScriptContext,
     f: F,
-) -> Result<(), ScriptError> {
+) -> Result<O, ScriptError> {
     WorldCallbackAccess::with_callback_access(world, |guard| {
         context.scope.push("world", guard.clone());
         f(context)

crates/languages/bevy_mod_scripting_rhai/tests/rhai_tests.rs

@@ -1,42 +1,26 @@
-use bevy::{
-    app::App,
-    asset::AssetPlugin,
-    prelude::{Children, Entity, HierarchyPlugin, Parent, World},
-    reflect::{Reflect, TypeRegistration},
-};
-use bevy_mod_scripting_core::{
-    bindings::{
-        access_map::ReflectAccessId, pretty_print::DisplayWithWorld, script_value::ScriptValue,
-        ReflectReference, ScriptTypeRegistration, WorldAccessGuard,
-    },
-    context::ContextLoadingSettings,
-    error::ScriptError,
-    event::CallbackLabel,
-};
-use bevy_mod_scripting_functions::ScriptFunctionsPlugin;
-use bevy_mod_scripting_rhai::{RhaiScriptContext, RhaiScriptingPlugin};
+// use bevy::app::App;
+// use bevy_mod_scripting_functions::ScriptFunctionsPlugin;
+// use bevy_mod_scripting_rhai::RhaiScriptingPlugin;
 use libtest_mimic::{Arguments, Failed, Trial};
-use rhai::Engine;
 use std::{
     fs::{self, DirEntry},
     io, panic,
     path::{Path, PathBuf},
-    sync::Arc,
 };
-use test_utils::test_data::{setup_integration_test, setup_world, EnumerateTestComponents};
+// use test_utils::test_data::setup_integration_test;
 
-/// Initializes world for tests
-fn init_app() -> App {
-    let mut app = setup_integration_test(|_, _| {});
+// Initializes world for tests
+// fn init_app() -> App {
+//     let mut app = setup_integration_test(|_, _| {});
 
-    app.add_plugins(RhaiScriptingPlugin::default())
-        .add_plugins(ScriptFunctionsPlugin);
+//     app.add_plugins(RhaiScriptingPlugin::default())
+//         .add_plugins(ScriptFunctionsPlugin);
 
-    app.finish();
-    app.cleanup();
+//     app.finish();
+//     app.cleanup();
 
-    app
-}
+//     app
+// }
 
 struct Test {
     code: String,
@@ -45,10 +29,12 @@ struct Test {
 
 impl Test {
     fn execute(self) -> Result<(), Failed> {
+        println!("Running test: {}", self.name());
+        println!("Code: {}", self.code);
         // let lua = Lua::new();
         // set file information
-        let mut app = init_app();
-        app.add_systems(schedule, systems)
+        // let mut app = init_app();
+        // app.add_systems(schedule, systems);
 
         // let mut lua = lua_context_load(
         //     &(self.name()).into(),

crates/test_utils/src/test_data.rs

@@ -1,5 +1,4 @@
 use std::alloc::Layout;
-use std::sync::{Arc, RwLock};
 
 use bevy::ecs::{component::*, world::World};
 use bevy::prelude::*;

crates/xtask/src/main.rs

@@ -175,6 +175,15 @@ struct App {
     subcmd: Xtasks,
 }
 
+#[derive(Debug, Clone, Default, strum::EnumString)]
+#[strum(serialize_all = "snake_case")]
+enum CheckKind {
+    #[default]
+    All,
+    Main,
+    Codegen,
+}
+
 #[derive(Debug, clap::Subcommand)]
 #[clap(
     name = "xtask",
@@ -195,6 +204,15 @@ enum Xtasks {
             help = "Run in the expected format for rust-analyzer's override check command"
         )]
         ide_mode: bool,
+
+        #[clap(
+            long,
+            short,
+            default_value = "all",
+            value_parser=clap::value_parser!(CheckKind),
+            help = "The kind of check to perform",
+        )]
+        kind: CheckKind,
     },
     /// Build the rust crates.io docs as well as any other docs
     Docs {
@@ -217,7 +235,7 @@ impl Xtasks {
     fn run(self, features: Features) -> Result<()> {
         match self {
             Xtasks::Build => Self::build(features),
-            Xtasks::Check { ide_mode } => Self::check(features, ide_mode),
+            Xtasks::Check { ide_mode, kind } => Self::check(features, ide_mode, kind),
             Xtasks::Docs { open, no_rust_docs } => Self::docs(open, no_rust_docs),
             Xtasks::Test => Self::test(features),
             Xtasks::CiCheck => Self::cicd(),
@@ -361,7 +379,7 @@ impl Xtasks {
 
     fn check_main_workspace(features: Features, ide_mode: bool) -> Result<()> {
         // start with cargo clippy
-        let mut clippy_args = Vec::default();
+        let mut clippy_args = vec![];
         if ide_mode {
             clippy_args.push("--message-format=json");
         }
@@ -390,14 +408,42 @@ impl Xtasks {
         Ok(())
     }
 
-    fn check_codegen_crate(features: Features, ide_mode: bool) -> Result<()> {
+    fn check_codegen_crate(_ide_mode: bool) -> Result<()> {
         // set the working directory to the codegen crate
-        let codegen_dir = Self::relative_workspace_dir(Path::join("crates", "bevy_api_gen"))?;
+        // let crates_path = Self::relative_workspace_dir(PathBuf::from("crates"))?;
+        // let codegen_crate_path = crates_path.join("bevy_api_gen");
+
+        // let mut clippy_args = vec!["+nightly-2024-12-15", "clippy"];
+        // if ide_mode {
+        //     clippy_args.push("--message-format=json");
+        // }
+        // clippy_args.extend(vec!["--all-targets", "--", "-D", "warnings"]);
+
+        // Self::run_system_command(
+        //     "cargo",
+        //     "Failed to run clippy on codegen crate",
+        //     clippy_args,
+        //     Some(&codegen_crate_path),
+        // )?;
+
+        // TODO: for now do nothing, it's difficult to get rust analyzer to accept the nightly version
+
         Ok(())
     }
 
-    fn check(features: Features, ide_mode: bool) -> Result<()> {
-        check_main_workspace(features, ide_mode)?;
+    fn check(features: Features, ide_mode: bool, kind: CheckKind) -> Result<()> {
+        match kind {
+            CheckKind::All => {
+                Self::check_main_workspace(features.clone(), ide_mode)?;
+                Self::check_codegen_crate(ide_mode)?;
+            }
+            CheckKind::Main => {
+                Self::check_main_workspace(features, ide_mode)?;
+            }
+            CheckKind::Codegen => {
+                Self::check_codegen_crate(ide_mode)?;
+            }
+        }
         Ok(())
     }
 
@@ -591,7 +637,7 @@ impl Xtasks {
 
         // run lints
         let all_features = Features::all_features();
-        Self::check(all_features.clone(), false)?;
+        Self::check(all_features.clone(), false, CheckKind::Main)?;
 
         // run docs
         Self::docs(false, false)?;