refactor(config): simplify configuration loading by removing manual setup

Signed-off-by: azjezz <[email protected]>

Author: azjezz

src/commands/init.rs

@@ -25,7 +25,7 @@ use crate::error::Error;
 use crate::utils::version::extract_minimum_php_version;
 
 const CONFIGURATION_TEMPLATE: &str = r#"# Welcome to Mago!
-# For full documentation, see https://mago.carthage.software/
+# For full documentation, see https://mago.carthage.software/tools/overview
 php_version = "{php_version}"
 
 [source]

src/config/analyzer.rs

@@ -1,14 +1,8 @@
-use config::ConfigBuilder;
-use config::Value;
-use config::ValueKind;
-use config::builder::BuilderState;
-use mago_analyzer::settings::Settings;
-use mago_php_version::PHPVersion;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::config::ConfigurationEntry;
-use crate::error::Error;
+use mago_analyzer::settings::Settings;
+use mago_php_version::PHPVersion;
 
 /// Configuration options for the static analyzer.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -134,49 +128,6 @@ impl AnalyzerConfiguration {
     }
 }
 
-impl ConfigurationEntry for AnalyzerConfiguration {
-    fn configure<St: BuilderState>(self, builder: ConfigBuilder<St>) -> Result<ConfigBuilder<St>, Error> {
-        let defaults = Self::default();
-
-        builder
-            .set_default(
-                "analyze.excludes",
-                Value::new(None, ValueKind::Array(self.excludes.into_iter().map(Value::from).collect::<Vec<_>>())),
-            )?
-            .set_default(
-                "analyze.ignore",
-                Value::new(None, ValueKind::Array(self.ignore.into_iter().map(Value::from).collect::<Vec<_>>())),
-            )?
-            .set_default("analyze.mixed-issues", defaults.mixed_issues)?
-            .set_default("analyze.falsable-issues", defaults.falsable_issues)?
-            .set_default("analyze.nullable-issues", defaults.nullable_issues)?
-            .set_default("analyze.redundancy-issues", defaults.redundancy_issues)?
-            .set_default("analyze.reference-issues", defaults.reference_issues)?
-            .set_default("analyze.unreachable-issues", defaults.unreachable_issues)?
-            .set_default("analyze.deprecation-issues", defaults.deprecation_issues)?
-            .set_default("analyze.impossibility-issues", defaults.impossibility_issues)?
-            .set_default("analyze.ambiguity-issues", defaults.ambiguity_issues)?
-            .set_default("analyze.existence-issues", defaults.existence_issues)?
-            .set_default("analyze.template-issues", defaults.template_issues)?
-            .set_default("analyze.argument-issues", defaults.argument_issues)?
-            .set_default("analyze.operand-issues", defaults.operand_issues)?
-            .set_default("analyze.property-issues", defaults.property_issues)?
-            .set_default("analyze.generator-issues", defaults.generator_issues)?
-            .set_default("analyze.array-issues", defaults.array_issues)?
-            .set_default("analyze.return-issues", defaults.return_issues)?
-            .set_default("analyze.method-issues", defaults.method_issues)?
-            .set_default("analyze.iterator-issues", defaults.iterator_issues)?
-            .set_default("analyze.find-unused-definitions", defaults.find_unused_definitions)?
-            .set_default("analyze.find-unused-expressions", defaults.find_unused_expressions)?
-            .set_default("analyze.analyze-dead-code", defaults.analyze_dead_code)?
-            .set_default("analyze.memoize-properties", defaults.memoize_properties)?
-            .set_default("analyze.allow-possibly-undefined-array-keys", defaults.allow_possibly_undefined_array_keys)?
-            .set_default("analyze.check-throws", defaults.check_throws)?
-            .set_default("analyze.perform-heuristic-checks", defaults.perform_heuristic_checks)
-            .map_err(Error::from)
-    }
-}
-
 impl Default for AnalyzerConfiguration {
     fn default() -> Self {
         let defaults = Settings::default();

src/config/formatter.rs

@@ -1,15 +1,8 @@
-use config::ConfigBuilder;
-use config::Value;
-use config::ValueKind;
-use config::builder::BuilderState;
 use serde::Deserialize;
 use serde::Serialize;
 
 use mago_formatter::settings::*;
 
-use crate::config::ConfigurationEntry;
-use crate::error::Error;
-
 /// Configuration options for formatting source code.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "kebab-case", deny_unknown_fields)]
@@ -22,9 +15,3 @@ pub struct FormatterConfiguration {
     #[serde(flatten)]
     pub settings: FormatSettings,
 }
-
-impl ConfigurationEntry for FormatterConfiguration {
-    fn configure<St: BuilderState>(self, builder: ConfigBuilder<St>) -> Result<ConfigBuilder<St>, Error> {
-        builder.set_default("format.excludes", Value::new(None, ValueKind::Array(vec![]))).map_err(Error::from)
-    }
-}

src/config/linter.rs

@@ -1,16 +1,11 @@
-use config::ConfigBuilder;
-use config::builder::BuilderState;
-use mago_linter::integration::Integration;
 use serde::Deserialize;
 use serde::Serialize;
 
+use mago_linter::integration::Integration;
 use mago_linter::settings::RulesSettings;
 
-use crate::config::ConfigurationEntry;
-use crate::error::Error;
-
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+#[serde(default, rename_all = "kebab-case", deny_unknown_fields)]
 pub struct LinterConfiguration {
     /// A list of patterns to exclude from linting.
     pub excludes: Vec<String>,
@@ -21,17 +16,3 @@ pub struct LinterConfiguration {
     /// Settings for various linting rules.
     pub rules: RulesSettings,
 }
-
-impl ConfigurationEntry for LinterConfiguration {
-    fn configure<St: BuilderState>(self, builder: ConfigBuilder<St>) -> Result<ConfigBuilder<St>, Error> {
-        use ::config::Value;
-        use ::config::ValueKind;
-
-        let builder = builder
-            .set_default("linter.excludes", Value::new(None, ValueKind::Array(vec![])))?
-            .set_default("linter.integrations", Value::new(None, ValueKind::Array(vec![])))?
-            .set_default("linter.rules", Value::new(None, ValueKind::Table(Default::default())))?;
-
-        Ok(builder)
-    }
-}

src/config/mod.rs

@@ -2,20 +2,18 @@ use std::env::home_dir;
 use std::path::Path;
 use std::path::PathBuf;
 
-use analyzer::AnalyzerConfiguration;
 use config::Config;
-use config::ConfigBuilder;
 use config::Environment;
 use config::File;
 use config::FileFormat;
 use config::Value;
 use config::ValueKind;
-use config::builder::BuilderState;
 use serde::Deserialize;
+use serde::Serialize;
 
 use mago_php_version::PHPVersion;
-use serde::Serialize;
 
+use crate::config::analyzer::AnalyzerConfiguration;
 use crate::config::formatter::FormatterConfiguration;
 use crate::config::linter::LinterConfiguration;
 use crate::config::source::SourceConfiguration;
@@ -48,17 +46,14 @@ pub struct Configuration {
 
     /// Configuration options for the linter.
     #[serde(default)]
-    #[serde(alias = "lint")]
     pub linter: LinterConfiguration,
 
     /// Configuration options for the formatter.
     #[serde(default)]
-    #[serde(alias = "format")]
     pub formatter: FormatterConfiguration,
 
     /// Configuration options for the analyzer.
     #[serde(default)]
-    #[serde(alias = "analyser", alias = "analyze", alias = "analyse")]
     pub analyzer: AnalyzerConfiguration,
 
     /// The log filter.
@@ -68,7 +63,8 @@ pub struct Configuration {
     ///
     /// If this field is to be removed, serde will complain about an unknown field in the configuration
     /// when `MAGO_LOG` is set due to the `deny_unknown_fields` attribute and the use of `Environment` source.
-    #[serde(skip_serializing)]
+    #[serde(default, skip_serializing)]
+    #[allow(dead_code)]
     log: Value,
 }
 
@@ -106,29 +102,38 @@ impl Configuration {
         allow_unsupported_php_version: bool,
     ) -> Result<Configuration, Error> {
         let workspace_dir = workspace.clone().unwrap_or_else(|| CURRENT_DIR.to_path_buf());
+        let workspace_config_path = workspace_dir.join(CONFIGURATION_FILE);
+
+        let mut configuration = Configuration::from_workspace(workspace_dir);
+        let mut builder = Config::builder().add_source(Config::try_from(&configuration)?);
 
-        let mut builder = Config::builder();
         if let Some(file) = file {
+            tracing::debug!("Sourcing configuration from {}.", file.display());
+
             builder = builder.add_source(File::from(file).required(true).format(FileFormat::Toml));
         } else {
-            let global_config_roots =
-                [std::env::var_os("XDG_CONFIG_HOME").map(PathBuf::from), home_dir()].into_iter().flatten();
-
+            let global_config_roots = [std::env::var_os("XDG_CONFIG_HOME").map(PathBuf::from), home_dir()];
             for global_config_root in global_config_roots {
-                builder = builder.add_source(
-                    File::from(global_config_root.join(CONFIGURATION_FILE)).required(false).format(FileFormat::Toml),
-                );
-            }
+                let Some(global_config_root) = global_config_root else {
+                    continue;
+                };
 
-            builder = builder
-                .add_source(File::from(workspace_dir.join(CONFIGURATION_FILE)).required(false).format(FileFormat::Toml))
-        }
+                let global_config_path = global_config_root.join(CONFIGURATION_FILE);
 
-        builder = builder.add_source(Environment::with_prefix(ENVIRONMENT_PREFIX));
+                tracing::debug!("Sourcing global configuration from {}.", global_config_path.display());
 
-        let mut configuration = Configuration::from_workspace(workspace_dir);
+                builder = builder.add_source(File::from(global_config_path).required(false).format(FileFormat::Toml));
+            }
 
-        configuration = configuration.configure(builder)?.build()?.try_deserialize::<Configuration>()?;
+            tracing::debug!("Sourcing workspace configuration from {}.", workspace_config_path.display());
+
+            builder = builder.add_source(File::from(workspace_config_path).required(false).format(FileFormat::Toml));
+        }
+
+        configuration = builder
+            .add_source(Environment::with_prefix(ENVIRONMENT_PREFIX))
+            .build()?
+            .try_deserialize::<Configuration>()?;
 
         if allow_unsupported_php_version && !configuration.allow_unsupported_php_version {
             tracing::warn!("Allowing unsupported PHP versions.");
@@ -183,32 +188,7 @@ impl Configuration {
     }
 }
 
-trait ConfigurationEntry {
-    /// Configures the builder with the entry.
-    fn configure<St: BuilderState>(self, builder: ConfigBuilder<St>) -> Result<ConfigBuilder<St>, Error>;
-
-    fn normalize(&mut self) -> Result<(), Error> {
-        Ok(())
-    }
-}
-
-impl ConfigurationEntry for Configuration {
-    fn configure<St: BuilderState>(self, builder: ConfigBuilder<St>) -> Result<ConfigBuilder<St>, Error> {
-        let mut builder = builder
-            .set_default("threads", Value::new(None, ValueKind::U64(self.threads as u64)))?
-            .set_default("stack-size", Value::new(None, ValueKind::U64(self.stack_size as u64)))?
-            .set_default("php-version", Value::new(None, ValueKind::String(self.php_version.to_string())))?
-            .set_default("allow-unsupported-php-version", self.allow_unsupported_php_version)?
-            .set_default("log", self.log)?;
-
-        builder = self.source.configure(builder)?;
-        builder = self.linter.configure(builder)?;
-        builder = self.formatter.configure(builder)?;
-        builder = self.analyzer.configure(builder)?;
-
-        Ok(builder)
-    }
-
+impl Configuration {
     fn normalize(&mut self) -> Result<(), Error> {
         match self.threads {
             0 => {
@@ -252,9 +232,6 @@ impl ConfigurationEntry for Configuration {
         }
 
         self.source.normalize()?;
-        self.linter.normalize()?;
-        self.formatter.normalize()?;
-        self.analyzer.normalize()?;
 
         Ok(())
     }

src/config/source.rs

@@ -1,14 +1,10 @@
 use std::path::PathBuf;
 
-use config::ConfigBuilder;
-use config::Value;
-use config::ValueKind;
-use config::builder::BuilderState;
 use serde::Deserialize;
 use serde::Serialize;
 
 use crate::config::CURRENT_DIR;
-use crate::config::ConfigurationEntry;
+use crate::consts::PHP_EXTENSION;
 use crate::error::Error;
 
 /// Configuration options for source discovery.
@@ -25,21 +21,25 @@ pub struct SourceConfiguration {
     /// If empty, all files in the workspace directory are included.
     ///
     /// Defaults to `[]`.
+    #[serde(default)]
     pub paths: Vec<PathBuf>,
 
     /// Paths to non-user defined files to include in the scan.
     ///
     /// Defaults to `[]`.
+    #[serde(default)]
     pub includes: Vec<PathBuf>,
 
     /// Patterns to exclude from the scan.
     ///
     /// Defaults to `[]`.
+    #[serde(default)]
     pub excludes: Vec<String>,
 
     /// File extensions to filter by.
     ///
     /// Defaults to `[".php"]`.
+    #[serde(default = "default_extensions")]
     pub extensions: Vec<String>,
 }
 
@@ -54,28 +54,18 @@ impl SourceConfiguration {
     ///
     /// A new `SourceConfiguration` with the given workspace directory.
     pub fn from_workspace(workspace: PathBuf) -> Self {
-        Self { workspace, paths: vec![], includes: vec![], excludes: vec![], extensions: vec![] }
+        Self {
+            workspace,
+            paths: vec![],
+            includes: vec![],
+            excludes: vec![],
+            extensions: vec![PHP_EXTENSION.to_string()],
+        }
     }
 }
 
-impl ConfigurationEntry for SourceConfiguration {
-    fn configure<St: BuilderState>(self, builder: ConfigBuilder<St>) -> Result<ConfigBuilder<St>, Error> {
-        builder
-            .set_default(
-                "source.workspace",
-                Value::new(None, ValueKind::String(self.workspace.to_string_lossy().to_string())),
-            )?
-            .set_default("source.paths", Value::new(None, ValueKind::Array(vec![])))?
-            .set_default("source.includes", Value::new(None, ValueKind::Array(vec![])))?
-            .set_default("source.excludes", Value::new(None, ValueKind::Array(vec![])))?
-            .set_default(
-                "source.extensions",
-                Value::new(None, ValueKind::Array(vec![Value::new(None, ValueKind::String("php".to_string()))])),
-            )
-            .map_err(Error::from)
-    }
-
-    fn normalize(&mut self) -> Result<(), Error> {
+impl SourceConfiguration {
+    pub fn normalize(&mut self) -> Result<(), Error> {
         // Make workspace absolute if not already
         let workspace =
             if !self.workspace.is_absolute() { (*CURRENT_DIR).join(&self.workspace) } else { self.workspace.clone() };
@@ -85,3 +75,7 @@ impl ConfigurationEntry for SourceConfiguration {
         Ok(())
     }
 }
+
+fn default_extensions() -> Vec<String> {
+    vec![PHP_EXTENSION.to_string()]
+}

src/consts.rs

@@ -21,6 +21,9 @@ pub const ARCHIVE_EXTENSION: &str = "zip";
 #[cfg(not(target_os = "windows"))]
 pub const ARCHIVE_EXTENSION: &str = "tar.gz";
 
+/// The extension for PHP files.
+pub const PHP_EXTENSION: &str = "php";
+
 /// The name of the repository owner.
 pub const REPO_OWNER: &str = "carthage-software";