rumdl 0.0.77__tar.gz → 0.0.79__tar.gz

{rumdl-0.0.77 → rumdl-0.0.79}/Cargo.lock

@@ -1783,7 +1783,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.77"
+version = "0.0.79"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.77 → rumdl-0.0.79}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.77"
+version = "0.0.79"
 edition = "2021"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
 authors = ["Ruben J. Jongejan <ruben.jongejan@gmail.com>"]

{rumdl-0.0.77 → rumdl-0.0.79}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rumdl
-Version: 0.0.77
+Version: 0.0.79
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{rumdl-0.0.77 → rumdl-0.0.79}/src/config.rs

@@ -697,7 +697,7 @@ impl SourcedConfig {
         }
     }
 
-    /// Load and merge configurations from files and CLI overrides.
+        /// Load and merge configurations from files and CLI overrides.
     pub fn load(
         config_path: Option<&str>,
         cli_overrides: Option<&SourcedGlobalConfig>,

{rumdl-0.0.77 → rumdl-0.0.79}/src/lsp/server.rs

@@ -119,6 +119,57 @@ impl RumdlLanguageServer {
             }
         }
     }
+
+        /// Load or reload rumdl configuration from files
+    async fn load_configuration(&self, notify_client: bool) {
+        let config_guard = self.config.read().await;
+        let explicit_config_path = config_guard.config_path.clone();
+        drop(config_guard);
+
+        // Use the same discovery logic as CLI but with LSP-specific error handling
+        match Self::load_config_for_lsp(explicit_config_path.as_deref()) {
+            Ok(sourced_config) => {
+                let loaded_files = sourced_config.loaded_files.clone();
+                *self.rumdl_config.write().await = sourced_config.into();
+
+                if !loaded_files.is_empty() {
+                    let message = format!("Loaded rumdl config from: {}", loaded_files.join(", "));
+                    log::info!("{}", message);
+                    if notify_client {
+                        self.client
+                            .log_message(MessageType::INFO, &message)
+                            .await;
+                    }
+                } else {
+                    log::info!("Using default rumdl configuration (no config files found)");
+                }
+            }
+            Err(e) => {
+                let message = format!("Failed to load rumdl config: {}", e);
+                log::warn!("{}", message);
+                if notify_client {
+                    self.client
+                        .log_message(MessageType::WARNING, &message)
+                        .await;
+                }
+                // Use default configuration
+                *self.rumdl_config.write().await = crate::config::Config::default();
+            }
+        }
+    }
+
+    /// Reload rumdl configuration from files (with client notification)
+    async fn reload_configuration(&self) {
+        self.load_configuration(true).await;
+    }
+
+    /// Load configuration for LSP - similar to CLI loading but returns Result
+    fn load_config_for_lsp(
+        config_path: Option<&str>,
+    ) -> Result<crate::config::SourcedConfig, crate::config::ConfigError> {
+        // Use the same configuration loading as the CLI
+        crate::config::SourcedConfig::load_with_discovery(config_path, None, false)
+    }
 }
 
 #[tower_lsp::async_trait]
@@ -133,20 +184,8 @@ impl LanguageServer for RumdlLanguageServer {
             }
         }
 
-        // Load rumdl configuration if specified
-        let config_guard = self.config.read().await;
-        if let Some(config_path) = &config_guard.config_path {
-            match crate::config::SourcedConfig::load(Some(config_path), None) {
-                Ok(sourced_config) => {
-                    *self.rumdl_config.write().await = sourced_config.into();
-                    log::info!("Loaded rumdl config from: {}", config_path);
-                }
-                Err(e) => {
-                    log::warn!("Failed to load config from {}: {}", config_path, e);
-                }
-            }
-        }
-        drop(config_guard);
+        // Load rumdl configuration with auto-discovery
+        self.load_configuration(false).await;
 
         Ok(InitializeResult {
             capabilities: ServerCapabilities {
@@ -186,6 +225,13 @@ impl LanguageServer for RumdlLanguageServer {
             .await;
     }
 
+    async fn did_change_workspace_folders(&self, _params: DidChangeWorkspaceFoldersParams) {
+        // Reload configuration when workspace folders change
+        self.reload_configuration().await;
+    }
+
+
+
     async fn shutdown(&self) -> JsonRpcResult<()> {
         log::info!("Shutting down rumdl Language Server");
         Ok(())

{rumdl-0.0.77 → rumdl-0.0.79}/src/main.rs

@@ -47,6 +47,21 @@ fn read_file_efficiently(path: &Path) -> Result<String, Box<dyn Error>> {
     }
 }
 
+/// Utility function to load configuration with standard CLI error handling.
+/// This eliminates duplication between different CLI commands that load configuration.
+fn load_config_with_cli_error_handling(
+    config_path: Option<&str>,
+    no_config: bool,
+) -> rumdl_config::SourcedConfig {
+    match rumdl_config::SourcedConfig::load_with_discovery(config_path, None, no_config) {
+        Ok(config) => config,
+        Err(e) => {
+            eprintln!("{}: {}", "Config error".red().bold(), e);
+            std::process::exit(1);
+        }
+    }
+}
+
 #[derive(Parser)]
 #[command(author, version, about, long_about = None)]
 struct Cli {
@@ -164,6 +179,8 @@ enum Commands {
 enum ConfigSubcommand {
     /// Query a specific config key (e.g. global.exclude or MD013.line_length)
     Get { key: String },
+    /// Show the absolute path of the configuration file that was loaded
+    File,
 }
 
 #[derive(Args, Debug)]
@@ -951,7 +968,7 @@ build-backend = \"setuptools.build_meta\"
                 defaults,
                 output,
             }) => {
-                // Handle 'config get' subcommand for querying a specific key
+                // Handle config subcommands
                 if let Some(ConfigSubcommand::Get { key }) = subcmd {
                     if let Some((section_part, field_part)) = key.split_once('.') {
                         // 1. Load the full SourcedConfig once
@@ -1096,6 +1113,32 @@ build-backend = \"setuptools.build_meta\"
                         std::process::exit(1);
                     }
                 }
+                // Handle 'config file' subcommand for showing config file path
+                else if let Some(ConfigSubcommand::File) = subcmd {
+                    let sourced = load_config_with_cli_error_handling(cli.config.as_deref(), cli.no_config);
+
+                    if sourced.loaded_files.is_empty() {
+                        if cli.no_config {
+                            println!("No configuration file loaded (--no-config specified)");
+                        } else {
+                            println!("No configuration file found (using defaults)");
+                        }
+                    } else {
+                        // Convert relative paths to absolute paths
+                        for file_path in &sourced.loaded_files {
+                            match std::fs::canonicalize(file_path) {
+                                Ok(absolute_path) => {
+                                    println!("{}", absolute_path.display());
+                                }
+                                Err(_) => {
+                                    // If canonicalize fails, it might be a file that doesn't exist anymore
+                                    // or a relative path that can't be resolved. Just print as-is.
+                                    println!("{}", file_path);
+                                }
+                            }
+                        }
+                    }
+                }
                 // --- Fallthrough logic for `rumdl config` (no subcommand) ---
                 // This code now runs ONLY if `subcmd` is None
                 else {
@@ -1105,17 +1148,7 @@ build-backend = \"setuptools.build_meta\"
                     let sourced_reg = if *defaults {
                         rumdl_config::SourcedConfig::default()
                     } else {
-                        match rumdl_config::SourcedConfig::load_with_discovery(
-                            cli.config.as_deref(),
-                            None,
-                            cli.no_config,
-                        ) {
-                            Ok(s) => s,
-                            Err(e) => {
-                                eprintln!("{}: {}", "Config error".red().bold(), e);
-                                std::process::exit(1);
-                            }
-                        }
+                        load_config_with_cli_error_handling(cli.config.as_deref(), cli.no_config)
                     };
                     let validation_warnings =
                         rumdl_config::validate_config_sourced(&sourced_reg, &registry_reg);
@@ -1133,17 +1166,7 @@ build-backend = \"setuptools.build_meta\"
                         rumdl_config::SourcedConfig::default()
                     } else {
                         // Reload config if not defaults (necessary because we exited early in 'get' case)
-                        match rumdl_config::SourcedConfig::load_with_discovery(
-                            cli.config.as_deref(),
-                            None,
-                            cli.no_config,
-                        ) {
-                            Ok(s) => s,
-                            Err(e) => {
-                                eprintln!("{}: {}", "Config error".red().bold(), e);
-                                std::process::exit(1);
-                            }
-                        }
+                        load_config_with_cli_error_handling(cli.config.as_deref(), cli.no_config)
                     };
 
                     // If --output toml is set, print as valid TOML
@@ -1325,16 +1348,7 @@ fn process_stdin(rules: &[Box<dyn Rule>], args: &CheckArgs) {
 
 fn run_check(args: &CheckArgs, global_config_path: Option<&str>, no_config: bool) {
     // 1. Load sourced config (for provenance and validation)
-    let sourced =
-        match rumdl_config::SourcedConfig::load_with_discovery(global_config_path, None, no_config)
-        {
-            Ok(sourced) => sourced,
-            Err(e) => {
-                // Syntax error or type mismatch: fail and exit
-                eprintln!("{}: {}", "Config error".red().bold(), e);
-                std::process::exit(1);
-            }
-        };
+    let sourced = load_config_with_cli_error_handling(global_config_path, no_config);
 
     // 2. Validate config (unknown keys/rules/options)
     let all_rules = rumdl::rules::all_rules(&rumdl_config::Config::default());