Issue 279 remove unnecessary unwraps

.github/workflows/ci.yaml

@@ -97,7 +97,7 @@ jobs:
       - name: Install stable@stable toolchain
         uses: dtolnay/rust-toolchain@stable
       - name: Run cargo test
-        run: cargo test --workspace --all-features --profile=ci
+        run: cargo test --workspace --all-features --release
 
   # Run cargo clippy -- -D warnings
   clippy_check:

Cargo.toml

@@ -138,7 +138,7 @@ backtrace = ["backtrace-on-stack-overflow"]
 bevy_xpbd_3d = ["dep:space_bevy_xpbd_plugin"]
 persistence_editor = []
 no_event_registration = ["space_prefab/no_event_registration"]
-default = ["bevy_xpbd_3d", "persistence_editor", "bevy/dynamic_linking"]
+default = ["bevy_xpbd_3d", "persistence_editor", "bevy/dynamic_linking", "space_prefab/editor"]
 
 [[example]]
 name = "platformer"

crates/editor_core/src/gltf_unpack.rs

@@ -78,7 +78,9 @@
 
 fn unpack_gltf(world: &mut World) {
     let loaded_scenes = {
-        let mut events = world.resource_mut::<Events<GltfLoaded>>();
+        let Some(mut events) = world.get_resource_mut::<Events<GltfLoaded>>() else {
+            return;
+        };
         let mut reader = events.get_reader();
         let loaded = reader.read(&events).cloned().collect::<Vec<GltfLoaded>>();
         events.clear();
@@ -95,15 +97,44 @@
         };
         info!("Path: {:?}", &gltf_path);
 
-        let Some(gltf) = world.resource::<Assets<Gltf>>().get(&gltf.0) else {
+        let Some(gltf) = world
+            .get_resource::<Assets<Gltf>>()
+            .and_then(|gltfs| gltfs.get(&gltf.0))
+        else {
+            #[cfg(feature = "editor")]
+            world.send_event(space_shared::toast::ToastMessage::new(
+                "Gltf asset not found or empty",
+                space_shared::toast::ToastKind::Error,
+            ));
             continue;
         };
 
         let mut commands = Commands::new(&mut command_queue, world);
 
-        let gltf_nodes = world.resource::<Assets<GltfNode>>();
-        let gltf_meshs = world.resource::<Assets<GltfMesh>>();
-        let scenes = world.resource::<Assets<Scene>>();
+        let Some(gltf_nodes) = world.get_resource::<Assets<GltfNode>>() else {
+            #[cfg(feature = "editor")]
+            world.send_event(space_shared::toast::ToastMessage::new(
+                "Gltf Node asset not found",
+                space_shared::toast::ToastKind::Error,
+            ));
+            continue;
+        };
+        let Some(gltf_meshs) = world.get_resource::<Assets<GltfMesh>>() else {
+            #[cfg(feature = "editor")]
+            world.send_event(space_shared::toast::ToastMessage::new(
+                "Gltf Mesh asset not found",
+                space_shared::toast::ToastKind::Error,
+            ));
+            continue;
+        };
+        let Some(scenes) = world.get_resource::<Assets<Scene>>() else {
+            #[cfg(feature = "editor")]
+            world.send_event(space_shared::toast::ToastMessage::new(
+                "Scene asset not found",
+                space_shared::toast::ToastKind::Error,
+            ));
+            continue;
+        };
 
         let mut mesh_map = HashMap::new();
         for idx in 0..gltf.meshes.len() {
@@ -125,7 +156,9 @@
             let mut roots = vec![];
             for e in scene.world.iter_entities() {
                 if !e.contains::<Parent>() && e.contains::<Children>() {
-                    let children = e.get::<Children>().unwrap();
+                    let Some(children) = e.get::<Children>() else {
+                        continue;
+                    };
                     for child in children.iter() {
                         if let Some(name) = scene.world.entity(*child).get::<Name>() {
                             info!("Name: {:?}", &name);

crates/editor_core/src/hotkeys.rs

@@ -130,6 +130,7 @@
             self.register_type::<HashMap<T, Vec<KeyCode>>>();
             self.register_type::<T>();
             self.world
+                // Safe, was injected in this function
                 .resource_mut::<AllHotkeys>()
                 .mappers
                 .push(Box::new(|w, map_fun| {
@@ -141,6 +142,7 @@
                 }));
 
             self.world
+                // Safe, was injected in this function
                 .resource_mut::<AllHotkeys>()
                 .global_mapper
                 .push(Box::new(|w, map_fun| {
@@ -150,7 +152,9 @@
                 }))
         }
 
-        let mut set = self.world.get_resource_mut::<HotkeySet<T>>().unwrap();
+        let Some(mut set) = self.world.get_resource_mut::<HotkeySet<T>>() else {
+            return self;
+        };
         set.bindings.insert(key, binding);
         self
     }

crates/editor_core/src/load.rs

@@ -11,7 +11,9 @@
         let assets = world.resource::<Assets<DynamicScene>>();
         if let Some(scene) = &load_server.scene {
             if let Some(scene) = assets.get(scene) {
-                let mut scene = Scene::from_dynamic_scene(scene, &app_registry).unwrap();
+                let Ok(mut scene) = Scene::from_dynamic_scene(scene, &app_registry) else {
+                    return;
+                };
                 scene.world.insert_resource(app_registry);
                 prefab = DynamicScene::from_scene(&scene); //kill me, is it clone() analog for DynamicScene
             } else {
@@ -21,7 +23,14 @@
             return;
         }
     }
-    world.resource_mut::<EditorLoader>().scene = None;
+    let Some(mut editor_loader) = world.get_resource_mut::<EditorLoader>() else {
+        world.send_event(ToastMessage::new(
+            "Failed to get prefab loader",
+            egui_toast::ToastKind::Error,
+        ));
+        return;
+    };
+    editor_loader.scene = None;
 
     let mut query = world.query_filtered::<(Entity, Option<&Name>), With<PrefabMarker>>();
     let mark_to_delete: Vec<_> = query
@@ -38,7 +47,11 @@
         if despawned {
             world.send_event(ToastMessage::new(
                 &if name.is_some() {
-                    format!("Despawning {}: {:?}", name.unwrap(), entity)
+                    format!(
+                        "Despawning {}: {:?}",
+                        name.unwrap_or_else(|| Name::from(format!("{entity:?}"))),
+                        entity
+                    )
                 } else {
                     format!("Despawning {:?}", entity)
                 },

crates/editor_tabs/src/lib.rs

@@ -137,7 +137,12 @@
             .show_add_popup(true)
             .show(ctx, &mut tab_viewer);
 
-        let windows_setting = unsafe { cell.world_mut().resource_mut::<NewWindowSettings>() };
+        let Some(windows_setting) =
+            (unsafe { cell.world_mut().get_resource_mut::<NewWindowSettings>() })
+        else {
+            error!("Failed to load new window settings");
+            return;
+        };
         for command in tab_viewer.tab_commands {
             match command {
                 EditorTabCommand::Add {
@@ -162,7 +167,7 @@
                         if let Some(surface) = self.tree.get_surface_mut(surface) {
                             surface
                                 .node_tree_mut()
-                                .unwrap()
+                                .unwrap() // Guaranteed to exist
                                 .split_right(node, 0.5, vec![name]);
                         }
                     }
@@ -216,7 +221,10 @@
                         });
 
                 to_label(
-                    world.resource_mut::<T>().tab_name().title.as_str(),
+                    &world
+                        .get_resource::<T>()
+                        .map(|tab| tab.tab_name().title)
+                        .unwrap_or_else(|| "Unknown".to_string()),
                     text_size,
                 )
                 .into()
@@ -243,6 +251,7 @@
 
         tab.schedule.add_systems(tab_systems);
 
+        // Not much we can do here
         self.world
             .resource_mut::<ScheduleEditorTabStorage>()
             .0

crates/editor_tabs/src/start_layout.rs

@@ -86,7 +86,9 @@
         group: G,
         tab: N,
     ) -> &mut Self {
-        self.world.resource_mut::<R>().push(group, tab);
+        if let Some(mut layout) = self.world.get_resource_mut::<R>() {
+            layout.push(group, tab)
+        }
         self
     }
 
@@ -95,7 +97,9 @@
         group: G,
         tab: N,
     ) -> &mut Self {
-        self.world.resource_mut::<R>().push_front(group, tab);
+        if let Some(mut layout) = self.world.get_resource_mut::<R>() {
+            layout.push_front(group, tab)
+        }
         self
     }
 

crates/editor_ui/src/camera_view.rs

@@ -191,12 +191,18 @@
         let mut need_recreate_texture = false;
 
         if self.target_image.is_none() {
-            let handle = world
-                .resource_mut::<Assets<Image>>()
-                .add(create_camera_image(
+            let Some(handle) = world.get_resource_mut::<Assets<Image>>().map(|mut assets| {
+                assets.add(create_camera_image(
                     clipped.width() as u32,
                     clipped.height() as u32,
+                ))
+            }) else {
+                world.send_event(ToastMessage::new(
+                    "No camera image target found.",
+                    toast::ToastKind::Error,
                 ));
+                return;
+            };
             self.target_image = Some(handle);
             self.need_reinit_egui_tex = true;
             let msg = format!(
@@ -220,12 +226,18 @@
         }
 
         if need_recreate_texture {
-            let handle = world
-                .resource_mut::<Assets<Image>>()
-                .add(create_camera_image(
+            let Some(handle) = world.get_resource_mut::<Assets<Image>>().map(|mut assets| {
+                assets.add(create_camera_image(
                     clipped.width() as u32,
                     clipped.height() as u32,
+                ))
+            }) else {
+                world.send_event(ToastMessage::new(
+                    "No camera image target found.",
+                    toast::ToastKind::Error,
                 ));
+                return;
+            };
 
             self.target_image = Some(handle);
             self.need_reinit_egui_tex = true;

crates/editor_ui/src/game_view.rs

@@ -90,9 +90,11 @@
 
             ui.spacing();
             //Draw FPS
-            let dt = world.get_resource::<Time>().unwrap().delta_seconds();
-            self.smoothed_dt = self.smoothed_dt.mul_add(0.98, dt * 0.02);
-            ui.colored_label(TEXT_COLOR, format!("FPS: {:.0}", 1.0 / self.smoothed_dt));
+            if let Some(dt) = world.get_resource::<Time>() {
+                let dt = dt.delta_seconds();
+                self.smoothed_dt = self.smoothed_dt.mul_add(0.98, dt * 0.02);
+                ui.colored_label(TEXT_COLOR, format!("FPS: {:.0}", 1.0 / self.smoothed_dt));
+            }
 
             #[cfg(debug_assertions)]
             {

crates/editor_ui/src/hierarchy.rs

@@ -211,6 +211,7 @@ fn draw_entity<F: QueryFilter>(
             }
         })
         .body(|ui| {
+            // already checked that children is some
             for child in children.unwrap().iter() {
                 draw_entity(
                     commands,

crates/editor_ui/src/inspector/mod.rs

@@ -18,8 +18,11 @@
 
 use space_editor_core::prelude::*;
 use space_prefab::{component::EntityLink, editor_registry::EditorRegistry};
-use space_shared::ext::bevy_inspector_egui::{
-    inspector_egui_impls::InspectorEguiImpl, reflect_inspector::InspectorUi,
+use space_shared::{
+    ext::bevy_inspector_egui::{
+        inspector_egui_impls::InspectorEguiImpl, reflect_inspector::InspectorUi,
+    },
+    toast::{ToastKind, ToastMessage},
 };
 
 use crate::{editor_tab_name::EditorTabName, icons::add_component_icon};
@@ -114,7 +117,14 @@
         });
 
         let cell = world.as_unsafe_world_cell();
-        let mut state = unsafe { cell.get_resource_mut::<InspectState>().unwrap() };
+        let Some(mut state) = (unsafe { cell.get_resource_mut::<InspectState>() }) else {
+            error!("Failed to load inspect state");
+            world.send_event(ToastMessage::new(
+                "Failed to load inspect state",
+                ToastKind::Error,
+            ));
+            return;
+        };
 
         let mut commands: Vec<InspectCommand> = vec![];
         let mut queue = CommandQueue::default();

crates/editor_ui/src/meshless_visualizer.rs

@@ -128,6 +128,7 @@ pub struct EditorIconAssets {
 fn register_assets(mut commands: Commands, asset_server: Res<AssetServer>) {
     use space_shared::asset_fs::*;
     let assets = EditorIconAssets {
+        // Unwraps are logged
         unknown: asset_server.add(
             create_unknown_image()
                 .inspect_err(|err| error!("failed to load image `Unknown`: {err}"))

crates/editor_ui/src/settings.rs

@@ -135,9 +135,12 @@
         block: impl FnMut(&mut egui::Ui, &mut Commands, &mut World) + Send + Sync + 'static,
     ) {
         self.world
-            .resource_mut::<SettingsWindow>()
-            .sub_blocks
-            .insert(name.to_string(), Box::new(block));
+            .get_resource_mut::<SettingsWindow>()
+            .map(|mut settings| {
+                settings
+                    .sub_blocks
+                    .insert(name.to_string(), Box::new(block))
+            });
     }
 }
 

crates/editor_ui/src/ui_registration.rs

@@ -70,7 +70,11 @@
             reg
         } else {
             self.init_resource::<BundleReg>();
-            self.world.get_resource_mut::<BundleReg>().unwrap()
+            if let Some(reg) = self.world.get_resource_mut::<BundleReg>() {
+                reg
+            } else {
+                return;
+            }
         };
 
         reg.add_bundle(EditorBundle {

crates/prefab/Cargo.toml

@@ -12,6 +12,7 @@ description = "Subcrate for the space_editor crate. Contains the prefab systems
 
 [features]
 no_event_registration = []
+editor = []
 
 [dependencies]
 bevy.workspace = true