[WIP] Don't unghost plugins when loading initial state

If a plugin is explicitly active then it should already be unghosted, and otherwise isn't actually active.

If a plugin is implicitly active, then it's only actually implicitly active if the unghosted plugin exists.

If a plugin is inactive then it can be ghosted or not.

WIP because what I've implemented doesn't match the text above, but I'm also not sure that's the correct approach, it could be confusing since the ghost extension is stripped, so you could see a plugin in the load order that seems like it should be active, but it isn't because it's actually ghosted.

Author: Ortham

src/load_order/asterisk_based.rs

@@ -70,7 +70,7 @@ impl AsteriskBasedLoadOrder {
             > self.game_settings.early_loading_plugins().len()
     }
 
-    fn implicitly_activate_blueprint_ships_plugins(&mut self) -> Result<(), Error> {
+    fn implicitly_activate_blueprint_ships_plugins(&mut self) {
         let active_base_names: HashSet<UniCase<&str>> = self
             .plugins()
             .iter()
@@ -93,11 +93,9 @@ impl AsteriskBasedLoadOrder {
 
         for index in indexes {
             if let Some(plugin) = self.plugins.get_mut(index) {
-                plugin.implicitly_activate()?;
+                plugin.set_implicitly_active_if_inactive();
             }
         }
-
-        Ok(())
     }
 }
 
@@ -133,7 +131,7 @@ impl WritableLoadOrder for AsteriskBasedLoadOrder {
         self.add_implicitly_active_plugins()?;
 
         if self.game_settings.id() == GameId::Starfield {
-            self.implicitly_activate_blueprint_ships_plugins()?;
+            self.implicitly_activate_blueprint_ships_plugins();
         }
 
         hoist_masters(&mut self.plugins)?;

src/load_order/mutable.rs

@@ -304,7 +304,9 @@ where
 
     for plugin_name in plugin_names {
         if let Some(plugin) = load_order.find_plugin_mut(&plugin_name) {
-            plugin.activate()?;
+            // No need to un-ghost plugins since this is loading existing active
+            // state so the plugins must already be non-ghosted.
+            plugin.set_explicitly_active();
         }
     }
 
@@ -769,7 +771,8 @@ fn implicitly_activate<T: MutableLoadOrder + ?Sized>(
     filename: &str,
 ) -> Result<(), Error> {
     if let Some(plugin) = load_order.find_plugin_mut(filename) {
-        plugin.implicitly_activate()
+        plugin.set_implicitly_active_if_inactive();
+        Ok(())
     } else {
         // Ignore any errors trying to load the plugin to save checking if it's
         // valid and then loading it if it is.

src/load_order/timestamp_based.rs

@@ -110,7 +110,9 @@ impl TimestampBasedLoadOrder {
 
         for plugin_name in plugin_names {
             if let Some(plugin) = self.find_plugin_mut(&plugin_name) {
-                plugin.activate()?;
+                // No need to un-ghost plugins since this is loading existing
+                // active state so the plugins must already be non-ghosted.
+                plugin.set_explicitly_active();
             }
         }
 

src/load_order/writable.rs

@@ -255,7 +255,7 @@ fn activate_with_blueprint_ships_plugin<T: MutableLoadOrder>(
 
     if let Some(index) = blueprint_ships_plugin_index {
         if let Some(plugin) = load_order.plugins_mut().get_mut(index) {
-            plugin.implicitly_activate()?;
+            plugin.set_implicitly_active_if_inactive();
         }
     }
 
@@ -969,8 +969,7 @@ mod tests {
         load_order
             .find_plugin_mut(plugin_name)
             .unwrap()
-            .implicitly_activate()
-            .unwrap();
+            .set_implicitly_active_if_inactive();
 
         assert!(load_order.is_active(plugin_name));
         assert!(!load_order
@@ -1031,8 +1030,7 @@ mod tests {
         load_order
             .find_plugin_mut(plugin_name)
             .unwrap()
-            .implicitly_activate()
-            .unwrap();
+            .set_implicitly_active_if_inactive();
 
         let blueprint_ships = "BlueprintShips-Blank.esm";
         copy_to_test_dir(
@@ -1240,7 +1238,7 @@ mod tests {
             load_order.game_settings(),
         );
         let index = add(&mut load_order, blueprint_ships).unwrap();
-        load_order.plugins[index].implicitly_activate().unwrap();
+        load_order.plugins[index].set_implicitly_active_if_inactive();
 
         let plugin_name = "Blank.esp";
         assert!(load_order.is_active(plugin_name));
@@ -1294,7 +1292,7 @@ mod tests {
             load_order.game_settings(),
         );
         let index = add(&mut load_order, blueprint_ships).unwrap();
-        load_order.plugins[index].implicitly_activate().unwrap();
+        load_order.plugins[index].set_implicitly_active_if_inactive();
 
         let plugin_name = "Blank.esp";
         assert!(load_order.is_active(plugin_name));
@@ -1319,7 +1317,7 @@ mod tests {
             load_order.game_settings(),
         );
         let index = add(&mut load_order, blueprint_ships).unwrap();
-        load_order.plugins[index].implicitly_activate().unwrap();
+        load_order.plugins[index].set_implicitly_active_if_inactive();
 
         std::fs::write(
             load_order

src/plugin.rs

@@ -78,7 +78,7 @@ impl Plugin {
             use crate::ghostable_path::GhostablePath;
 
             if active.is_active() {
-                filepath.unghost()?
+                filepath
             } else {
                 filepath.resolve_path()?
             }
@@ -207,6 +207,18 @@ impl Plugin {
         Ok(())
     }
 
+    /// This does not un-ghost ghosted plugins.
+    pub(crate) fn set_explicitly_active(&mut self) {
+        self.active = ActiveState::ExplicitlyActive;
+    }
+
+    pub(crate) fn set_implicitly_active_if_inactive(&mut self) {
+        if self.active == ActiveState::Inactive {
+            self.active = ActiveState::ImplicitlyActive;
+        }
+    }
+
+    /// This un-ghosts plugins that are currently inactive.
     pub fn activate(&mut self) -> Result<(), Error> {
         // A plugin only needs to be un-ghosted if it's currently inactive.
         if !self.is_active() && self.game_id.allow_plugin_ghosting() {
@@ -228,18 +240,6 @@ impl Plugin {
         Ok(())
     }
 
-    pub(crate) fn implicitly_activate(&mut self) -> Result<(), Error> {
-        let was_inactive = self.active == ActiveState::Inactive;
-
-        self.activate()?;
-
-        if was_inactive {
-            self.active = ActiveState::ImplicitlyActive;
-        }
-
-        Ok(())
-    }
-
     /// This should only be called after checking that the plugin isn't
     /// considered implicitly active.
     pub fn deactivate(&mut self) {
@@ -765,7 +765,7 @@ mod tests {
         copy_to_test_dir("Blank.esp", "Blank.esp.ghost", &settings);
         let mut plugin = Plugin::new("Blank.esp", &settings).unwrap();
 
-        plugin.implicitly_activate().unwrap();
+        plugin.set_implicitly_active_if_inactive();
 
         assert!(plugin.is_active());
         assert_eq!(ActiveState::ImplicitlyActive, plugin.active);
@@ -784,7 +784,7 @@ mod tests {
         let mut plugin =
             Plugin::with_active("Blank.esp", &settings, ActiveState::ExplicitlyActive).unwrap();
 
-        plugin.implicitly_activate().unwrap();
+        plugin.set_implicitly_active_if_inactive();
 
         assert!(plugin.is_active());
         assert_eq!(ActiveState::ExplicitlyActive, plugin.active);