🎉 automatically manage luau-api of project

Author: vanyle

TODO.md

@@ -18,12 +18,12 @@
     - [x] Add a way to pick the prefered text editor (with vscode as default)
   - [x] Write the bundle.py script to watch the specs defined in plugins.md
   - [x] Manage files that the editor needs to work that are not inside the editor binary in a cross-platform way.
-  - [ ] Show plugins in the editor
-  - [ ] Automatically manage the `luau-api` folder (create it when the project is created, verify its integrity on load, etc...)
+  - [x] Show plugins in the editor
+  - [x] Automatically manage the `luau-api` folder (create it when the project is created, verify its integrity on load, etc...)
   - [ ] Add all editor hooks (debug menu)
   - [ ] Reload plugins in the editor
-  - [ ] Show supported platforms in the editor
-  - [ ] Add ability to load/unload plugins from the editor from the filesystem
+  - [x] Show supported platforms in the editor
+  - [x] Add ability to load/unload plugins from the editor from the filesystem
   - [ ] Add ability to download plugins from the editor
   - [ ] Add documentation on how to create and use plugins
   - [ ] Test that it works on Linux

docs/user-manual.md

@@ -858,10 +858,13 @@ Working on a game with other people is more fun!
 
 ## Vectarine and Git
 
-Vectarine works well with version control systems like [Git](https://git-scm.com/). If you already now Git, use it!
+Vectarine works well with version control systems like [Git](https://git-scm.com/). If you already now Git, use it! You can add "luau-api" to your .gitignore
+as it is automatically generated by Vectarine when the project is loaded.
 
 If you don't know Git, do not use it, it is complex to learn.
 
+
+
 ## Vectarine and shared folders
 
 You use shared folder using Google Drive, Dropbox to have multiple people working on the same project.

editor/src/editorinterface.rs

@@ -33,7 +33,7 @@ use crate::{
     },
     egui_sdl2_platform,
     export::exportinterface::draw_editor_export,
-    pluginsystem::trustedplugin::{self, PluginEntry},
+    pluginsystem::trustedplugin::{self, PluginEntry, TrustedPlugin},
     projectstate::ProjectState,
 };
 use editorconsole::draw_editor_console;
@@ -101,6 +101,7 @@ impl EditorState {
         let video = self.video.clone();
         let window = self.window.clone();
         let debouncer = self.debouncer.clone();
+        let trusted_plugins = self.get_trusted_plugins();
 
         LocalFileSystem.read_file(
             geteditorpaths::get_editor_config_path()
@@ -138,6 +139,7 @@ impl EditorState {
                             gl,
                             video,
                             window,
+                            &trusted_plugins,
                             |loaded_project| {
                                 if let Ok(loaded_project) = loaded_project {
                                     project.replace(Some(loaded_project));
@@ -200,9 +202,12 @@ impl EditorState {
             self.gl.clone(),
             self.video.clone(),
             self.window.clone(),
+            &self.get_trusted_plugins(),
             |project| {
                 match project {
-                    Ok(p) => self.project.borrow_mut().replace(p),
+                    Ok(p) => {
+                        self.project.borrow_mut().replace(p);
+                    }
                     Err(e) => {
                         callback(Err(e));
                         return;
@@ -303,6 +308,16 @@ impl EditorState {
             platform.handle_event(event, sdl, &self.video.borrow());
         }
     }
+
+    pub fn get_trusted_plugins(&self) -> Vec<TrustedPlugin> {
+        self.plugins
+            .iter()
+            .filter_map(|entry| match entry {
+                PluginEntry::Trusted(trusted_plugin) => Some(trusted_plugin.clone()),
+                PluginEntry::Malformed(_) => None,
+            })
+            .collect::<Vec<TrustedPlugin>>()
+    }
 }
 
 pub fn handle_close_events(latest_events: &[sdl2::event::Event]) {

editor/src/editorinterface/editorplugins.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Cow, fs};
+use std::{borrow::Cow, fs, path::PathBuf};
 
 use egui_extras::{Column, TableBody, TableBuilder};
 use runtime::egui::{self, Label};
@@ -8,7 +8,9 @@ use crate::{
         EditorState,
         extra::geteditorpaths::{get_editor_plugins_path, get_end_of_path},
     },
-    pluginsystem::trustedplugin::{self, PluginEntry, TrustedPlugin},
+    pluginsystem::trustedplugin::{
+        self, PluginEntry, TrustedPlugin, get_available_filename_for_trusted_plugin,
+    },
     projectstate::ProjectState,
 };
 
@@ -42,6 +44,10 @@ pub fn draw_editor_plugin_manager(editor: &mut EditorState, ctx: &egui::Context)
 }
 
 fn draw_editor_plugin_manager_content(editor: &mut EditorState, ui: &mut egui::Ui) {
+    // Both refresh buttons do the same as there is no case where you want to refresh one list without refreshing the other.
+    // There are 2 buttons in the UI to drive away the point that there are 2 different concepts: game plugins and trusted plugins.
+    let mut should_refresh_plugins = false;
+
     ui.horizontal(|ui|{
         if ui.button("Open trusted plugins folder")
             .on_hover_text("Open the folder where trusted plugins are stored. You can add plugins there and they will appear in the list of trusted plugins.")
@@ -54,24 +60,27 @@ fn draw_editor_plugin_manager_content(editor: &mut EditorState, ui: &mut egui::U
             }
 
         if ui.button("Refresh trusted plugin list").clicked() {
-            editor.plugins = trustedplugin::load_plugins();
+            should_refresh_plugins = true;
         }
     });
 
-    let plugins = &mut editor.plugins;
-
-    if plugins.is_empty() {
+    if editor.plugins.is_empty() {
         ui.label("No plugins found").on_hover_text("Plugins are programs that extend Vectarine's functionality. They are files ending with '.vecta.plugin'. You can download plugins or create them using the template provided by Vectarine GitHub repository.");
     } else {
         ui.heading("Trusted plugins").on_hover_text("Trusted plugins are the list of plugins known to the editor. Only plugins of a game that are also inside the trusted list are executed.");
 
         draw_table_header_for_plugin(ui, "trusted", |body| {
-            for plugin in plugins.iter_mut() {
+            for plugin in editor.plugins.iter_mut() {
                 let row_height = 20.0;
                 match plugin {
                     PluginEntry::Trusted(trusted_plugin) => {
                         let game_project = editor.project.borrow();
-                        draw_trusted_plugin_row(body, trusted_plugin, game_project.as_ref());
+                        draw_trusted_plugin_row(
+                            body,
+                            trusted_plugin,
+                            game_project.as_ref(),
+                            &mut should_refresh_plugins,
+                        );
                     }
                     PluginEntry::Malformed(malformed) => {
                         let filename = malformed
@@ -114,7 +123,8 @@ fn draw_editor_plugin_manager_content(editor: &mut EditorState, ui: &mut egui::U
         .on_hover_text("Game plugins are the list of plugins belonging to the current game. Only plugins that are also trusted are executed.");
 
     let project = editor.project.borrow();
-    if let Some(project) = &project.as_ref() {
+
+    if let Some(project) = project.as_ref() {
         ui.horizontal(|ui| {
             #[allow(clippy::collapsible_if)]
             if ui
@@ -131,37 +141,61 @@ fn draw_editor_plugin_manager_content(editor: &mut EditorState, ui: &mut egui::U
             }
 
             if ui.button("Refresh game plugins list").clicked() {
-                let trusted_plugins = editor
-                    .plugins
-                    .iter()
-                    .filter_map(|entry| match entry {
-                        PluginEntry::Trusted(trusted_plugin) => Some(trusted_plugin.clone()),
-                        PluginEntry::Malformed(_) => None,
-                    })
-                    .collect::<Vec<TrustedPlugin>>();
-                project.refresh_plugin_list(&trusted_plugins);
+                should_refresh_plugins = true;
             }
         });
 
-        let mut game_plugins = project.plugins.borrow_mut();
+        {
+            let game_plugins = project.plugins.borrow();
+            if game_plugins.is_empty() {
+                ui.label("Because you use no native plugins, all platforms are supported.");
+            } else {
+                let is_untrusted_plugin_in_list =
+                    game_plugins.iter().any(|p| p.trusted_plugin.is_none());
+                if is_untrusted_plugin_in_list {
+                    ui.label("Because some plugins are not trusted, the list of supported platform is unknown");
+                } else {
+                    let supported_platforms = game_plugins
+                        .iter()
+                        .filter_map(|p| p.trusted_plugin.as_ref())
+                        .map(|trusted_plugin| trusted_plugin.supported_platforms.clone())
+                        .reduce(|a, b| &a & &b);
+                    if let Some(supported_platforms) = supported_platforms {
+                        ui.label(format!(
+                        "Your game only supports the following platforms: {}",
+                        supported_platforms
+                            .iter()
+                            .map(|p| p.to_string())
+                            .collect::<Vec<_>>()
+                            .join(", ")
+                    )).on_hover_text("For a platform to be supported, it needs to be supported by all the plugins you use.");
+                    } else {
+                        ui.label("Something went wrong while checking the supported platform. Try refreshing the list of plugins.");
+                    }
+                }
+            }
+        }
+
+        let mut plugin_to_trust: Option<PathBuf> = None;
 
         draw_table_header_for_game_plugin(ui, "game", |body| {
-            for plugin in game_plugins.iter_mut() {
+            let game_plugins = project.plugins.borrow();
+            for plugin in game_plugins.iter() {
                 let row_height = 20.0;
-                let filename = plugin
+                let display_filename = plugin
                     .path
                     .file_name()
                     .map(|p| p.display().to_string())
                     .unwrap_or_else(|| get_end_of_path(&plugin.path));
 
-                match plugin.trusted_plugin.as_mut() {
+                match plugin.trusted_plugin.as_ref() {
                     Some(trusted_plugin) => {
                         body.row(row_height, |mut row| {
                             row.col(|ui| {
                                 ui.label(&trusted_plugin.name);
                             });
                             row.col(|ui| {
-                                ui.label(filename);
+                                ui.label(display_filename);
                             });
                             row.col(|ui| {
                                 ui.label("This plugin is trusted");
@@ -171,31 +205,54 @@ fn draw_editor_plugin_manager_content(editor: &mut EditorState, ui: &mut egui::U
                     None => {
                         body.row(row_height, |mut row| {
                             row.col(|ui| {
-                                ui.label("⚠️ Untrusted").on_hover_text("This plugin is not trusted and won't be executed. You can add it to the list of trusted plugin to allow its execution.");
+                                ui.label("⚠ Untrusted").on_hover_text("This plugin is not trusted and won't be executed. You can add it to the list of trusted plugins to allow its execution.");
                             });
                             row.col(|ui| {
-                                ui.label(filename);
+                                ui.label(display_filename);
                             });
                             row.col(|ui| {
                                 if ui.button("Trust").clicked() {
-                                    // Trust it and refresh lists.
+                                    plugin_to_trust = Some(plugin.path.clone());
+                                    should_refresh_plugins = true;
                                 }
                             });
                         });
                     }
                 }
             }
         });
+
+        // We perform actions on the plugin list outside of drawing code to avoid mutating the list of plugins while iterating on it.
+        // Trusting a plugin means copying it the trusted folder. We refresh the list afterwards
+        if let Some(plugin_to_trust) = plugin_to_trust {
+            let editor_plugin_folder = get_editor_plugins_path();
+            let plugin_filename = plugin_to_trust
+                .file_name()
+                .map(|fname| fname.display().to_string())
+                .unwrap_or_else(|| "plugin.vectaplugin".to_string());
+            let _ = std::fs::create_dir_all(&editor_plugin_folder);
+            let destination = editor_plugin_folder
+                .join(get_available_filename_for_trusted_plugin(&plugin_filename));
+            let _ = std::fs::copy(&plugin_to_trust, destination);
+        }
     } else {
         ui.label("No project loaded")
             .on_hover_text("Load a project to see its plugins.");
     }
+
+    if should_refresh_plugins {
+        editor.plugins = trustedplugin::load_plugins();
+        if let Some(project) = project.as_ref() {
+            project.refresh_plugin_list(&editor.get_trusted_plugins());
+        }
+    }
 }
 
 fn draw_trusted_plugin_row(
     body: &mut TableBody,
     plugin: &mut TrustedPlugin,
     game_project: Option<&ProjectState>,
+    should_refresh_plugins: &mut bool,
 ) {
     let ui = body.ui_mut();
     let font_id = egui::TextStyle::Body.resolve(ui.style());
@@ -258,9 +315,19 @@ fn draw_trusted_plugin_row(
                     p.trusted_plugin.as_ref().map(|plugin| plugin.hash) == Some(plugin.hash)
                 });
                 if is_added {
-                    ui.label("Added");
+                    if ui
+                        .button("Stop trusting")
+                        .on_hover_text(
+                            "Deletes the trusted plugin file from the editor plugin folder",
+                        )
+                        .clicked()
+                    {
+                        let _ = fs::remove_file(&plugin.path);
+                        *should_refresh_plugins = true;
+                    }
                 } else if ui.button("Add to game").clicked() {
                     game_project.add_plugin(plugin.clone());
+                    *should_refresh_plugins = true;
                 }
             }
         });
@@ -337,8 +404,8 @@ fn draw_table_header_for_game_plugin(
             .resizable(true)
             .auto_shrink(true)
             .cell_layout(egui::Layout::left_to_right(egui::Align::Center))
-            .column(Column::auto()) // Name
-            .column(Column::auto().at_most(200.0).clip(true)) // Path
+            .column(Column::auto().at_least(100.0)) // Name
+            .column(Column::auto().at_least(200.0).clip(true)) // Filename
             .column(Column::auto()) // Actions
             .min_scrolled_height(0.0)
             .max_scroll_height(available_height);

editor/src/pluginsystem/trustedplugin.rs

@@ -221,3 +221,32 @@ pub fn is_dynamic_library_file(path: &Path) -> bool {
     };
     DYNAMIC_LIB_SUFFIXES.contains(&ext.to_string_lossy().as_ref())
 }
+
+pub fn is_trusted_plugin_name_is_available(name: &str) -> bool {
+    let editor_plugin_path = get_editor_plugins_path();
+    !editor_plugin_path.join(name).exists()
+}
+
+/// Returns a name for a trusted plugin that does not exist yet, using the preferred name if possible.
+pub fn get_available_filename_for_trusted_plugin(preferred_name: &str) -> String {
+    let (name, extension) = preferred_name
+        .split_once('.')
+        .unwrap_or((preferred_name, ""));
+    let mut considered_index = 0;
+    loop {
+        let name = format!(
+            "{}{}.{}",
+            name,
+            if considered_index == 0 {
+                String::new()
+            } else {
+                format!("_{}", considered_index)
+            },
+            extension
+        );
+        if is_trusted_plugin_name_is_available(&name) {
+            return name;
+        }
+        considered_index += 1;
+    }
+}