Use "Light Plugin" instead of "Light Master"

Libloadorder used both terms, but the former is less confusable with non-light master files, so use it consistently.
Ortham · Mar 9, 2021 · a4e589e · a4e589e
1 parent 65e2a25
commit a4e589e
Show file tree

Hide file tree

Showing 4 changed files with 37 additions and 40 deletions.
diff --git a/src/enums.rs b/src/enums.rs
@@ -68,7 +68,7 @@ impl GameId {
         }
     }
 
-    pub fn supports_light_masters(self) -> bool {
+    pub fn supports_light_plugins(self) -> bool {
         use enums::GameId::*;
         match self {
             Fallout4 | Fallout4VR | SkyrimSE | SkyrimVR => true,
@@ -229,15 +229,15 @@ mod tests {
     }
 
     #[test]
-    fn game_id_supports_light_masters_should_be_false_until_fallout_4() {
-        assert!(!GameId::Morrowind.supports_light_masters());
-        assert!(!GameId::Oblivion.supports_light_masters());
-        assert!(!GameId::Skyrim.supports_light_masters());
-        assert!(GameId::SkyrimSE.supports_light_masters());
-        assert!(GameId::SkyrimVR.supports_light_masters());
-        assert!(!GameId::Fallout3.supports_light_masters());
-        assert!(!GameId::FalloutNV.supports_light_masters());
-        assert!(GameId::Fallout4.supports_light_masters());
-        assert!(GameId::Fallout4VR.supports_light_masters());
+    fn game_id_supports_light_plugins_should_be_false_until_fallout_4() {
+        assert!(!GameId::Morrowind.supports_light_plugins());
+        assert!(!GameId::Oblivion.supports_light_plugins());
+        assert!(!GameId::Skyrim.supports_light_plugins());
+        assert!(GameId::SkyrimSE.supports_light_plugins());
+        assert!(GameId::SkyrimVR.supports_light_plugins());
+        assert!(!GameId::Fallout3.supports_light_plugins());
+        assert!(!GameId::FalloutNV.supports_light_plugins());
+        assert!(GameId::Fallout4.supports_light_plugins());
+        assert!(GameId::Fallout4VR.supports_light_plugins());
     }
 }
diff --git a/src/load_order/mutable.rs b/src/load_order/mutable.rs
@@ -34,7 +34,7 @@ use game_settings::GameSettings;
 use plugin::{trim_dot_ghost, Plugin};
 
 pub const MAX_ACTIVE_NORMAL_PLUGINS: usize = 255;
-pub const MAX_ACTIVE_LIGHT_MASTERS: usize = 4096;
+pub const MAX_ACTIVE_LIGHT_PLUGINS: usize = 4096;
 
 pub trait MutableLoadOrder: ReadableLoadOrder + ReadableLoadOrderBase + Sync {
     fn plugins_mut(&mut self) -> &mut Vec<Plugin>;
@@ -44,14 +44,14 @@ pub trait MutableLoadOrder: ReadableLoadOrder + ReadableLoadOrderBase + Sync {
     fn count_active_normal_plugins(&self) -> usize {
         self.plugins()
             .iter()
-            .filter(|p| !p.is_light_master_file() && p.is_active())
+            .filter(|p| !p.is_light_plugin() && p.is_active())
             .count()
     }
 
-    fn count_active_light_masters(&self) -> usize {
+    fn count_active_light_plugins(&self) -> usize {
         self.plugins()
             .iter()
-            .filter(|p| p.is_light_master_file() && p.is_active())
+            .filter(|p| p.is_light_plugin() && p.is_active())
             .count()
     }
 
@@ -110,8 +110,8 @@ pub trait MutableLoadOrder: ReadableLoadOrder + ReadableLoadOrderBase + Sync {
         count_plugins(self.plugins(), existing_plugin_indices, false)
     }
 
-    fn count_light_masters(&mut self, existing_plugin_indices: &[usize]) -> usize {
-        if self.game_settings().id().supports_light_masters() {
+    fn count_light_plugins(&mut self, existing_plugin_indices: &[usize]) -> usize {
+        if self.game_settings().id().supports_light_plugins() {
             count_plugins(self.plugins(), existing_plugin_indices, true)
         } else {
             0
@@ -329,23 +329,23 @@ fn to_plugin(
 fn count_plugins(
     existing_plugins: &[Plugin],
     existing_plugin_indices: &[usize],
-    count_light_masters: bool,
+    count_light_plugins: bool,
 ) -> usize {
     existing_plugin_indices
         .iter()
-        .filter(|i| existing_plugins[**i].is_light_master_file() == count_light_masters)
+        .filter(|i| existing_plugins[**i].is_light_plugin() == count_light_plugins)
         .count()
 }
 
 fn get_excess_active_plugin_indices<T: MutableLoadOrder + ?Sized>(load_order: &T) -> Vec<usize> {
     let implicitly_active_plugins = load_order.game_settings().implicitly_active_plugins();
     let mut normal_active_count = load_order.count_active_normal_plugins();
-    let mut light_master_active_count = load_order.count_active_light_masters();
+    let mut light_plugin_active_count = load_order.count_active_light_plugins();
 
     let mut plugin_indices: Vec<usize> = Vec::new();
     for (index, plugin) in load_order.plugins().iter().enumerate().rev() {
         if normal_active_count <= MAX_ACTIVE_NORMAL_PLUGINS
-            && light_master_active_count <= MAX_ACTIVE_LIGHT_MASTERS
+            && light_plugin_active_count <= MAX_ACTIVE_LIGHT_PLUGINS
         {
             break;
         }
@@ -354,13 +354,10 @@ fn get_excess_active_plugin_indices<T: MutableLoadOrder + ?Sized>(load_order: &T
                 .iter()
                 .any(|i| plugin.name_matches(i));
         if can_deactivate {
-            if plugin.is_light_master_file() && light_master_active_count > MAX_ACTIVE_LIGHT_MASTERS
-            {
+            if plugin.is_light_plugin() && light_plugin_active_count > MAX_ACTIVE_LIGHT_PLUGINS {
                 plugin_indices.push(index);
-                light_master_active_count -= 1;
-            } else if !plugin.is_light_master_file()
-                && normal_active_count > MAX_ACTIVE_NORMAL_PLUGINS
-            {
+                light_plugin_active_count -= 1;
+            } else if !plugin.is_light_plugin() && normal_active_count > MAX_ACTIVE_NORMAL_PLUGINS {
                 plugin_indices.push(index);
                 normal_active_count -= 1;
             }
@@ -946,7 +943,7 @@ mod tests {
     }
 
     #[test]
-    fn find_first_non_master_should_find_a_light_master_flagged_esp() {
+    fn find_first_non_master_should_find_a_light_flagged_esp() {
         let tmp_dir = tempdir().unwrap();
         let plugins = prepare_plugins(&tmp_dir.path(), "Blank.esl");
 

diff --git a/src/load_order/writable.rs b/src/load_order/writable.rs
@@ -22,7 +22,7 @@ use std::path::Path;
 
 use unicase::eq;
 
-use super::mutable::{MutableLoadOrder, MAX_ACTIVE_LIGHT_MASTERS, MAX_ACTIVE_NORMAL_PLUGINS};
+use super::mutable::{MutableLoadOrder, MAX_ACTIVE_LIGHT_PLUGINS, MAX_ACTIVE_NORMAL_PLUGINS};
 use super::readable::ReadableLoadOrder;
 use enums::Error;
 use plugin::Plugin;
@@ -124,8 +124,8 @@ pub fn remove<T: MutableLoadOrder>(load_order: &mut T, plugin_name: &str) -> Res
 pub fn activate<T: MutableLoadOrder>(load_order: &mut T, plugin_name: &str) -> Result<(), Error> {
     let at_max_active_normal_plugins =
         load_order.count_active_normal_plugins() == MAX_ACTIVE_NORMAL_PLUGINS;
-    let at_max_active_light_masters =
-        load_order.count_active_light_masters() == MAX_ACTIVE_LIGHT_MASTERS;
+    let at_max_active_light_plugins =
+        load_order.count_active_light_plugins() == MAX_ACTIVE_LIGHT_PLUGINS;
 
     let plugin = match load_order
         .plugins_mut()
@@ -137,8 +137,8 @@ pub fn activate<T: MutableLoadOrder>(load_order: &mut T, plugin_name: &str) -> R
     };
 
     if !plugin.is_active()
-        && ((!plugin.is_light_master_file() && at_max_active_normal_plugins)
-            || (plugin.is_light_master_file() && at_max_active_light_masters))
+        && ((!plugin.is_light_plugin() && at_max_active_normal_plugins)
+            || (plugin.is_light_plugin() && at_max_active_light_plugins))
     {
         Err(Error::TooManyActivePlugins)
     } else {
@@ -166,7 +166,7 @@ pub fn set_active_plugins<T: MutableLoadOrder>(
     let existing_plugin_indices = load_order.lookup_plugins(active_plugin_names)?;
 
     if load_order.count_normal_plugins(&existing_plugin_indices) > MAX_ACTIVE_NORMAL_PLUGINS
-        || load_order.count_light_masters(&existing_plugin_indices) > MAX_ACTIVE_LIGHT_MASTERS
+        || load_order.count_light_plugins(&existing_plugin_indices) > MAX_ACTIVE_LIGHT_PLUGINS
     {
         return Err(Error::TooManyActivePlugins);
     }

diff --git a/src/plugin.rs b/src/plugin.rs
@@ -104,7 +104,7 @@ impl Plugin {
         self.data.is_master_file()
     }
 
-    pub fn is_light_master_file(&self) -> bool {
+    pub fn is_light_plugin(&self) -> bool {
         self.data.is_light_master_file()
     }
 
@@ -165,7 +165,7 @@ impl Plugin {
 }
 
 fn has_valid_extension(filename: &str, game: GameId) -> bool {
-    let valid_extensions = if game.supports_light_masters() {
+    let valid_extensions = if game.supports_light_plugins() {
         VALID_EXTENSIONS_WITH_ESL
     } else {
         VALID_EXTENSIONS
@@ -313,7 +313,7 @@ mod tests {
     }
 
     #[test]
-    fn is_light_master_file_should_be_true_for_esl_files_only() {
+    fn is_light_plugin_should_be_true_for_esl_files_only() {
         let tmp_dir = tempdir().unwrap();
         let game_dir = tmp_dir.path();
 
@@ -329,17 +329,17 @@ mod tests {
         copy_to_test_dir("Blank.esm", "Blank.esm", &settings);
         let plugin = Plugin::new("Blank.esm", &settings).unwrap();
 
-        assert!(!plugin.is_light_master_file());
+        assert!(!plugin.is_light_plugin());
 
         copy_to_test_dir("Blank.esm", "Blank.esl", &settings);
         let plugin = Plugin::new("Blank.esl", &settings).unwrap();
 
-        assert!(plugin.is_light_master_file());
+        assert!(plugin.is_light_plugin());
 
         copy_to_test_dir("Blank - Different.esp", "Blank - Different.esl", &settings);
         let plugin = Plugin::new("Blank - Different.esl", &settings).unwrap();
 
-        assert!(plugin.is_light_master_file());
+        assert!(plugin.is_light_plugin());
     }
 
     #[test]