internal: rename structs for clarity

5 files changed, 49 insertions, 51 deletions

diff --git a/src/config/mod.rs b/src/config/mod.rs
index 131ed22..4029426 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -6,7 +6,7 @@ mod v2;
 /// This structure represents the configuration the user must provide in each
 /// instance.
 #[derive(Debug, PartialEq)]
-pub(crate) struct AdmonitionInfoRaw {
+pub(crate) struct InstanceConfig {
     pub(crate) directive: String,
     pub(crate) title: Option<String>,
     pub(crate) additional_classnames: Vec<String>,
@@ -28,10 +28,10 @@ fn admonition_config_string(info_string: &str) -> Option<&str> {
     }
 }
 
-impl AdmonitionInfoRaw {
+impl InstanceConfig {
     /// Returns:
     /// - `None` if this is not an `admonish` block.
-    /// - `Some(AdmonitionInfoRaw)` if this is an `admonish` block
+    /// - `Some(InstanceConfig)` if this is an `admonish` block
     pub fn from_info_string(info_string: &str) -> Option<Result<Self, String>> {
         let config_string = admonition_config_string(info_string)?;
 
@@ -41,15 +41,13 @@ impl AdmonitionInfoRaw {
             Err(config) => config,
         };
 
-        Some(
-            if let Ok(info_raw) = v1::from_config_string(config_string) {
-                // If we succeed at parsing v1, return that.
-                Ok(info_raw)
-            } else {
-                // Otherwise return our v2 error.
-                Err(config_v2_error)
-            },
-        )
+        Some(if let Ok(config) = v1::from_config_string(config_string) {
+            // If we succeed at parsing v1, return that.
+            Ok(config)
+        } else {
+            // Otherwise return our v2 error.
+            Err(config_v2_error)
+        })
     }
 }
 
@@ -61,14 +59,14 @@ mod test {
     #[test]
     fn test_from_info_string() {
         // Not admonition blocks
-        assert_eq!(AdmonitionInfoRaw::from_info_string(""), None);
-        assert_eq!(AdmonitionInfoRaw::from_info_string("adm"), None);
+        assert_eq!(InstanceConfig::from_info_string(""), None);
+        assert_eq!(InstanceConfig::from_info_string("adm"), None);
         // v1 syntax is supported back compatibly
         assert_eq!(
-            AdmonitionInfoRaw::from_info_string("admonish note.additional-classname")
+            InstanceConfig::from_info_string("admonish note.additional-classname")
                 .unwrap()
                 .unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "note".to_owned(),
                 title: None,
                 additional_classnames: vec!["additional-classname".to_owned()],
@@ -77,10 +75,10 @@ mod test {
         );
         // v2 syntax is supported
         assert_eq!(
-            AdmonitionInfoRaw::from_info_string(r#"admonish title="Custom Title" type="question""#)
+            InstanceConfig::from_info_string(r#"admonish title="Custom Title" type="question""#)
                 .unwrap()
                 .unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "question".to_owned(),
                 title: Some("Custom Title".to_owned()),
                 additional_classnames: Vec::new(),
diff --git a/src/config/v1.rs b/src/config/v1.rs
index 52641c7..20c9645 100644
--- a/src/config/v1.rs
+++ b/src/config/v1.rs
@@ -1,8 +1,8 @@
-use super::AdmonitionInfoRaw;
+use super::InstanceConfig;
 use once_cell::sync::Lazy;
 use regex::Regex;
 
-pub(crate) fn from_config_string(config_string: &str) -> Result<AdmonitionInfoRaw, String> {
+pub(crate) fn from_config_string(config_string: &str) -> Result<InstanceConfig, String> {
     let config_string = config_string.trim();
 
     static RX_CONFIG_STRING_V1: Lazy<Regex> = Lazy::new(|| {
@@ -49,7 +49,7 @@ pub(crate) fn from_config_string(config_string: &str) -> Result<AdmonitionInfoRa
         ),
     };
 
-    Ok(AdmonitionInfoRaw {
+    Ok(InstanceConfig {
         directive: directive.to_owned(),
         title,
         additional_classnames,
@@ -66,7 +66,7 @@ mod test {
     fn test_from_config_string() {
         assert_eq!(
             from_config_string("").unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "".to_owned(),
                 title: None,
                 additional_classnames: Vec::new(),
@@ -75,7 +75,7 @@ mod test {
         );
         assert_eq!(
             from_config_string(" ").unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "".to_owned(),
                 title: None,
                 additional_classnames: Vec::new(),
@@ -84,7 +84,7 @@ mod test {
         );
         assert_eq!(
             from_config_string("unknown").unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "unknown".to_owned(),
                 title: None,
                 additional_classnames: Vec::new(),
@@ -93,7 +93,7 @@ mod test {
         );
         assert_eq!(
             from_config_string("note").unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "note".to_owned(),
                 title: None,
                 additional_classnames: Vec::new(),
@@ -102,7 +102,7 @@ mod test {
         );
         assert_eq!(
             from_config_string("note.additional-classname").unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "note".to_owned(),
                 title: None,
                 additional_classnames: vec!["additional-classname".to_owned()],
diff --git a/src/config/v2.rs b/src/config/v2.rs
index c5550c2..7db6aec 100644
--- a/src/config/v2.rs
+++ b/src/config/v2.rs
@@ -1,10 +1,10 @@
-use super::AdmonitionInfoRaw;
+use super::InstanceConfig;
 use once_cell::sync::Lazy;
 use regex::Regex;
 use serde::Deserialize;
 
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
-struct AdmonitionInfoConfig {
+struct UserInput {
     #[serde(default)]
     r#type: Option<String>,
     #[serde(default)]
@@ -43,11 +43,11 @@ fn bare_key_value_pairs_to_toml(pairs: &str) -> String {
 ///
 /// Note that if an error occurs, a parsed struct that can be returned to
 /// show the error message will be returned.
-pub(crate) fn from_config_string(config_string: &str) -> Result<AdmonitionInfoRaw, String> {
+pub(crate) fn from_config_string(config_string: &str) -> Result<InstanceConfig, String> {
     let config_toml = bare_key_value_pairs_to_toml(config_string);
     let config_toml = config_toml.trim();
 
-    let config: AdmonitionInfoConfig = match toml::from_str(config_toml) {
+    let config: UserInput = match toml::from_str(config_toml) {
         Ok(config) => config,
         Err(error) => {
             let original_error = Err(format!("TOML parsing error: {error}"));
@@ -67,7 +67,7 @@ pub(crate) fn from_config_string(config_string: &str) -> Result<AdmonitionInfoRa
                 return original_error;
             }
 
-            let mut config: AdmonitionInfoConfig = match toml::from_str(config_toml) {
+            let mut config: UserInput = match toml::from_str(config_toml) {
                 Ok(config) => config,
                 Err(_) => return original_error,
             };
@@ -85,7 +85,7 @@ pub(crate) fn from_config_string(config_string: &str) -> Result<AdmonitionInfoRa
                 .collect()
         })
         .unwrap_or_default();
-    Ok(AdmonitionInfoRaw {
+    Ok(InstanceConfig {
         directive: config.r#type.unwrap_or_default(),
         title: config.title,
         additional_classnames,
@@ -102,7 +102,7 @@ mod test {
     fn test_from_config_string_v2() {
         assert_eq!(
             from_config_string("").unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "".to_owned(),
                 title: None,
                 additional_classnames: Vec::new(),
@@ -111,7 +111,7 @@ mod test {
         );
         assert_eq!(
             from_config_string(" ").unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "".to_owned(),
                 title: None,
                 additional_classnames: Vec::new(),
@@ -123,7 +123,7 @@ mod test {
                 r#"type="note" class="additional classname" title="Никита" collapsible=true"#
             )
             .unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "note".to_owned(),
                 title: Some("Никита".to_owned()),
                 additional_classnames: vec!["additional".to_owned(), "classname".to_owned()],
@@ -133,7 +133,7 @@ mod test {
         // Specifying unknown keys is okay, as long as they're valid
         assert_eq!(
             from_config_string(r#"unkonwn="but valid toml""#).unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "".to_owned(),
                 title: None,
                 additional_classnames: Vec::new(),
@@ -143,7 +143,7 @@ mod test {
         // Just directive is fine
         assert_eq!(
             from_config_string(r#"info"#).unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "info".to_owned(),
                 title: None,
                 additional_classnames: Vec::new(),
@@ -153,7 +153,7 @@ mod test {
         // Directive plus toml config
         assert_eq!(
             from_config_string(r#"info title="Information" collapsible=false"#).unwrap(),
-            AdmonitionInfoRaw {
+            InstanceConfig {
                 directive: "info".to_owned(),
                 title: Some("Information".to_owned()),
                 additional_classnames: Vec::new(),
diff --git a/src/lib.rs b/src/lib.rs
index 37bdd5e..b91a7d4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,7 +13,7 @@ mod resolve;
 mod types;
 
 use crate::{
-    resolve::AdmonitionInfo,
+    resolve::AdmonitionMeta,
     types::{AdmonitionDefaults, Directive},
 };
 
@@ -151,8 +151,8 @@ struct Admonition<'a> {
 }
 
 impl<'a> Admonition<'a> {
-    pub fn new(info: AdmonitionInfo, content: &'a str) -> Self {
-        let AdmonitionInfo {
+    pub fn new(info: AdmonitionMeta, content: &'a str) -> Self {
+        let AdmonitionMeta {
             directive,
             title,
             additional_classnames,
@@ -255,7 +255,7 @@ fn parse_admonition<'a>(
     content: &'a str,
     on_failure: OnFailure,
 ) -> Option<MdbookResult<Admonition<'a>>> {
-    let info = AdmonitionInfo::from_info_string(info_string, admonition_defaults)?;
+    let info = AdmonitionMeta::from_info_string(info_string, admonition_defaults)?;
     let info = match info {
         Ok(info) => info,
         // FIXME return error messages to break build if configured
diff --git a/src/resolve.rs b/src/resolve.rs
index f676b32..267791d 100644
--- a/src/resolve.rs
+++ b/src/resolve.rs
@@ -1,4 +1,4 @@
-use crate::config::AdmonitionInfoRaw;
+use crate::config::InstanceConfig;
 use crate::types::{AdmonitionDefaults, Directive};
 use std::str::FromStr;
 
@@ -6,26 +6,26 @@ use std::str::FromStr;
 ///
 /// i.e. all configured options have been resolved at this point.
 #[derive(Debug, PartialEq)]
-pub(crate) struct AdmonitionInfo {
+pub(crate) struct AdmonitionMeta {
     pub directive: Directive,
     pub title: String,
     pub additional_classnames: Vec<String>,
     pub collapsible: bool,
 }
 
-impl AdmonitionInfo {
+impl AdmonitionMeta {
     pub fn from_info_string(
         info_string: &str,
         defaults: &AdmonitionDefaults,
     ) -> Option<Result<Self, String>> {
-        AdmonitionInfoRaw::from_info_string(info_string)
+        InstanceConfig::from_info_string(info_string)
             .map(|raw| raw.map(|raw| Self::resolve(raw, defaults)))
     }
 
     /// Combine the per-admonition configuration with global defaults (and
     /// other logic) to resolve the values needed for rendering.
-    fn resolve(raw: AdmonitionInfoRaw, defaults: &AdmonitionDefaults) -> Self {
-        let AdmonitionInfoRaw {
+    fn resolve(raw: InstanceConfig, defaults: &AdmonitionDefaults) -> Self {
+        let InstanceConfig {
             directive: raw_directive,
             title,
             additional_classnames,
@@ -72,8 +72,8 @@ mod test {
     #[test]
     fn test_admonition_info_from_raw() {
         assert_eq!(
-            AdmonitionInfo::resolve(
-                AdmonitionInfoRaw {
+            AdmonitionMeta::resolve(
+                InstanceConfig {
                     directive: " ".to_owned(),
                     title: None,
                     additional_classnames: Vec::new(),
@@ -81,7 +81,7 @@ mod test {
                 },
                 &Default::default()
             ),
-            AdmonitionInfo {
+            AdmonitionMeta {
                 directive: Directive::Note,
                 title: "Note".to_owned(),
                 additional_classnames: Vec::new(),